docusign_esign.apis.envelopes_api
Docusign eSignature REST API
The Docusign eSignature REST API provides you with a powerful, convenient, and simple Web services API for interacting with Docusign. # noqa: E501
OpenAPI spec version: v2.1 Contact: devcenter@docusign.com Generated by: https://github.com/swagger-api/swagger-codegen.git
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 EnvelopesApi(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 apply_template(self, account_id, envelope_id, **kwargs): 44 """ 45 Adds templates to an envelope. 46 Adds templates to the specified envelope. 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.apply_template(account_id, envelope_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 str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 59 :param str preserve_template_recipient: 60 :param DocumentTemplateList document_template_list: 61 :return: DocumentTemplateList 62 If the method is called asynchronously, 63 returns the request thread. 64 """ 65 kwargs['_return_http_data_only'] = True 66 if kwargs.get('callback'): 67 return self.apply_template_with_http_info(account_id, envelope_id, **kwargs) 68 else: 69 (data) = self.apply_template_with_http_info(account_id, envelope_id, **kwargs) 70 return data 71 72 def apply_template_with_http_info(self, account_id, envelope_id, **kwargs): 73 """ 74 Adds templates to an envelope. 75 Adds templates to the specified envelope. 76 This method makes a synchronous HTTP request by default. To make an 77 asynchronous HTTP request, please define a `callback` function 78 to be invoked when receiving the response. 79 >>> def callback_function(response): 80 >>> pprint(response) 81 >>> 82 >>> thread = api.apply_template_with_http_info(account_id, envelope_id, callback=callback_function) 83 84 :param callback function: The callback function 85 for asynchronous request. (optional) 86 :param str account_id: The external account number (int) or account ID Guid. (required) 87 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 88 :param str preserve_template_recipient: 89 :param DocumentTemplateList document_template_list: 90 :return: DocumentTemplateList 91 If the method is called asynchronously, 92 returns the request thread. 93 """ 94 95 all_params = ['account_id', 'envelope_id', 'preserve_template_recipient', 'document_template_list'] 96 all_params.append('callback') 97 all_params.append('_return_http_data_only') 98 all_params.append('_preload_content') 99 all_params.append('_request_timeout') 100 101 params = locals() 102 for key, val in iteritems(params['kwargs']): 103 if key not in all_params: 104 raise TypeError( 105 "Got an unexpected keyword argument '%s'" 106 " to method apply_template" % key 107 ) 108 params[key] = val 109 del params['kwargs'] 110 # verify the required parameter 'account_id' is set 111 if ('account_id' not in params) or (params['account_id'] is None): 112 raise ValueError("Missing the required parameter `account_id` when calling `apply_template`") 113 # verify the required parameter 'envelope_id' is set 114 if ('envelope_id' not in params) or (params['envelope_id'] is None): 115 raise ValueError("Missing the required parameter `envelope_id` when calling `apply_template`") 116 117 118 collection_formats = {} 119 120 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/templates'.replace('{format}', 'json') 121 path_params = {} 122 if 'account_id' in params: 123 path_params['accountId'] = params['account_id'] 124 if 'envelope_id' in params: 125 path_params['envelopeId'] = params['envelope_id'] 126 127 query_params = {} 128 if 'preserve_template_recipient' in params: 129 query_params['preserve_template_recipient'] = params['preserve_template_recipient'] 130 131 header_params = {} 132 133 form_params = [] 134 local_var_files = {} 135 136 body_params = None 137 if 'document_template_list' in params: 138 body_params = params['document_template_list'] 139 # HTTP header `Accept` 140 header_params['Accept'] = self.api_client.\ 141 select_header_accept(['application/json']) 142 143 # Authentication setting 144 auth_settings = [] 145 146 return self.api_client.call_api(resource_path, 'POST', 147 path_params, 148 query_params, 149 header_params, 150 body=body_params, 151 post_params=form_params, 152 files=local_var_files, 153 response_type='DocumentTemplateList', 154 auth_settings=auth_settings, 155 callback=params.get('callback'), 156 _return_http_data_only=params.get('_return_http_data_only'), 157 _preload_content=params.get('_preload_content', True), 158 _request_timeout=params.get('_request_timeout'), 159 collection_formats=collection_formats) 160 161 def apply_template_to_document(self, account_id, document_id, envelope_id, **kwargs): 162 """ 163 Adds templates to a document in an envelope. 164 Adds templates to a document in the specified envelope. 165 This method makes a synchronous HTTP request by default. To make an 166 asynchronous HTTP request, please define a `callback` function 167 to be invoked when receiving the response. 168 >>> def callback_function(response): 169 >>> pprint(response) 170 >>> 171 >>> thread = api.apply_template_to_document(account_id, document_id, envelope_id, callback=callback_function) 172 173 :param callback function: The callback function 174 for asynchronous request. (optional) 175 :param str account_id: The external account number (int) or account ID Guid. (required) 176 :param str document_id: The ID of the document being accessed. (required) 177 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 178 :param str preserve_template_recipient: 179 :param DocumentTemplateList document_template_list: 180 :return: DocumentTemplateList 181 If the method is called asynchronously, 182 returns the request thread. 183 """ 184 kwargs['_return_http_data_only'] = True 185 if kwargs.get('callback'): 186 return self.apply_template_to_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 187 else: 188 (data) = self.apply_template_to_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 189 return data 190 191 def apply_template_to_document_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 192 """ 193 Adds templates to a document in an envelope. 194 Adds templates to a document in the specified envelope. 195 This method makes a synchronous HTTP request by default. To make an 196 asynchronous HTTP request, please define a `callback` function 197 to be invoked when receiving the response. 198 >>> def callback_function(response): 199 >>> pprint(response) 200 >>> 201 >>> thread = api.apply_template_to_document_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 202 203 :param callback function: The callback function 204 for asynchronous request. (optional) 205 :param str account_id: The external account number (int) or account ID Guid. (required) 206 :param str document_id: The ID of the document being accessed. (required) 207 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 208 :param str preserve_template_recipient: 209 :param DocumentTemplateList document_template_list: 210 :return: DocumentTemplateList 211 If the method is called asynchronously, 212 returns the request thread. 213 """ 214 215 all_params = ['account_id', 'document_id', 'envelope_id', 'preserve_template_recipient', 'document_template_list'] 216 all_params.append('callback') 217 all_params.append('_return_http_data_only') 218 all_params.append('_preload_content') 219 all_params.append('_request_timeout') 220 221 params = locals() 222 for key, val in iteritems(params['kwargs']): 223 if key not in all_params: 224 raise TypeError( 225 "Got an unexpected keyword argument '%s'" 226 " to method apply_template_to_document" % key 227 ) 228 params[key] = val 229 del params['kwargs'] 230 # verify the required parameter 'account_id' is set 231 if ('account_id' not in params) or (params['account_id'] is None): 232 raise ValueError("Missing the required parameter `account_id` when calling `apply_template_to_document`") 233 # verify the required parameter 'document_id' is set 234 if ('document_id' not in params) or (params['document_id'] is None): 235 raise ValueError("Missing the required parameter `document_id` when calling `apply_template_to_document`") 236 # verify the required parameter 'envelope_id' is set 237 if ('envelope_id' not in params) or (params['envelope_id'] is None): 238 raise ValueError("Missing the required parameter `envelope_id` when calling `apply_template_to_document`") 239 240 241 collection_formats = {} 242 243 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/templates'.replace('{format}', 'json') 244 path_params = {} 245 if 'account_id' in params: 246 path_params['accountId'] = params['account_id'] 247 if 'document_id' in params: 248 path_params['documentId'] = params['document_id'] 249 if 'envelope_id' in params: 250 path_params['envelopeId'] = params['envelope_id'] 251 252 query_params = {} 253 if 'preserve_template_recipient' in params: 254 query_params['preserve_template_recipient'] = params['preserve_template_recipient'] 255 256 header_params = {} 257 258 form_params = [] 259 local_var_files = {} 260 261 body_params = None 262 if 'document_template_list' in params: 263 body_params = params['document_template_list'] 264 # HTTP header `Accept` 265 header_params['Accept'] = self.api_client.\ 266 select_header_accept(['application/json']) 267 268 # Authentication setting 269 auth_settings = [] 270 271 return self.api_client.call_api(resource_path, 'POST', 272 path_params, 273 query_params, 274 header_params, 275 body=body_params, 276 post_params=form_params, 277 files=local_var_files, 278 response_type='DocumentTemplateList', 279 auth_settings=auth_settings, 280 callback=params.get('callback'), 281 _return_http_data_only=params.get('_return_http_data_only'), 282 _preload_content=params.get('_preload_content', True), 283 _request_timeout=params.get('_request_timeout'), 284 collection_formats=collection_formats) 285 286 def create_chunked_upload(self, account_id, **kwargs): 287 """ 288 Initiate a new ChunkedUpload. 289 This method initiates a new chunked upload with the first part of the content. 290 This method makes a synchronous HTTP request by default. To make an 291 asynchronous HTTP request, please define a `callback` function 292 to be invoked when receiving the response. 293 >>> def callback_function(response): 294 >>> pprint(response) 295 >>> 296 >>> thread = api.create_chunked_upload(account_id, callback=callback_function) 297 298 :param callback function: The callback function 299 for asynchronous request. (optional) 300 :param str account_id: The external account number (int) or account ID Guid. (required) 301 :param ChunkedUploadRequest chunked_upload_request: 302 :return: ChunkedUploadResponse 303 If the method is called asynchronously, 304 returns the request thread. 305 """ 306 kwargs['_return_http_data_only'] = True 307 if kwargs.get('callback'): 308 return self.create_chunked_upload_with_http_info(account_id, **kwargs) 309 else: 310 (data) = self.create_chunked_upload_with_http_info(account_id, **kwargs) 311 return data 312 313 def create_chunked_upload_with_http_info(self, account_id, **kwargs): 314 """ 315 Initiate a new ChunkedUpload. 316 This method initiates a new chunked upload with the first part of the content. 317 This method makes a synchronous HTTP request by default. To make an 318 asynchronous HTTP request, please define a `callback` function 319 to be invoked when receiving the response. 320 >>> def callback_function(response): 321 >>> pprint(response) 322 >>> 323 >>> thread = api.create_chunked_upload_with_http_info(account_id, callback=callback_function) 324 325 :param callback function: The callback function 326 for asynchronous request. (optional) 327 :param str account_id: The external account number (int) or account ID Guid. (required) 328 :param ChunkedUploadRequest chunked_upload_request: 329 :return: ChunkedUploadResponse 330 If the method is called asynchronously, 331 returns the request thread. 332 """ 333 334 all_params = ['account_id', 'chunked_upload_request'] 335 all_params.append('callback') 336 all_params.append('_return_http_data_only') 337 all_params.append('_preload_content') 338 all_params.append('_request_timeout') 339 340 params = locals() 341 for key, val in iteritems(params['kwargs']): 342 if key not in all_params: 343 raise TypeError( 344 "Got an unexpected keyword argument '%s'" 345 " to method create_chunked_upload" % key 346 ) 347 params[key] = val 348 del params['kwargs'] 349 # verify the required parameter 'account_id' is set 350 if ('account_id' not in params) or (params['account_id'] is None): 351 raise ValueError("Missing the required parameter `account_id` when calling `create_chunked_upload`") 352 353 354 collection_formats = {} 355 356 resource_path = '/v2.1/accounts/{accountId}/chunked_uploads'.replace('{format}', 'json') 357 path_params = {} 358 if 'account_id' in params: 359 path_params['accountId'] = params['account_id'] 360 361 query_params = {} 362 363 header_params = {} 364 365 form_params = [] 366 local_var_files = {} 367 368 body_params = None 369 if 'chunked_upload_request' in params: 370 body_params = params['chunked_upload_request'] 371 # HTTP header `Accept` 372 header_params['Accept'] = self.api_client.\ 373 select_header_accept(['application/json']) 374 375 # Authentication setting 376 auth_settings = [] 377 378 return self.api_client.call_api(resource_path, 'POST', 379 path_params, 380 query_params, 381 header_params, 382 body=body_params, 383 post_params=form_params, 384 files=local_var_files, 385 response_type='ChunkedUploadResponse', 386 auth_settings=auth_settings, 387 callback=params.get('callback'), 388 _return_http_data_only=params.get('_return_http_data_only'), 389 _preload_content=params.get('_preload_content', True), 390 _request_timeout=params.get('_request_timeout'), 391 collection_formats=collection_formats) 392 393 def create_console_view(self, account_id, **kwargs): 394 """ 395 Returns a URL to the authentication view UI. 396 Returns a URL that allows you to embed the authentication view of the DocuSign UI in your applications. 397 This method makes a synchronous HTTP request by default. To make an 398 asynchronous HTTP request, please define a `callback` function 399 to be invoked when receiving the response. 400 >>> def callback_function(response): 401 >>> pprint(response) 402 >>> 403 >>> thread = api.create_console_view(account_id, callback=callback_function) 404 405 :param callback function: The callback function 406 for asynchronous request. (optional) 407 :param str account_id: The external account number (int) or account ID Guid. (required) 408 :param ConsoleViewRequest console_view_request: 409 :return: ViewUrl 410 If the method is called asynchronously, 411 returns the request thread. 412 """ 413 kwargs['_return_http_data_only'] = True 414 if kwargs.get('callback'): 415 return self.create_console_view_with_http_info(account_id, **kwargs) 416 else: 417 (data) = self.create_console_view_with_http_info(account_id, **kwargs) 418 return data 419 420 def create_console_view_with_http_info(self, account_id, **kwargs): 421 """ 422 Returns a URL to the authentication view UI. 423 Returns a URL that allows you to embed the authentication view of the DocuSign UI in your applications. 424 This method makes a synchronous HTTP request by default. To make an 425 asynchronous HTTP request, please define a `callback` function 426 to be invoked when receiving the response. 427 >>> def callback_function(response): 428 >>> pprint(response) 429 >>> 430 >>> thread = api.create_console_view_with_http_info(account_id, callback=callback_function) 431 432 :param callback function: The callback function 433 for asynchronous request. (optional) 434 :param str account_id: The external account number (int) or account ID Guid. (required) 435 :param ConsoleViewRequest console_view_request: 436 :return: ViewUrl 437 If the method is called asynchronously, 438 returns the request thread. 439 """ 440 441 all_params = ['account_id', 'console_view_request'] 442 all_params.append('callback') 443 all_params.append('_return_http_data_only') 444 all_params.append('_preload_content') 445 all_params.append('_request_timeout') 446 447 params = locals() 448 for key, val in iteritems(params['kwargs']): 449 if key not in all_params: 450 raise TypeError( 451 "Got an unexpected keyword argument '%s'" 452 " to method create_console_view" % key 453 ) 454 params[key] = val 455 del params['kwargs'] 456 # verify the required parameter 'account_id' is set 457 if ('account_id' not in params) or (params['account_id'] is None): 458 raise ValueError("Missing the required parameter `account_id` when calling `create_console_view`") 459 460 461 collection_formats = {} 462 463 resource_path = '/v2.1/accounts/{accountId}/views/console'.replace('{format}', 'json') 464 path_params = {} 465 if 'account_id' in params: 466 path_params['accountId'] = params['account_id'] 467 468 query_params = {} 469 470 header_params = {} 471 472 form_params = [] 473 local_var_files = {} 474 475 body_params = None 476 if 'console_view_request' in params: 477 body_params = params['console_view_request'] 478 # HTTP header `Accept` 479 header_params['Accept'] = self.api_client.\ 480 select_header_accept(['application/json']) 481 482 # Authentication setting 483 auth_settings = [] 484 485 return self.api_client.call_api(resource_path, 'POST', 486 path_params, 487 query_params, 488 header_params, 489 body=body_params, 490 post_params=form_params, 491 files=local_var_files, 492 response_type='ViewUrl', 493 auth_settings=auth_settings, 494 callback=params.get('callback'), 495 _return_http_data_only=params.get('_return_http_data_only'), 496 _preload_content=params.get('_preload_content', True), 497 _request_timeout=params.get('_request_timeout'), 498 collection_formats=collection_formats) 499 500 def create_correct_view(self, account_id, envelope_id, **kwargs): 501 """ 502 Returns a URL to the envelope correction UI. 503 Returns a URL that allows you to embed the envelope correction view of the DocuSign UI in your applications. Important: iFrames should not be used for embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends using a WebView. 504 This method makes a synchronous HTTP request by default. To make an 505 asynchronous HTTP request, please define a `callback` function 506 to be invoked when receiving the response. 507 >>> def callback_function(response): 508 >>> pprint(response) 509 >>> 510 >>> thread = api.create_correct_view(account_id, envelope_id, callback=callback_function) 511 512 :param callback function: The callback function 513 for asynchronous request. (optional) 514 :param str account_id: The external account number (int) or account ID Guid. (required) 515 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 516 :param EnvelopeViewRequest envelope_view_request: 517 :return: ViewUrl 518 If the method is called asynchronously, 519 returns the request thread. 520 """ 521 kwargs['_return_http_data_only'] = True 522 if kwargs.get('callback'): 523 return self.create_correct_view_with_http_info(account_id, envelope_id, **kwargs) 524 else: 525 (data) = self.create_correct_view_with_http_info(account_id, envelope_id, **kwargs) 526 return data 527 528 def create_correct_view_with_http_info(self, account_id, envelope_id, **kwargs): 529 """ 530 Returns a URL to the envelope correction UI. 531 Returns a URL that allows you to embed the envelope correction view of the DocuSign UI in your applications. Important: iFrames should not be used for embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends using a WebView. 532 This method makes a synchronous HTTP request by default. To make an 533 asynchronous HTTP request, please define a `callback` function 534 to be invoked when receiving the response. 535 >>> def callback_function(response): 536 >>> pprint(response) 537 >>> 538 >>> thread = api.create_correct_view_with_http_info(account_id, envelope_id, callback=callback_function) 539 540 :param callback function: The callback function 541 for asynchronous request. (optional) 542 :param str account_id: The external account number (int) or account ID Guid. (required) 543 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 544 :param EnvelopeViewRequest envelope_view_request: 545 :return: ViewUrl 546 If the method is called asynchronously, 547 returns the request thread. 548 """ 549 550 all_params = ['account_id', 'envelope_id', 'envelope_view_request'] 551 all_params.append('callback') 552 all_params.append('_return_http_data_only') 553 all_params.append('_preload_content') 554 all_params.append('_request_timeout') 555 556 params = locals() 557 for key, val in iteritems(params['kwargs']): 558 if key not in all_params: 559 raise TypeError( 560 "Got an unexpected keyword argument '%s'" 561 " to method create_correct_view" % key 562 ) 563 params[key] = val 564 del params['kwargs'] 565 # verify the required parameter 'account_id' is set 566 if ('account_id' not in params) or (params['account_id'] is None): 567 raise ValueError("Missing the required parameter `account_id` when calling `create_correct_view`") 568 # verify the required parameter 'envelope_id' is set 569 if ('envelope_id' not in params) or (params['envelope_id'] is None): 570 raise ValueError("Missing the required parameter `envelope_id` when calling `create_correct_view`") 571 572 573 collection_formats = {} 574 575 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/correct'.replace('{format}', 'json') 576 path_params = {} 577 if 'account_id' in params: 578 path_params['accountId'] = params['account_id'] 579 if 'envelope_id' in params: 580 path_params['envelopeId'] = params['envelope_id'] 581 582 query_params = {} 583 584 header_params = {} 585 586 form_params = [] 587 local_var_files = {} 588 589 body_params = None 590 if 'envelope_view_request' in params: 591 body_params = params['envelope_view_request'] 592 # HTTP header `Accept` 593 header_params['Accept'] = self.api_client.\ 594 select_header_accept(['application/json']) 595 596 # Authentication setting 597 auth_settings = [] 598 599 return self.api_client.call_api(resource_path, 'POST', 600 path_params, 601 query_params, 602 header_params, 603 body=body_params, 604 post_params=form_params, 605 files=local_var_files, 606 response_type='ViewUrl', 607 auth_settings=auth_settings, 608 callback=params.get('callback'), 609 _return_http_data_only=params.get('_return_http_data_only'), 610 _preload_content=params.get('_preload_content', True), 611 _request_timeout=params.get('_request_timeout'), 612 collection_formats=collection_formats) 613 614 def create_custom_fields(self, account_id, envelope_id, **kwargs): 615 """ 616 Updates envelope custom fields for an envelope. 617 Updates the envelope custom fields for draft and in-process envelopes. Each custom field used in an envelope must have a unique name. 618 This method makes a synchronous HTTP request by default. To make an 619 asynchronous HTTP request, please define a `callback` function 620 to be invoked when receiving the response. 621 >>> def callback_function(response): 622 >>> pprint(response) 623 >>> 624 >>> thread = api.create_custom_fields(account_id, envelope_id, callback=callback_function) 625 626 :param callback function: The callback function 627 for asynchronous request. (optional) 628 :param str account_id: The external account number (int) or account ID Guid. (required) 629 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 630 :param CustomFields custom_fields: 631 :return: CustomFields 632 If the method is called asynchronously, 633 returns the request thread. 634 """ 635 kwargs['_return_http_data_only'] = True 636 if kwargs.get('callback'): 637 return self.create_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 638 else: 639 (data) = self.create_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 640 return data 641 642 def create_custom_fields_with_http_info(self, account_id, envelope_id, **kwargs): 643 """ 644 Updates envelope custom fields for an envelope. 645 Updates the envelope custom fields for draft and in-process envelopes. Each custom field used in an envelope must have a unique name. 646 This method makes a synchronous HTTP request by default. To make an 647 asynchronous HTTP request, please define a `callback` function 648 to be invoked when receiving the response. 649 >>> def callback_function(response): 650 >>> pprint(response) 651 >>> 652 >>> thread = api.create_custom_fields_with_http_info(account_id, envelope_id, callback=callback_function) 653 654 :param callback function: The callback function 655 for asynchronous request. (optional) 656 :param str account_id: The external account number (int) or account ID Guid. (required) 657 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 658 :param CustomFields custom_fields: 659 :return: CustomFields 660 If the method is called asynchronously, 661 returns the request thread. 662 """ 663 664 all_params = ['account_id', 'envelope_id', 'custom_fields'] 665 all_params.append('callback') 666 all_params.append('_return_http_data_only') 667 all_params.append('_preload_content') 668 all_params.append('_request_timeout') 669 670 params = locals() 671 for key, val in iteritems(params['kwargs']): 672 if key not in all_params: 673 raise TypeError( 674 "Got an unexpected keyword argument '%s'" 675 " to method create_custom_fields" % key 676 ) 677 params[key] = val 678 del params['kwargs'] 679 # verify the required parameter 'account_id' is set 680 if ('account_id' not in params) or (params['account_id'] is None): 681 raise ValueError("Missing the required parameter `account_id` when calling `create_custom_fields`") 682 # verify the required parameter 'envelope_id' is set 683 if ('envelope_id' not in params) or (params['envelope_id'] is None): 684 raise ValueError("Missing the required parameter `envelope_id` when calling `create_custom_fields`") 685 686 687 collection_formats = {} 688 689 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/custom_fields'.replace('{format}', 'json') 690 path_params = {} 691 if 'account_id' in params: 692 path_params['accountId'] = params['account_id'] 693 if 'envelope_id' in params: 694 path_params['envelopeId'] = params['envelope_id'] 695 696 query_params = {} 697 698 header_params = {} 699 700 form_params = [] 701 local_var_files = {} 702 703 body_params = None 704 if 'custom_fields' in params: 705 body_params = params['custom_fields'] 706 # HTTP header `Accept` 707 header_params['Accept'] = self.api_client.\ 708 select_header_accept(['application/json']) 709 710 # Authentication setting 711 auth_settings = [] 712 713 return self.api_client.call_api(resource_path, 'POST', 714 path_params, 715 query_params, 716 header_params, 717 body=body_params, 718 post_params=form_params, 719 files=local_var_files, 720 response_type='CustomFields', 721 auth_settings=auth_settings, 722 callback=params.get('callback'), 723 _return_http_data_only=params.get('_return_http_data_only'), 724 _preload_content=params.get('_preload_content', True), 725 _request_timeout=params.get('_request_timeout'), 726 collection_formats=collection_formats) 727 728 def create_document_fields(self, account_id, document_id, envelope_id, **kwargs): 729 """ 730 Creates custom document fields in an existing envelope document. 731 Creates custom document fields in an existing envelope document. 732 This method makes a synchronous HTTP request by default. To make an 733 asynchronous HTTP request, please define a `callback` function 734 to be invoked when receiving the response. 735 >>> def callback_function(response): 736 >>> pprint(response) 737 >>> 738 >>> thread = api.create_document_fields(account_id, document_id, envelope_id, callback=callback_function) 739 740 :param callback function: The callback function 741 for asynchronous request. (optional) 742 :param str account_id: The external account number (int) or account ID Guid. (required) 743 :param str document_id: The ID of the document being accessed. (required) 744 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 745 :param DocumentFieldsInformation document_fields_information: 746 :return: DocumentFieldsInformation 747 If the method is called asynchronously, 748 returns the request thread. 749 """ 750 kwargs['_return_http_data_only'] = True 751 if kwargs.get('callback'): 752 return self.create_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 753 else: 754 (data) = self.create_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 755 return data 756 757 def create_document_fields_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 758 """ 759 Creates custom document fields in an existing envelope document. 760 Creates custom document fields in an existing envelope document. 761 This method makes a synchronous HTTP request by default. To make an 762 asynchronous HTTP request, please define a `callback` function 763 to be invoked when receiving the response. 764 >>> def callback_function(response): 765 >>> pprint(response) 766 >>> 767 >>> thread = api.create_document_fields_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 768 769 :param callback function: The callback function 770 for asynchronous request. (optional) 771 :param str account_id: The external account number (int) or account ID Guid. (required) 772 :param str document_id: The ID of the document being accessed. (required) 773 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 774 :param DocumentFieldsInformation document_fields_information: 775 :return: DocumentFieldsInformation 776 If the method is called asynchronously, 777 returns the request thread. 778 """ 779 780 all_params = ['account_id', 'document_id', 'envelope_id', 'document_fields_information'] 781 all_params.append('callback') 782 all_params.append('_return_http_data_only') 783 all_params.append('_preload_content') 784 all_params.append('_request_timeout') 785 786 params = locals() 787 for key, val in iteritems(params['kwargs']): 788 if key not in all_params: 789 raise TypeError( 790 "Got an unexpected keyword argument '%s'" 791 " to method create_document_fields" % key 792 ) 793 params[key] = val 794 del params['kwargs'] 795 # verify the required parameter 'account_id' is set 796 if ('account_id' not in params) or (params['account_id'] is None): 797 raise ValueError("Missing the required parameter `account_id` when calling `create_document_fields`") 798 # verify the required parameter 'document_id' is set 799 if ('document_id' not in params) or (params['document_id'] is None): 800 raise ValueError("Missing the required parameter `document_id` when calling `create_document_fields`") 801 # verify the required parameter 'envelope_id' is set 802 if ('envelope_id' not in params) or (params['envelope_id'] is None): 803 raise ValueError("Missing the required parameter `envelope_id` when calling `create_document_fields`") 804 805 806 collection_formats = {} 807 808 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/fields'.replace('{format}', 'json') 809 path_params = {} 810 if 'account_id' in params: 811 path_params['accountId'] = params['account_id'] 812 if 'document_id' in params: 813 path_params['documentId'] = params['document_id'] 814 if 'envelope_id' in params: 815 path_params['envelopeId'] = params['envelope_id'] 816 817 query_params = {} 818 819 header_params = {} 820 821 form_params = [] 822 local_var_files = {} 823 824 body_params = None 825 if 'document_fields_information' in params: 826 body_params = params['document_fields_information'] 827 # HTTP header `Accept` 828 header_params['Accept'] = self.api_client.\ 829 select_header_accept(['application/json']) 830 831 # Authentication setting 832 auth_settings = [] 833 834 return self.api_client.call_api(resource_path, 'POST', 835 path_params, 836 query_params, 837 header_params, 838 body=body_params, 839 post_params=form_params, 840 files=local_var_files, 841 response_type='DocumentFieldsInformation', 842 auth_settings=auth_settings, 843 callback=params.get('callback'), 844 _return_http_data_only=params.get('_return_http_data_only'), 845 _preload_content=params.get('_preload_content', True), 846 _request_timeout=params.get('_request_timeout'), 847 collection_formats=collection_formats) 848 849 def create_document_responsive_html_preview(self, account_id, document_id, envelope_id, **kwargs): 850 """ 851 Get Responsive HTML Preview for a document in an envelope. 852 Creates a preview of the [responsive](/docs/esign-rest-api/esign101/concepts/responsive/) HTML version of a specific document. This method enables you to preview a PDF document conversion to responsive HTML across device types prior to sending. The request body is a `documentHtmlDefinition` object, which holds the responsive signing parameters that define how to generate the HTML version of the signing document. 853 This method makes a synchronous HTTP request by default. To make an 854 asynchronous HTTP request, please define a `callback` function 855 to be invoked when receiving the response. 856 >>> def callback_function(response): 857 >>> pprint(response) 858 >>> 859 >>> thread = api.create_document_responsive_html_preview(account_id, document_id, envelope_id, callback=callback_function) 860 861 :param callback function: The callback function 862 for asynchronous request. (optional) 863 :param str account_id: The external account number (int) or account ID Guid. (required) 864 :param str document_id: The ID of the document being accessed. (required) 865 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 866 :param DocumentHtmlDefinition document_html_definition: 867 :return: DocumentHtmlDefinitions 868 If the method is called asynchronously, 869 returns the request thread. 870 """ 871 kwargs['_return_http_data_only'] = True 872 if kwargs.get('callback'): 873 return self.create_document_responsive_html_preview_with_http_info(account_id, document_id, envelope_id, **kwargs) 874 else: 875 (data) = self.create_document_responsive_html_preview_with_http_info(account_id, document_id, envelope_id, **kwargs) 876 return data 877 878 def create_document_responsive_html_preview_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 879 """ 880 Get Responsive HTML Preview for a document in an envelope. 881 Creates a preview of the [responsive](/docs/esign-rest-api/esign101/concepts/responsive/) HTML version of a specific document. This method enables you to preview a PDF document conversion to responsive HTML across device types prior to sending. The request body is a `documentHtmlDefinition` object, which holds the responsive signing parameters that define how to generate the HTML version of the signing document. 882 This method makes a synchronous HTTP request by default. To make an 883 asynchronous HTTP request, please define a `callback` function 884 to be invoked when receiving the response. 885 >>> def callback_function(response): 886 >>> pprint(response) 887 >>> 888 >>> thread = api.create_document_responsive_html_preview_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 889 890 :param callback function: The callback function 891 for asynchronous request. (optional) 892 :param str account_id: The external account number (int) or account ID Guid. (required) 893 :param str document_id: The ID of the document being accessed. (required) 894 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 895 :param DocumentHtmlDefinition document_html_definition: 896 :return: DocumentHtmlDefinitions 897 If the method is called asynchronously, 898 returns the request thread. 899 """ 900 901 all_params = ['account_id', 'document_id', 'envelope_id', 'document_html_definition'] 902 all_params.append('callback') 903 all_params.append('_return_http_data_only') 904 all_params.append('_preload_content') 905 all_params.append('_request_timeout') 906 907 params = locals() 908 for key, val in iteritems(params['kwargs']): 909 if key not in all_params: 910 raise TypeError( 911 "Got an unexpected keyword argument '%s'" 912 " to method create_document_responsive_html_preview" % key 913 ) 914 params[key] = val 915 del params['kwargs'] 916 # verify the required parameter 'account_id' is set 917 if ('account_id' not in params) or (params['account_id'] is None): 918 raise ValueError("Missing the required parameter `account_id` when calling `create_document_responsive_html_preview`") 919 # verify the required parameter 'document_id' is set 920 if ('document_id' not in params) or (params['document_id'] is None): 921 raise ValueError("Missing the required parameter `document_id` when calling `create_document_responsive_html_preview`") 922 # verify the required parameter 'envelope_id' is set 923 if ('envelope_id' not in params) or (params['envelope_id'] is None): 924 raise ValueError("Missing the required parameter `envelope_id` when calling `create_document_responsive_html_preview`") 925 926 927 collection_formats = {} 928 929 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/responsive_html_preview'.replace('{format}', 'json') 930 path_params = {} 931 if 'account_id' in params: 932 path_params['accountId'] = params['account_id'] 933 if 'document_id' in params: 934 path_params['documentId'] = params['document_id'] 935 if 'envelope_id' in params: 936 path_params['envelopeId'] = params['envelope_id'] 937 938 query_params = {} 939 940 header_params = {} 941 942 form_params = [] 943 local_var_files = {} 944 945 body_params = None 946 if 'document_html_definition' in params: 947 body_params = params['document_html_definition'] 948 # HTTP header `Accept` 949 header_params['Accept'] = self.api_client.\ 950 select_header_accept(['application/json']) 951 952 # Authentication setting 953 auth_settings = [] 954 955 return self.api_client.call_api(resource_path, 'POST', 956 path_params, 957 query_params, 958 header_params, 959 body=body_params, 960 post_params=form_params, 961 files=local_var_files, 962 response_type='DocumentHtmlDefinitions', 963 auth_settings=auth_settings, 964 callback=params.get('callback'), 965 _return_http_data_only=params.get('_return_http_data_only'), 966 _preload_content=params.get('_preload_content', True), 967 _request_timeout=params.get('_request_timeout'), 968 collection_formats=collection_formats) 969 970 def create_document_tabs(self, account_id, document_id, envelope_id, **kwargs): 971 """ 972 Adds the tabs to an envelope document 973 Adds tabs to the document specified by `documentId` in the envelope specified by `envelopeId`. In the request body, you only need to specify the tabs that your are adding. For example, to add a text [prefill tab](/docs/esign-rest-api/reference/envelopes/envelopedocumenttabs/create/#definition__tabs_prefilltabs), your request body might look like this: ``` { \"prefillTabs\": { \"textTabs\": [ { \"value\": \"a prefill text tab\", \"pageNumber\": \"1\", \"documentId\": \"1\", \"xPosition\": 316, \"yPosition\": 97 } ] } } ``` 974 This method makes a synchronous HTTP request by default. To make an 975 asynchronous HTTP request, please define a `callback` function 976 to be invoked when receiving the response. 977 >>> def callback_function(response): 978 >>> pprint(response) 979 >>> 980 >>> thread = api.create_document_tabs(account_id, document_id, envelope_id, callback=callback_function) 981 982 :param callback function: The callback function 983 for asynchronous request. (optional) 984 :param str account_id: The external account number (int) or account ID Guid. (required) 985 :param str document_id: The ID of the document being accessed. (required) 986 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 987 :param Tabs tabs: 988 :return: Tabs 989 If the method is called asynchronously, 990 returns the request thread. 991 """ 992 kwargs['_return_http_data_only'] = True 993 if kwargs.get('callback'): 994 return self.create_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 995 else: 996 (data) = self.create_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 997 return data 998 999 def create_document_tabs_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 1000 """ 1001 Adds the tabs to an envelope document 1002 Adds tabs to the document specified by `documentId` in the envelope specified by `envelopeId`. In the request body, you only need to specify the tabs that your are adding. For example, to add a text [prefill tab](/docs/esign-rest-api/reference/envelopes/envelopedocumenttabs/create/#definition__tabs_prefilltabs), your request body might look like this: ``` { \"prefillTabs\": { \"textTabs\": [ { \"value\": \"a prefill text tab\", \"pageNumber\": \"1\", \"documentId\": \"1\", \"xPosition\": 316, \"yPosition\": 97 } ] } } ``` 1003 This method makes a synchronous HTTP request by default. To make an 1004 asynchronous HTTP request, please define a `callback` function 1005 to be invoked when receiving the response. 1006 >>> def callback_function(response): 1007 >>> pprint(response) 1008 >>> 1009 >>> thread = api.create_document_tabs_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 1010 1011 :param callback function: The callback function 1012 for asynchronous request. (optional) 1013 :param str account_id: The external account number (int) or account ID Guid. (required) 1014 :param str document_id: The ID of the document being accessed. (required) 1015 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1016 :param Tabs tabs: 1017 :return: Tabs 1018 If the method is called asynchronously, 1019 returns the request thread. 1020 """ 1021 1022 all_params = ['account_id', 'document_id', 'envelope_id', 'tabs'] 1023 all_params.append('callback') 1024 all_params.append('_return_http_data_only') 1025 all_params.append('_preload_content') 1026 all_params.append('_request_timeout') 1027 1028 params = locals() 1029 for key, val in iteritems(params['kwargs']): 1030 if key not in all_params: 1031 raise TypeError( 1032 "Got an unexpected keyword argument '%s'" 1033 " to method create_document_tabs" % key 1034 ) 1035 params[key] = val 1036 del params['kwargs'] 1037 # verify the required parameter 'account_id' is set 1038 if ('account_id' not in params) or (params['account_id'] is None): 1039 raise ValueError("Missing the required parameter `account_id` when calling `create_document_tabs`") 1040 # verify the required parameter 'document_id' is set 1041 if ('document_id' not in params) or (params['document_id'] is None): 1042 raise ValueError("Missing the required parameter `document_id` when calling `create_document_tabs`") 1043 # verify the required parameter 'envelope_id' is set 1044 if ('envelope_id' not in params) or (params['envelope_id'] is None): 1045 raise ValueError("Missing the required parameter `envelope_id` when calling `create_document_tabs`") 1046 1047 1048 collection_formats = {} 1049 1050 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/tabs'.replace('{format}', 'json') 1051 path_params = {} 1052 if 'account_id' in params: 1053 path_params['accountId'] = params['account_id'] 1054 if 'document_id' in params: 1055 path_params['documentId'] = params['document_id'] 1056 if 'envelope_id' in params: 1057 path_params['envelopeId'] = params['envelope_id'] 1058 1059 query_params = {} 1060 1061 header_params = {} 1062 1063 form_params = [] 1064 local_var_files = {} 1065 1066 body_params = None 1067 if 'tabs' in params: 1068 body_params = params['tabs'] 1069 # HTTP header `Accept` 1070 header_params['Accept'] = self.api_client.\ 1071 select_header_accept(['application/json']) 1072 1073 # Authentication setting 1074 auth_settings = [] 1075 1076 return self.api_client.call_api(resource_path, 'POST', 1077 path_params, 1078 query_params, 1079 header_params, 1080 body=body_params, 1081 post_params=form_params, 1082 files=local_var_files, 1083 response_type='Tabs', 1084 auth_settings=auth_settings, 1085 callback=params.get('callback'), 1086 _return_http_data_only=params.get('_return_http_data_only'), 1087 _preload_content=params.get('_preload_content', True), 1088 _request_timeout=params.get('_request_timeout'), 1089 collection_formats=collection_formats) 1090 1091 def create_edit_view(self, account_id, envelope_id, **kwargs): 1092 """ 1093 Returns a URL to the edit view UI. 1094 Returns a URL that allows you to embed the edit view of the DocuSign UI in your applications. This is a one-time use login token that allows the user to be placed into the DocuSign editing view. Upon sending completion, the user is returned to the return URL provided by the API application. Important: iFrames should not be used for embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends using a WebView. 1095 This method makes a synchronous HTTP request by default. To make an 1096 asynchronous HTTP request, please define a `callback` function 1097 to be invoked when receiving the response. 1098 >>> def callback_function(response): 1099 >>> pprint(response) 1100 >>> 1101 >>> thread = api.create_edit_view(account_id, envelope_id, callback=callback_function) 1102 1103 :param callback function: The callback function 1104 for asynchronous request. (optional) 1105 :param str account_id: The external account number (int) or account ID Guid. (required) 1106 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1107 :param EnvelopeViewRequest envelope_view_request: 1108 :return: ViewUrl 1109 If the method is called asynchronously, 1110 returns the request thread. 1111 """ 1112 kwargs['_return_http_data_only'] = True 1113 if kwargs.get('callback'): 1114 return self.create_edit_view_with_http_info(account_id, envelope_id, **kwargs) 1115 else: 1116 (data) = self.create_edit_view_with_http_info(account_id, envelope_id, **kwargs) 1117 return data 1118 1119 def create_edit_view_with_http_info(self, account_id, envelope_id, **kwargs): 1120 """ 1121 Returns a URL to the edit view UI. 1122 Returns a URL that allows you to embed the edit view of the DocuSign UI in your applications. This is a one-time use login token that allows the user to be placed into the DocuSign editing view. Upon sending completion, the user is returned to the return URL provided by the API application. Important: iFrames should not be used for embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends using a WebView. 1123 This method makes a synchronous HTTP request by default. To make an 1124 asynchronous HTTP request, please define a `callback` function 1125 to be invoked when receiving the response. 1126 >>> def callback_function(response): 1127 >>> pprint(response) 1128 >>> 1129 >>> thread = api.create_edit_view_with_http_info(account_id, envelope_id, callback=callback_function) 1130 1131 :param callback function: The callback function 1132 for asynchronous request. (optional) 1133 :param str account_id: The external account number (int) or account ID Guid. (required) 1134 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1135 :param EnvelopeViewRequest envelope_view_request: 1136 :return: ViewUrl 1137 If the method is called asynchronously, 1138 returns the request thread. 1139 """ 1140 1141 all_params = ['account_id', 'envelope_id', 'envelope_view_request'] 1142 all_params.append('callback') 1143 all_params.append('_return_http_data_only') 1144 all_params.append('_preload_content') 1145 all_params.append('_request_timeout') 1146 1147 params = locals() 1148 for key, val in iteritems(params['kwargs']): 1149 if key not in all_params: 1150 raise TypeError( 1151 "Got an unexpected keyword argument '%s'" 1152 " to method create_edit_view" % key 1153 ) 1154 params[key] = val 1155 del params['kwargs'] 1156 # verify the required parameter 'account_id' is set 1157 if ('account_id' not in params) or (params['account_id'] is None): 1158 raise ValueError("Missing the required parameter `account_id` when calling `create_edit_view`") 1159 # verify the required parameter 'envelope_id' is set 1160 if ('envelope_id' not in params) or (params['envelope_id'] is None): 1161 raise ValueError("Missing the required parameter `envelope_id` when calling `create_edit_view`") 1162 1163 1164 collection_formats = {} 1165 1166 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/edit'.replace('{format}', 'json') 1167 path_params = {} 1168 if 'account_id' in params: 1169 path_params['accountId'] = params['account_id'] 1170 if 'envelope_id' in params: 1171 path_params['envelopeId'] = params['envelope_id'] 1172 1173 query_params = {} 1174 1175 header_params = {} 1176 1177 form_params = [] 1178 local_var_files = {} 1179 1180 body_params = None 1181 if 'envelope_view_request' in params: 1182 body_params = params['envelope_view_request'] 1183 # HTTP header `Accept` 1184 header_params['Accept'] = self.api_client.\ 1185 select_header_accept(['application/json']) 1186 1187 # Authentication setting 1188 auth_settings = [] 1189 1190 return self.api_client.call_api(resource_path, 'POST', 1191 path_params, 1192 query_params, 1193 header_params, 1194 body=body_params, 1195 post_params=form_params, 1196 files=local_var_files, 1197 response_type='ViewUrl', 1198 auth_settings=auth_settings, 1199 callback=params.get('callback'), 1200 _return_http_data_only=params.get('_return_http_data_only'), 1201 _preload_content=params.get('_preload_content', True), 1202 _request_timeout=params.get('_request_timeout'), 1203 collection_formats=collection_formats) 1204 1205 def create_email_settings(self, account_id, envelope_id, **kwargs): 1206 """ 1207 Adds email setting overrides to an envelope. 1208 Adds email override settings, changing the email address to reply to an email address, name, or the BCC for email archive information, for the envelope. Note that adding email settings will only affect email communications that occur after the addition was made. ### Important: The BCC Email address feature is designed to provide a copy of all email communications for external archiving purposes. DocuSign recommends that envelopes sent using the BCC for Email Archive feature, including the BCC Email Override option, include additional signer authentication options. To send a copy of the envelope to a recipient who does not need to sign, use a Carbon Copies or Certified Deliveries Recipient Type. 1209 This method makes a synchronous HTTP request by default. To make an 1210 asynchronous HTTP request, please define a `callback` function 1211 to be invoked when receiving the response. 1212 >>> def callback_function(response): 1213 >>> pprint(response) 1214 >>> 1215 >>> thread = api.create_email_settings(account_id, envelope_id, callback=callback_function) 1216 1217 :param callback function: The callback function 1218 for asynchronous request. (optional) 1219 :param str account_id: The external account number (int) or account ID Guid. (required) 1220 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1221 :param EmailSettings email_settings: 1222 :return: EmailSettings 1223 If the method is called asynchronously, 1224 returns the request thread. 1225 """ 1226 kwargs['_return_http_data_only'] = True 1227 if kwargs.get('callback'): 1228 return self.create_email_settings_with_http_info(account_id, envelope_id, **kwargs) 1229 else: 1230 (data) = self.create_email_settings_with_http_info(account_id, envelope_id, **kwargs) 1231 return data 1232 1233 def create_email_settings_with_http_info(self, account_id, envelope_id, **kwargs): 1234 """ 1235 Adds email setting overrides to an envelope. 1236 Adds email override settings, changing the email address to reply to an email address, name, or the BCC for email archive information, for the envelope. Note that adding email settings will only affect email communications that occur after the addition was made. ### Important: The BCC Email address feature is designed to provide a copy of all email communications for external archiving purposes. DocuSign recommends that envelopes sent using the BCC for Email Archive feature, including the BCC Email Override option, include additional signer authentication options. To send a copy of the envelope to a recipient who does not need to sign, use a Carbon Copies or Certified Deliveries Recipient Type. 1237 This method makes a synchronous HTTP request by default. To make an 1238 asynchronous HTTP request, please define a `callback` function 1239 to be invoked when receiving the response. 1240 >>> def callback_function(response): 1241 >>> pprint(response) 1242 >>> 1243 >>> thread = api.create_email_settings_with_http_info(account_id, envelope_id, callback=callback_function) 1244 1245 :param callback function: The callback function 1246 for asynchronous request. (optional) 1247 :param str account_id: The external account number (int) or account ID Guid. (required) 1248 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1249 :param EmailSettings email_settings: 1250 :return: EmailSettings 1251 If the method is called asynchronously, 1252 returns the request thread. 1253 """ 1254 1255 all_params = ['account_id', 'envelope_id', 'email_settings'] 1256 all_params.append('callback') 1257 all_params.append('_return_http_data_only') 1258 all_params.append('_preload_content') 1259 all_params.append('_request_timeout') 1260 1261 params = locals() 1262 for key, val in iteritems(params['kwargs']): 1263 if key not in all_params: 1264 raise TypeError( 1265 "Got an unexpected keyword argument '%s'" 1266 " to method create_email_settings" % key 1267 ) 1268 params[key] = val 1269 del params['kwargs'] 1270 # verify the required parameter 'account_id' is set 1271 if ('account_id' not in params) or (params['account_id'] is None): 1272 raise ValueError("Missing the required parameter `account_id` when calling `create_email_settings`") 1273 # verify the required parameter 'envelope_id' is set 1274 if ('envelope_id' not in params) or (params['envelope_id'] is None): 1275 raise ValueError("Missing the required parameter `envelope_id` when calling `create_email_settings`") 1276 1277 1278 collection_formats = {} 1279 1280 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/email_settings'.replace('{format}', 'json') 1281 path_params = {} 1282 if 'account_id' in params: 1283 path_params['accountId'] = params['account_id'] 1284 if 'envelope_id' in params: 1285 path_params['envelopeId'] = params['envelope_id'] 1286 1287 query_params = {} 1288 1289 header_params = {} 1290 1291 form_params = [] 1292 local_var_files = {} 1293 1294 body_params = None 1295 if 'email_settings' in params: 1296 body_params = params['email_settings'] 1297 # HTTP header `Accept` 1298 header_params['Accept'] = self.api_client.\ 1299 select_header_accept(['application/json']) 1300 1301 # Authentication setting 1302 auth_settings = [] 1303 1304 return self.api_client.call_api(resource_path, 'POST', 1305 path_params, 1306 query_params, 1307 header_params, 1308 body=body_params, 1309 post_params=form_params, 1310 files=local_var_files, 1311 response_type='EmailSettings', 1312 auth_settings=auth_settings, 1313 callback=params.get('callback'), 1314 _return_http_data_only=params.get('_return_http_data_only'), 1315 _preload_content=params.get('_preload_content', True), 1316 _request_timeout=params.get('_request_timeout'), 1317 collection_formats=collection_formats) 1318 1319 def create_envelope(self, account_id, **kwargs): 1320 """ 1321 Creates an envelope. 1322 Creates an envelope. Using this function you can: * Create an envelope and send it. * Create an envelope from an existing template and send it. In either case, you can choose to save the envelope as a draft envelope instead of sending it by setting the request's `status` property to `created` instead of `sent`. ## Sending Envelopes Documents can be included with the Envelopes::create call itself or a template can include documents. Documents can be added by using a multi-part/form request or by using the `documentBase64` field of the [`document` object](#/definitions/document) ### Recipient Types An [`envelopeDefinition` object](#/definitions/envelopeDefinition) is used as the method's body. Envelope recipients can be defined in the envelope or in templates. The `envelopeDefinition` object's `recipients` field is an [`EnvelopeRecipients` resource object](#/definitions/EnvelopeRecipients). It includes arrays of the seven types of recipients defined by DocuSign: Recipient type | Object definition -------------- | ----------------- agent (can add name and email information for later recipients/signers) | [`agent`](#/definitions/agent) carbon copy (receives a copy of the documents) | [`carbonCopy`](#/definitions/carbonCopy) certified delivery (receives a copy of the documents and must acknowledge receipt) | [`certifiedDelivery`](#/definitions/certifiedDelivery) editor (can change recipients and document fields for later recipients/signers) | [`editor`](#/definitions/editor) in-person signer (\"hosts\" someone who signs in-person) | [`inPersonSigner`](#/definitions/inPersonSigner) intermediary (can add name and email information for some later recipients/signers.) | [`intermediary`](#/definitions/intermediary) signer (signs and/or updates document fields) | [`signer`](#/definitions/signer) Additional information about the different types of recipients is available from the [`EnvelopeRecipients` resource page](../../EnvelopeRecipients) and from the [Developer Center](https://www.docusign.com/developer-center/explore/features/recipients) ### Tabs Tabs (also referred to as `tags` and as `fields` in the web sending user interface), can be defined in the `envelopeDefinition`, in templates, by transforming PDF Form Fields, or by using Composite Templates (see below). Defining tabs: the `inPersonSigner`, and `signer` recipient objects include a `tabs` field. It is an [`EnvelopeTabs` resource object](#/definitions/EnvelopeTabs). It includes arrays of the 24 different tab types available. See the [`EnvelopeTabs` resource](../../EnvelopeTabs) for more information. ## Using Templates Envelopes use specific people or groups as recipients. Templates can specify a role, eg `account_manager.` When a template is used in an envelope, the roles must be replaced with specific people or groups. When you create an envelope using a `templateId`, the different recipient type objects within the [`EnvelopeRecipients` object](#/definitions/EnvelopeRecipients) are used to assign recipients to the template's roles via the `roleName` property. The recipient objects can also override settings that were specified in the template, and set values for tab fields that were defined in the template. ### Message Lock When a template is added or applied to an envelope and the template has a locked email subject and message, that subject and message are used for the envelope and cannot be changed even if another locked template is subsequently added or applied to the envelope. The field `messageLock` is used to lock the email subject and message. If an email subject or message is entered before adding or applying a template with `messageLock` **true**, the email subject and message is overwritten with the locked email subject and message from the template. ## Envelope Status The status of sent envelopes can be determined through the DocuSign webhook system or by polling. Webhooks are highly recommended: they provide your application with the quickest updates when an envelope's status changes. DocuSign limits polling to once every 15 minutes or less frequently. When a webhook is used, DocuSign calls your application, via the URL you provide, with a notification XML message. See the [Webhook recipe](https://www.docusign.com/developer-center/recipes/webhook-status) for examples and live demos of using webhooks. ## Webhook Options The two webhook options, *eventNotification* and *Connect* use the same notification mechanism and message formats. eventNotification is used to create a webhook for a specific envelope sent via the API. Connect webhooks can be used for any envelope sent from an account, from any user, from any client. ### eventNotification Webhooks The Envelopes::create method includes an optional [eventNotification object](#definition-eventNotification) that adds a webhook to the envelope. eventNotification webhooks are available for all DocuSign accounts with API access. ### Connect Webhooks Connect can be used to create a webhook for all envelopes sent by all users in an account, either through the API or via other DocuSign clients (web, mobile, etc). Connect configurations are independent of specific envelopes. A Connect configuration includes a filter that may be used to limit the webhook to specific users, envelope statuses, etc. Connect configurations may be created and managed using the [ConnectConfigurations resource](../../Connect/ConnectConfigurations). Configurations can also be created and managed from the Administration tool accessed by selecting \"Go to Admin\" from the menu next to your picture on the DocuSign web app. See the Integrations/Connect section of the Admin tool. For repeatability, and to minimize support questions, creating Connect configurations via the API is recommended, especially for ISVs. Connect is available for some DocuSign account types. Please contact DocuSign Sales for more information. ## Composite Templates The Composite Templates feature, like [compositing in film production](https://en.wikipedia.org/wiki/Compositing), enables you to *overlay* document, recipient, and tab definitions from multiple sources, including PDF Form Field definitions, templates defined on the server, and more. Each Composite Template consists of optional elements: server templates, inline templates, PDF Metadata templates, and documents. * The Composite Template ID is an optional element used to identify the composite template. It is used as a reference when adding document object information via a multi-part HTTP message. If used, the document content-disposition must include the `compositeTemplateId` to which the document should be added. If `compositeTemplateId` is not specified in the content-disposition, the document is applied based on the `documentId` only. If no document object is specified, the composite template inherits the first document. * Server Templates are server-side templates stored on the DocuSign platform. If supplied, they are overlaid into the envelope in the order of their Sequence value. * Inline Templates provide a container to add documents, recipients, tabs, and custom fields. If inline templates are supplied, they are overlaid into the envelope in the order of their Sequence value. * Document objects are optional structures that provide a container to pass in a document or form. If this object is not included, the composite template inherits the *first* document it finds from a server template or inline template, starting with the lowest sequence value. PDF Form objects are only transformed from the document object. DocuSign does not derive PDF form properties from server templates or inline templates. To instruct DocuSign to transform fields from the PDF form, set `transformPdfFields` to \"true\" for the document. See the Transform PDF Fields section for more information about process. * PDF Metadata Templates provide a container to embed design-time template information into a PDF document. DocuSign uses this information when processing the Envelope. This convention allows the document to carry the signing instructions with it, so that less information needs to be provided at run-time through an inline template or synchronized with an external structure like a server template. PDF Metadata templates are stored in the Metadata layer of a PDF in accordance with Acrobat's XMP specification. DocuSign will only find PDF Metadata templates inside documents passed in the Document object (see below). If supplied, the PDF metadata template will be overlaid into the envelope in the order of its Sequence value. ### Compositing the definitions Each Composite Template adds a new document and templates overlay into the envelope. For each Composite Template these rules are applied: * Templates are overlaid in the order of their Sequence value. * If Document is not passed into the Composite Template's `document` field, the *first* template's document (based on the template's Sequence value) is used. * Last in wins in all cases except for the document (i.e. envelope information, recipient information, secure field information). There is no special casing. For example, if you want higher security on a tab, then that needs to be specified in a later template (by sequence number) then where the tab is included. If you want higher security on a role recipient, then it needs to be in a later template then where that role recipient is specified. * Recipient matching is based on Recipient Role and Routing Order. If there are matches, the recipient information is merged together. A final pass is done on all Composite Templates, after all template overlays have been applied, to collapse recipients with the same email, username and routing order. This prevents having the same recipients at the same routing order. * If you specify in a template that a recipient is locked, once that recipient is overlaid the recipient attributes can no longer be changed. The only items that can be changed for the recipient in this case are the email, username, access code and IDCheckInformationInput. * Tab matching is based on Tab Labels, Tab Types and Documents. If a Tab Label matches but the Document is not supplied, the Tab is overlaid for all the Documents. For example, if you have a simple inline template with only one tab in it with a label and a value, the Signature, Initial, Company, Envelope ID, User Name tabs will only be matched and collapsed if they fall in the exact same X and Y locations. * roleName and tabLabel matching is case sensitive. * The defaultRecipient field enables you to specify which recipient the generated tabs from a PDF form are mapped to. You can also set PDF form generated tabs to a recipient other than the DefaultRecipient by specifying the mapping of the tab label that is created to one of the template recipients. * You can use tabLabel wild carding to map a series of tabs from the PDF form. To use this you must end a tab label with \"\\*\" and then the system matches tabs that start with the label. * If no DefaultRecipient is specified, tabs must be explicitly mapped to recipients in order to be generated from the form. Unmapped form objects will not be generated into their DocuSign equivalents. (In the case of Signature/Initials, the tabs will be disregarded entirely; in the case of pdf text fields, the field data will be flattened on the Envelope document, but there will not be a corresponding DocuSign data tab.) ### Including the Document Content for Composite Templates Document content can be supplied inline, using the `documentBase64` or can be included in a multi-part HTTP message. If a multi-part message is used and there are multiple Composite Templates, the document content-disposition can include the `compositeTemplateId` to which the document should be added. Using the `compositeTemplateId` sets which documents are associated with particular composite templates. An example of this usage is: ``` --5cd3320a-5aac-4453-b3a4-cbb52a4cba5d Content-Type: application/pdf Content-Disposition: file; filename=\"eula.pdf\"; documentId=1; compositeTemplateId=\"1\" Content-Transfer-Encoding: base64 ``` ### PDF Form Field Transformation Only the following PDF Form FieldTypes will be transformed to DocuSign tabs: CheckBox, DateTime, ListBox, Numeric, Password, Radio, Signature, and Text Field Properties that will be transformed: Read Only, Required, Max Length, Positions, and Initial Data. When transforming a *PDF Form Digital Signature Field,* the following rules are used: If the PDF Field Name Contains | Then the DocuSign Tab Will be ------- | -------- DocuSignSignHere or eSignSignHere | Signature DocuSignSignHereOptional or eSignSignHereOptional | Optional Signature DocuSignInitialHere or eSignInitialHere | Initials DocuSignInitialHereOptional or eSignInitialHereOptional | Optional Initials Any other PDF Form Digital Signature Field will be transformed to a DocuSign Signature tab When transforming *PDF Form Text Fields,* the following rules are used: If the PDF Field Name Contains | Then the DocuSign Tab Will be ------- | -------- DocuSignSignHere or eSignSignHere | Signature DocuSignSignHereOptional or eSignSignHereOptional | Optional Signature DocuSignInitialHere or eSignInitialHere | Initials DocuSignInitialHereOptional or eSignInitialHereOptional | Optional Initials DocuSignEnvelopeID or eSignEnvelopeID | EnvelopeID DocuSignCompany or eSignCompany | Company DocuSignDateSigned or eSignDateSigned | Date Signed DocuSignTitle or eSignTitle | Title DocuSignFullName or eSignFullName | Full Name DocuSignSignerAttachmentOptional or eSignSignerAttachmentOptional | Optional Signer Attachment Any other PDF Form Text Field will be transformed to a DocuSign data (text) tab. PDF Form Field Names that include \"DocuSignIgnoreTransform\" or \"eSignIgnoreTransform\" will not be transformed. PDF Form Date fields will be transformed to Date Signed fields if their name includes DocuSignDateSigned or eSignDateSigned. ## Template Email Subject Merge Fields This feature enables you to insert recipient name and email address merge fields into the email subject line when creating or sending from a template. The merge fields, based on the recipient's `roleName`, are added to the `emailSubject` when the template is created or when the template is used to create an envelope. After a template sender adds the name and email information for the recipient and sends the envelope, the recipient information is automatically merged into the appropriate fields in the email subject line. Both the sender and the recipients will see the information in the email subject line for any emails associated with the template. This provides an easy way for senders to organize their envelope emails without having to open an envelope to check the recipient. If merging the recipient information into the subject line causes the subject line to exceed 100 characters, then any characters over the 100 character limit are not included in the subject line. For cases where the recipient name or email is expected to be long, you should consider placing the merge field at the start of the email subject. * To add a recipient's name in the subject line add the following text in the `emailSubject` when creating the template or when sending an envelope from a template: [[<roleName>_UserName]] Example: `\"emailSubject\":\"[[Signer 1_UserName]], Please sign this NDA\",` * To add a recipient's email address in the subject line add the following text in the emailSubject when creating the template or when sending an envelope from a template: [[<roleName>_Email]] Example: `\"emailSubject\":\"[[Signer 1_Email]], Please sign this NDA\",` In both cases the <roleName> is the recipient's `roleName` in the template. For cases where another recipient (such as an Agent, Editor, or Intermediary recipient) is entering the name and email information for the recipient included in the email subject, then [[<roleName>_UserName]] or [[<roleName>_Email]] is shown in the email subject. ## Branding an envelope The following rules are used to determine the `brandId` used in an envelope: * If a `brandId` is specified in the envelope/template and that brandId is available to the account, that brand is used in the envelope. * If more than one template is used in an envelope and more than one `brandId` is specified, the first `brandId` specified is used throughout the envelope. * In cases where no brand is specified and the sender belongs to a Group; if there is only one brand associated with the Group, then that brand is used in the envelope. Otherwise, the account's default signing brand is used. * For envelopes that do not meet any of the previous criteria, the account's default signing brand is used for the envelope. ## BCC Email address feature The BCC Email address feature is designed to provide a copy of all email communications for external archiving purposes. DocuSign recommends that envelopes sent using the BCC for Email Archive feature, including the BCC Email Override option, include additional signer authentication options. To send a copy of the envelope to a recipient who does not need to sign, don't use the BCC Email field. Use a Carbon Copy or Certified Delivery Recipient type. ## Merge Recipient Roles for Draft Envelopes When an envelope with multiple templates is sent, the recipients from the templates are merged according to the template roles, and empty recipients are removed. When creating an envelope with multiple templates, but not sending it (keeping it in a created state), duplicate recipients are not merged, which could cause leave duplicate recipients in the envelope. To prevent this, the query parameter `merge_roles_on_draft` should be added when posting a draft envelope (status=created) with multiple templates. Doing this will merge template roles and remove empty recipients. ###### Note: DocuSign recommends that the `merge_roles_on_draft` query parameter be used anytime you are creating an envelope with multiple templates and keeping it in draft (created) status. 1323 This method makes a synchronous HTTP request by default. To make an 1324 asynchronous HTTP request, please define a `callback` function 1325 to be invoked when receiving the response. 1326 >>> def callback_function(response): 1327 >>> pprint(response) 1328 >>> 1329 >>> thread = api.create_envelope(account_id, callback=callback_function) 1330 1331 :param callback function: The callback function 1332 for asynchronous request. (optional) 1333 :param str account_id: The external account number (int) or account ID Guid. (required) 1334 :param str cdse_mode: 1335 :param str change_routing_order: 1336 :param str completed_documents_only: If set to true then we want to set the sourceEnvelopeId to indicate that this is a\"forward\" envelope action 1337 :param str merge_roles_on_draft: When set to **true**, merges template roles and remove empty recipients when you create an envelope with multiple templates. 1338 :param str tab_label_exact_matches: 1339 :param EnvelopeDefinition envelope_definition: 1340 :return: EnvelopeSummary 1341 If the method is called asynchronously, 1342 returns the request thread. 1343 """ 1344 kwargs['_return_http_data_only'] = True 1345 if kwargs.get('callback'): 1346 return self.create_envelope_with_http_info(account_id, **kwargs) 1347 else: 1348 (data) = self.create_envelope_with_http_info(account_id, **kwargs) 1349 return data 1350 1351 def create_envelope_with_http_info(self, account_id, **kwargs): 1352 """ 1353 Creates an envelope. 1354 Creates an envelope. Using this function you can: * Create an envelope and send it. * Create an envelope from an existing template and send it. In either case, you can choose to save the envelope as a draft envelope instead of sending it by setting the request's `status` property to `created` instead of `sent`. ## Sending Envelopes Documents can be included with the Envelopes::create call itself or a template can include documents. Documents can be added by using a multi-part/form request or by using the `documentBase64` field of the [`document` object](#/definitions/document) ### Recipient Types An [`envelopeDefinition` object](#/definitions/envelopeDefinition) is used as the method's body. Envelope recipients can be defined in the envelope or in templates. The `envelopeDefinition` object's `recipients` field is an [`EnvelopeRecipients` resource object](#/definitions/EnvelopeRecipients). It includes arrays of the seven types of recipients defined by DocuSign: Recipient type | Object definition -------------- | ----------------- agent (can add name and email information for later recipients/signers) | [`agent`](#/definitions/agent) carbon copy (receives a copy of the documents) | [`carbonCopy`](#/definitions/carbonCopy) certified delivery (receives a copy of the documents and must acknowledge receipt) | [`certifiedDelivery`](#/definitions/certifiedDelivery) editor (can change recipients and document fields for later recipients/signers) | [`editor`](#/definitions/editor) in-person signer (\"hosts\" someone who signs in-person) | [`inPersonSigner`](#/definitions/inPersonSigner) intermediary (can add name and email information for some later recipients/signers.) | [`intermediary`](#/definitions/intermediary) signer (signs and/or updates document fields) | [`signer`](#/definitions/signer) Additional information about the different types of recipients is available from the [`EnvelopeRecipients` resource page](../../EnvelopeRecipients) and from the [Developer Center](https://www.docusign.com/developer-center/explore/features/recipients) ### Tabs Tabs (also referred to as `tags` and as `fields` in the web sending user interface), can be defined in the `envelopeDefinition`, in templates, by transforming PDF Form Fields, or by using Composite Templates (see below). Defining tabs: the `inPersonSigner`, and `signer` recipient objects include a `tabs` field. It is an [`EnvelopeTabs` resource object](#/definitions/EnvelopeTabs). It includes arrays of the 24 different tab types available. See the [`EnvelopeTabs` resource](../../EnvelopeTabs) for more information. ## Using Templates Envelopes use specific people or groups as recipients. Templates can specify a role, eg `account_manager.` When a template is used in an envelope, the roles must be replaced with specific people or groups. When you create an envelope using a `templateId`, the different recipient type objects within the [`EnvelopeRecipients` object](#/definitions/EnvelopeRecipients) are used to assign recipients to the template's roles via the `roleName` property. The recipient objects can also override settings that were specified in the template, and set values for tab fields that were defined in the template. ### Message Lock When a template is added or applied to an envelope and the template has a locked email subject and message, that subject and message are used for the envelope and cannot be changed even if another locked template is subsequently added or applied to the envelope. The field `messageLock` is used to lock the email subject and message. If an email subject or message is entered before adding or applying a template with `messageLock` **true**, the email subject and message is overwritten with the locked email subject and message from the template. ## Envelope Status The status of sent envelopes can be determined through the DocuSign webhook system or by polling. Webhooks are highly recommended: they provide your application with the quickest updates when an envelope's status changes. DocuSign limits polling to once every 15 minutes or less frequently. When a webhook is used, DocuSign calls your application, via the URL you provide, with a notification XML message. See the [Webhook recipe](https://www.docusign.com/developer-center/recipes/webhook-status) for examples and live demos of using webhooks. ## Webhook Options The two webhook options, *eventNotification* and *Connect* use the same notification mechanism and message formats. eventNotification is used to create a webhook for a specific envelope sent via the API. Connect webhooks can be used for any envelope sent from an account, from any user, from any client. ### eventNotification Webhooks The Envelopes::create method includes an optional [eventNotification object](#definition-eventNotification) that adds a webhook to the envelope. eventNotification webhooks are available for all DocuSign accounts with API access. ### Connect Webhooks Connect can be used to create a webhook for all envelopes sent by all users in an account, either through the API or via other DocuSign clients (web, mobile, etc). Connect configurations are independent of specific envelopes. A Connect configuration includes a filter that may be used to limit the webhook to specific users, envelope statuses, etc. Connect configurations may be created and managed using the [ConnectConfigurations resource](../../Connect/ConnectConfigurations). Configurations can also be created and managed from the Administration tool accessed by selecting \"Go to Admin\" from the menu next to your picture on the DocuSign web app. See the Integrations/Connect section of the Admin tool. For repeatability, and to minimize support questions, creating Connect configurations via the API is recommended, especially for ISVs. Connect is available for some DocuSign account types. Please contact DocuSign Sales for more information. ## Composite Templates The Composite Templates feature, like [compositing in film production](https://en.wikipedia.org/wiki/Compositing), enables you to *overlay* document, recipient, and tab definitions from multiple sources, including PDF Form Field definitions, templates defined on the server, and more. Each Composite Template consists of optional elements: server templates, inline templates, PDF Metadata templates, and documents. * The Composite Template ID is an optional element used to identify the composite template. It is used as a reference when adding document object information via a multi-part HTTP message. If used, the document content-disposition must include the `compositeTemplateId` to which the document should be added. If `compositeTemplateId` is not specified in the content-disposition, the document is applied based on the `documentId` only. If no document object is specified, the composite template inherits the first document. * Server Templates are server-side templates stored on the DocuSign platform. If supplied, they are overlaid into the envelope in the order of their Sequence value. * Inline Templates provide a container to add documents, recipients, tabs, and custom fields. If inline templates are supplied, they are overlaid into the envelope in the order of their Sequence value. * Document objects are optional structures that provide a container to pass in a document or form. If this object is not included, the composite template inherits the *first* document it finds from a server template or inline template, starting with the lowest sequence value. PDF Form objects are only transformed from the document object. DocuSign does not derive PDF form properties from server templates or inline templates. To instruct DocuSign to transform fields from the PDF form, set `transformPdfFields` to \"true\" for the document. See the Transform PDF Fields section for more information about process. * PDF Metadata Templates provide a container to embed design-time template information into a PDF document. DocuSign uses this information when processing the Envelope. This convention allows the document to carry the signing instructions with it, so that less information needs to be provided at run-time through an inline template or synchronized with an external structure like a server template. PDF Metadata templates are stored in the Metadata layer of a PDF in accordance with Acrobat's XMP specification. DocuSign will only find PDF Metadata templates inside documents passed in the Document object (see below). If supplied, the PDF metadata template will be overlaid into the envelope in the order of its Sequence value. ### Compositing the definitions Each Composite Template adds a new document and templates overlay into the envelope. For each Composite Template these rules are applied: * Templates are overlaid in the order of their Sequence value. * If Document is not passed into the Composite Template's `document` field, the *first* template's document (based on the template's Sequence value) is used. * Last in wins in all cases except for the document (i.e. envelope information, recipient information, secure field information). There is no special casing. For example, if you want higher security on a tab, then that needs to be specified in a later template (by sequence number) then where the tab is included. If you want higher security on a role recipient, then it needs to be in a later template then where that role recipient is specified. * Recipient matching is based on Recipient Role and Routing Order. If there are matches, the recipient information is merged together. A final pass is done on all Composite Templates, after all template overlays have been applied, to collapse recipients with the same email, username and routing order. This prevents having the same recipients at the same routing order. * If you specify in a template that a recipient is locked, once that recipient is overlaid the recipient attributes can no longer be changed. The only items that can be changed for the recipient in this case are the email, username, access code and IDCheckInformationInput. * Tab matching is based on Tab Labels, Tab Types and Documents. If a Tab Label matches but the Document is not supplied, the Tab is overlaid for all the Documents. For example, if you have a simple inline template with only one tab in it with a label and a value, the Signature, Initial, Company, Envelope ID, User Name tabs will only be matched and collapsed if they fall in the exact same X and Y locations. * roleName and tabLabel matching is case sensitive. * The defaultRecipient field enables you to specify which recipient the generated tabs from a PDF form are mapped to. You can also set PDF form generated tabs to a recipient other than the DefaultRecipient by specifying the mapping of the tab label that is created to one of the template recipients. * You can use tabLabel wild carding to map a series of tabs from the PDF form. To use this you must end a tab label with \"\\*\" and then the system matches tabs that start with the label. * If no DefaultRecipient is specified, tabs must be explicitly mapped to recipients in order to be generated from the form. Unmapped form objects will not be generated into their DocuSign equivalents. (In the case of Signature/Initials, the tabs will be disregarded entirely; in the case of pdf text fields, the field data will be flattened on the Envelope document, but there will not be a corresponding DocuSign data tab.) ### Including the Document Content for Composite Templates Document content can be supplied inline, using the `documentBase64` or can be included in a multi-part HTTP message. If a multi-part message is used and there are multiple Composite Templates, the document content-disposition can include the `compositeTemplateId` to which the document should be added. Using the `compositeTemplateId` sets which documents are associated with particular composite templates. An example of this usage is: ``` --5cd3320a-5aac-4453-b3a4-cbb52a4cba5d Content-Type: application/pdf Content-Disposition: file; filename=\"eula.pdf\"; documentId=1; compositeTemplateId=\"1\" Content-Transfer-Encoding: base64 ``` ### PDF Form Field Transformation Only the following PDF Form FieldTypes will be transformed to DocuSign tabs: CheckBox, DateTime, ListBox, Numeric, Password, Radio, Signature, and Text Field Properties that will be transformed: Read Only, Required, Max Length, Positions, and Initial Data. When transforming a *PDF Form Digital Signature Field,* the following rules are used: If the PDF Field Name Contains | Then the DocuSign Tab Will be ------- | -------- DocuSignSignHere or eSignSignHere | Signature DocuSignSignHereOptional or eSignSignHereOptional | Optional Signature DocuSignInitialHere or eSignInitialHere | Initials DocuSignInitialHereOptional or eSignInitialHereOptional | Optional Initials Any other PDF Form Digital Signature Field will be transformed to a DocuSign Signature tab When transforming *PDF Form Text Fields,* the following rules are used: If the PDF Field Name Contains | Then the DocuSign Tab Will be ------- | -------- DocuSignSignHere or eSignSignHere | Signature DocuSignSignHereOptional or eSignSignHereOptional | Optional Signature DocuSignInitialHere or eSignInitialHere | Initials DocuSignInitialHereOptional or eSignInitialHereOptional | Optional Initials DocuSignEnvelopeID or eSignEnvelopeID | EnvelopeID DocuSignCompany or eSignCompany | Company DocuSignDateSigned or eSignDateSigned | Date Signed DocuSignTitle or eSignTitle | Title DocuSignFullName or eSignFullName | Full Name DocuSignSignerAttachmentOptional or eSignSignerAttachmentOptional | Optional Signer Attachment Any other PDF Form Text Field will be transformed to a DocuSign data (text) tab. PDF Form Field Names that include \"DocuSignIgnoreTransform\" or \"eSignIgnoreTransform\" will not be transformed. PDF Form Date fields will be transformed to Date Signed fields if their name includes DocuSignDateSigned or eSignDateSigned. ## Template Email Subject Merge Fields This feature enables you to insert recipient name and email address merge fields into the email subject line when creating or sending from a template. The merge fields, based on the recipient's `roleName`, are added to the `emailSubject` when the template is created or when the template is used to create an envelope. After a template sender adds the name and email information for the recipient and sends the envelope, the recipient information is automatically merged into the appropriate fields in the email subject line. Both the sender and the recipients will see the information in the email subject line for any emails associated with the template. This provides an easy way for senders to organize their envelope emails without having to open an envelope to check the recipient. If merging the recipient information into the subject line causes the subject line to exceed 100 characters, then any characters over the 100 character limit are not included in the subject line. For cases where the recipient name or email is expected to be long, you should consider placing the merge field at the start of the email subject. * To add a recipient's name in the subject line add the following text in the `emailSubject` when creating the template or when sending an envelope from a template: [[<roleName>_UserName]] Example: `\"emailSubject\":\"[[Signer 1_UserName]], Please sign this NDA\",` * To add a recipient's email address in the subject line add the following text in the emailSubject when creating the template or when sending an envelope from a template: [[<roleName>_Email]] Example: `\"emailSubject\":\"[[Signer 1_Email]], Please sign this NDA\",` In both cases the <roleName> is the recipient's `roleName` in the template. For cases where another recipient (such as an Agent, Editor, or Intermediary recipient) is entering the name and email information for the recipient included in the email subject, then [[<roleName>_UserName]] or [[<roleName>_Email]] is shown in the email subject. ## Branding an envelope The following rules are used to determine the `brandId` used in an envelope: * If a `brandId` is specified in the envelope/template and that brandId is available to the account, that brand is used in the envelope. * If more than one template is used in an envelope and more than one `brandId` is specified, the first `brandId` specified is used throughout the envelope. * In cases where no brand is specified and the sender belongs to a Group; if there is only one brand associated with the Group, then that brand is used in the envelope. Otherwise, the account's default signing brand is used. * For envelopes that do not meet any of the previous criteria, the account's default signing brand is used for the envelope. ## BCC Email address feature The BCC Email address feature is designed to provide a copy of all email communications for external archiving purposes. DocuSign recommends that envelopes sent using the BCC for Email Archive feature, including the BCC Email Override option, include additional signer authentication options. To send a copy of the envelope to a recipient who does not need to sign, don't use the BCC Email field. Use a Carbon Copy or Certified Delivery Recipient type. ## Merge Recipient Roles for Draft Envelopes When an envelope with multiple templates is sent, the recipients from the templates are merged according to the template roles, and empty recipients are removed. When creating an envelope with multiple templates, but not sending it (keeping it in a created state), duplicate recipients are not merged, which could cause leave duplicate recipients in the envelope. To prevent this, the query parameter `merge_roles_on_draft` should be added when posting a draft envelope (status=created) with multiple templates. Doing this will merge template roles and remove empty recipients. ###### Note: DocuSign recommends that the `merge_roles_on_draft` query parameter be used anytime you are creating an envelope with multiple templates and keeping it in draft (created) status. 1355 This method makes a synchronous HTTP request by default. To make an 1356 asynchronous HTTP request, please define a `callback` function 1357 to be invoked when receiving the response. 1358 >>> def callback_function(response): 1359 >>> pprint(response) 1360 >>> 1361 >>> thread = api.create_envelope_with_http_info(account_id, callback=callback_function) 1362 1363 :param callback function: The callback function 1364 for asynchronous request. (optional) 1365 :param str account_id: The external account number (int) or account ID Guid. (required) 1366 :param str cdse_mode: 1367 :param str change_routing_order: 1368 :param str completed_documents_only: If set to true then we want to set the sourceEnvelopeId to indicate that this is a\"forward\" envelope action 1369 :param str merge_roles_on_draft: When set to **true**, merges template roles and remove empty recipients when you create an envelope with multiple templates. 1370 :param str tab_label_exact_matches: 1371 :param EnvelopeDefinition envelope_definition: 1372 :return: EnvelopeSummary 1373 If the method is called asynchronously, 1374 returns the request thread. 1375 """ 1376 1377 all_params = ['account_id', 'cdse_mode', 'change_routing_order', 'completed_documents_only', 'merge_roles_on_draft', 'tab_label_exact_matches', 'envelope_definition'] 1378 all_params.append('callback') 1379 all_params.append('_return_http_data_only') 1380 all_params.append('_preload_content') 1381 all_params.append('_request_timeout') 1382 1383 params = locals() 1384 for key, val in iteritems(params['kwargs']): 1385 if key not in all_params: 1386 raise TypeError( 1387 "Got an unexpected keyword argument '%s'" 1388 " to method create_envelope" % key 1389 ) 1390 params[key] = val 1391 del params['kwargs'] 1392 # verify the required parameter 'account_id' is set 1393 if ('account_id' not in params) or (params['account_id'] is None): 1394 raise ValueError("Missing the required parameter `account_id` when calling `create_envelope`") 1395 1396 1397 collection_formats = {} 1398 1399 resource_path = '/v2.1/accounts/{accountId}/envelopes'.replace('{format}', 'json') 1400 path_params = {} 1401 if 'account_id' in params: 1402 path_params['accountId'] = params['account_id'] 1403 1404 query_params = {} 1405 if 'cdse_mode' in params: 1406 query_params['cdse_mode'] = params['cdse_mode'] 1407 if 'change_routing_order' in params: 1408 query_params['change_routing_order'] = params['change_routing_order'] 1409 if 'completed_documents_only' in params: 1410 query_params['completed_documents_only'] = params['completed_documents_only'] 1411 if 'merge_roles_on_draft' in params: 1412 query_params['merge_roles_on_draft'] = params['merge_roles_on_draft'] 1413 if 'tab_label_exact_matches' in params: 1414 query_params['tab_label_exact_matches'] = params['tab_label_exact_matches'] 1415 1416 header_params = {} 1417 1418 form_params = [] 1419 local_var_files = {} 1420 1421 body_params = None 1422 if 'envelope_definition' in params: 1423 body_params = params['envelope_definition'] 1424 # HTTP header `Accept` 1425 header_params['Accept'] = self.api_client.\ 1426 select_header_accept(['application/json']) 1427 1428 # Authentication setting 1429 auth_settings = [] 1430 1431 return self.api_client.call_api(resource_path, 'POST', 1432 path_params, 1433 query_params, 1434 header_params, 1435 body=body_params, 1436 post_params=form_params, 1437 files=local_var_files, 1438 response_type='EnvelopeSummary', 1439 auth_settings=auth_settings, 1440 callback=params.get('callback'), 1441 _return_http_data_only=params.get('_return_http_data_only'), 1442 _preload_content=params.get('_preload_content', True), 1443 _request_timeout=params.get('_request_timeout'), 1444 collection_formats=collection_formats) 1445 1446 def create_envelope_comments(self, account_id, envelope_id, **kwargs): 1447 """ 1448 Posts a list of comments for authorized user 1449 1450 This method makes a synchronous HTTP request by default. To make an 1451 asynchronous HTTP request, please define a `callback` function 1452 to be invoked when receiving the response. 1453 >>> def callback_function(response): 1454 >>> pprint(response) 1455 >>> 1456 >>> thread = api.create_envelope_comments(account_id, envelope_id, callback=callback_function) 1457 1458 :param callback function: The callback function 1459 for asynchronous request. (optional) 1460 :param str account_id: The external account number (int) or account ID Guid. (required) 1461 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1462 :param CommentsPublish comments_publish: 1463 :return: CommentHistoryResult 1464 If the method is called asynchronously, 1465 returns the request thread. 1466 """ 1467 kwargs['_return_http_data_only'] = True 1468 if kwargs.get('callback'): 1469 return self.create_envelope_comments_with_http_info(account_id, envelope_id, **kwargs) 1470 else: 1471 (data) = self.create_envelope_comments_with_http_info(account_id, envelope_id, **kwargs) 1472 return data 1473 1474 def create_envelope_comments_with_http_info(self, account_id, envelope_id, **kwargs): 1475 """ 1476 Posts a list of comments for authorized user 1477 1478 This method makes a synchronous HTTP request by default. To make an 1479 asynchronous HTTP request, please define a `callback` function 1480 to be invoked when receiving the response. 1481 >>> def callback_function(response): 1482 >>> pprint(response) 1483 >>> 1484 >>> thread = api.create_envelope_comments_with_http_info(account_id, envelope_id, callback=callback_function) 1485 1486 :param callback function: The callback function 1487 for asynchronous request. (optional) 1488 :param str account_id: The external account number (int) or account ID Guid. (required) 1489 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1490 :param CommentsPublish comments_publish: 1491 :return: CommentHistoryResult 1492 If the method is called asynchronously, 1493 returns the request thread. 1494 """ 1495 1496 all_params = ['account_id', 'envelope_id', 'comments_publish'] 1497 all_params.append('callback') 1498 all_params.append('_return_http_data_only') 1499 all_params.append('_preload_content') 1500 all_params.append('_request_timeout') 1501 1502 params = locals() 1503 for key, val in iteritems(params['kwargs']): 1504 if key not in all_params: 1505 raise TypeError( 1506 "Got an unexpected keyword argument '%s'" 1507 " to method create_envelope_comments" % key 1508 ) 1509 params[key] = val 1510 del params['kwargs'] 1511 # verify the required parameter 'account_id' is set 1512 if ('account_id' not in params) or (params['account_id'] is None): 1513 raise ValueError("Missing the required parameter `account_id` when calling `create_envelope_comments`") 1514 # verify the required parameter 'envelope_id' is set 1515 if ('envelope_id' not in params) or (params['envelope_id'] is None): 1516 raise ValueError("Missing the required parameter `envelope_id` when calling `create_envelope_comments`") 1517 1518 1519 collection_formats = {} 1520 1521 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/comments'.replace('{format}', 'json') 1522 path_params = {} 1523 if 'account_id' in params: 1524 path_params['accountId'] = params['account_id'] 1525 if 'envelope_id' in params: 1526 path_params['envelopeId'] = params['envelope_id'] 1527 1528 query_params = {} 1529 1530 header_params = {} 1531 1532 form_params = [] 1533 local_var_files = {} 1534 1535 body_params = None 1536 if 'comments_publish' in params: 1537 body_params = params['comments_publish'] 1538 # HTTP header `Accept` 1539 header_params['Accept'] = self.api_client.\ 1540 select_header_accept(['application/json']) 1541 1542 # Authentication setting 1543 auth_settings = [] 1544 1545 return self.api_client.call_api(resource_path, 'POST', 1546 path_params, 1547 query_params, 1548 header_params, 1549 body=body_params, 1550 post_params=form_params, 1551 files=local_var_files, 1552 response_type='CommentHistoryResult', 1553 auth_settings=auth_settings, 1554 callback=params.get('callback'), 1555 _return_http_data_only=params.get('_return_http_data_only'), 1556 _preload_content=params.get('_preload_content', True), 1557 _request_timeout=params.get('_request_timeout'), 1558 collection_formats=collection_formats) 1559 1560 def create_envelope_recipient_preview(self, account_id, envelope_id, **kwargs): 1561 """ 1562 Provides a URL to start a recipient view of the Envelope UI 1563 This method returns a URL for an envelope recipient preview in the DocuSign UI that you can embed in your application. You use this method to enable the sender to preview the recipients' experience. For more information, see [Preview and Send](https://support.docusign.com/en/guides/ndse-user-guide-send-your-documents). 1564 This method makes a synchronous HTTP request by default. To make an 1565 asynchronous HTTP request, please define a `callback` function 1566 to be invoked when receiving the response. 1567 >>> def callback_function(response): 1568 >>> pprint(response) 1569 >>> 1570 >>> thread = api.create_envelope_recipient_preview(account_id, envelope_id, callback=callback_function) 1571 1572 :param callback function: The callback function 1573 for asynchronous request. (optional) 1574 :param str account_id: The external account number (int) or account ID Guid. (required) 1575 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1576 :param RecipientPreviewRequest recipient_preview_request: 1577 :return: ViewUrl 1578 If the method is called asynchronously, 1579 returns the request thread. 1580 """ 1581 kwargs['_return_http_data_only'] = True 1582 if kwargs.get('callback'): 1583 return self.create_envelope_recipient_preview_with_http_info(account_id, envelope_id, **kwargs) 1584 else: 1585 (data) = self.create_envelope_recipient_preview_with_http_info(account_id, envelope_id, **kwargs) 1586 return data 1587 1588 def create_envelope_recipient_preview_with_http_info(self, account_id, envelope_id, **kwargs): 1589 """ 1590 Provides a URL to start a recipient view of the Envelope UI 1591 This method returns a URL for an envelope recipient preview in the DocuSign UI that you can embed in your application. You use this method to enable the sender to preview the recipients' experience. For more information, see [Preview and Send](https://support.docusign.com/en/guides/ndse-user-guide-send-your-documents). 1592 This method makes a synchronous HTTP request by default. To make an 1593 asynchronous HTTP request, please define a `callback` function 1594 to be invoked when receiving the response. 1595 >>> def callback_function(response): 1596 >>> pprint(response) 1597 >>> 1598 >>> thread = api.create_envelope_recipient_preview_with_http_info(account_id, envelope_id, callback=callback_function) 1599 1600 :param callback function: The callback function 1601 for asynchronous request. (optional) 1602 :param str account_id: The external account number (int) or account ID Guid. (required) 1603 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1604 :param RecipientPreviewRequest recipient_preview_request: 1605 :return: ViewUrl 1606 If the method is called asynchronously, 1607 returns the request thread. 1608 """ 1609 1610 all_params = ['account_id', 'envelope_id', 'recipient_preview_request'] 1611 all_params.append('callback') 1612 all_params.append('_return_http_data_only') 1613 all_params.append('_preload_content') 1614 all_params.append('_request_timeout') 1615 1616 params = locals() 1617 for key, val in iteritems(params['kwargs']): 1618 if key not in all_params: 1619 raise TypeError( 1620 "Got an unexpected keyword argument '%s'" 1621 " to method create_envelope_recipient_preview" % key 1622 ) 1623 params[key] = val 1624 del params['kwargs'] 1625 # verify the required parameter 'account_id' is set 1626 if ('account_id' not in params) or (params['account_id'] is None): 1627 raise ValueError("Missing the required parameter `account_id` when calling `create_envelope_recipient_preview`") 1628 # verify the required parameter 'envelope_id' is set 1629 if ('envelope_id' not in params) or (params['envelope_id'] is None): 1630 raise ValueError("Missing the required parameter `envelope_id` when calling `create_envelope_recipient_preview`") 1631 1632 1633 collection_formats = {} 1634 1635 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/recipient_preview'.replace('{format}', 'json') 1636 path_params = {} 1637 if 'account_id' in params: 1638 path_params['accountId'] = params['account_id'] 1639 if 'envelope_id' in params: 1640 path_params['envelopeId'] = params['envelope_id'] 1641 1642 query_params = {} 1643 1644 header_params = {} 1645 1646 form_params = [] 1647 local_var_files = {} 1648 1649 body_params = None 1650 if 'recipient_preview_request' in params: 1651 body_params = params['recipient_preview_request'] 1652 # HTTP header `Accept` 1653 header_params['Accept'] = self.api_client.\ 1654 select_header_accept(['application/json']) 1655 1656 # Authentication setting 1657 auth_settings = [] 1658 1659 return self.api_client.call_api(resource_path, 'POST', 1660 path_params, 1661 query_params, 1662 header_params, 1663 body=body_params, 1664 post_params=form_params, 1665 files=local_var_files, 1666 response_type='ViewUrl', 1667 auth_settings=auth_settings, 1668 callback=params.get('callback'), 1669 _return_http_data_only=params.get('_return_http_data_only'), 1670 _preload_content=params.get('_preload_content', True), 1671 _request_timeout=params.get('_request_timeout'), 1672 collection_formats=collection_formats) 1673 1674 def create_envelope_recipient_shared_view(self, account_id, envelope_id, **kwargs): 1675 """ 1676 Provides a URL to start a shared recipient view of the Envelope UI 1677 Returns a URL that enables you to embed the DocuSign UI recipient view of a [shared envelope](https://support.docusign.com/en/guides/ndse-admin-guide-share-envelopes) in your applications. This is the view that a user sees of an envelope that a recipient on the same account has shared with them. Due to screen space issues, do not use an `<iframe>` for embedded operations on mobile devices. For iOS devices, DocuSign recommends using a WebView. ### Revoking the URL You can revoke this URL by making a DELETE HTTP request to the URL with no request body. ### Related topics - [Embedded signing and sending](/docs/esign-rest-api/esign101/concepts/embedding/) - [How to send an envelope via your app](/docs/esign-rest-api/how-to/embedded-sending/) - [How to embed the DocuSign UI in your app](/docs/esign-rest-api/how-to/embed-ui/) 1678 This method makes a synchronous HTTP request by default. To make an 1679 asynchronous HTTP request, please define a `callback` function 1680 to be invoked when receiving the response. 1681 >>> def callback_function(response): 1682 >>> pprint(response) 1683 >>> 1684 >>> thread = api.create_envelope_recipient_shared_view(account_id, envelope_id, callback=callback_function) 1685 1686 :param callback function: The callback function 1687 for asynchronous request. (optional) 1688 :param str account_id: The external account number (int) or account ID Guid. (required) 1689 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1690 :param RecipientViewRequest recipient_view_request: 1691 :return: ViewUrl 1692 If the method is called asynchronously, 1693 returns the request thread. 1694 """ 1695 kwargs['_return_http_data_only'] = True 1696 if kwargs.get('callback'): 1697 return self.create_envelope_recipient_shared_view_with_http_info(account_id, envelope_id, **kwargs) 1698 else: 1699 (data) = self.create_envelope_recipient_shared_view_with_http_info(account_id, envelope_id, **kwargs) 1700 return data 1701 1702 def create_envelope_recipient_shared_view_with_http_info(self, account_id, envelope_id, **kwargs): 1703 """ 1704 Provides a URL to start a shared recipient view of the Envelope UI 1705 Returns a URL that enables you to embed the DocuSign UI recipient view of a [shared envelope](https://support.docusign.com/en/guides/ndse-admin-guide-share-envelopes) in your applications. This is the view that a user sees of an envelope that a recipient on the same account has shared with them. Due to screen space issues, do not use an `<iframe>` for embedded operations on mobile devices. For iOS devices, DocuSign recommends using a WebView. ### Revoking the URL You can revoke this URL by making a DELETE HTTP request to the URL with no request body. ### Related topics - [Embedded signing and sending](/docs/esign-rest-api/esign101/concepts/embedding/) - [How to send an envelope via your app](/docs/esign-rest-api/how-to/embedded-sending/) - [How to embed the DocuSign UI in your app](/docs/esign-rest-api/how-to/embed-ui/) 1706 This method makes a synchronous HTTP request by default. To make an 1707 asynchronous HTTP request, please define a `callback` function 1708 to be invoked when receiving the response. 1709 >>> def callback_function(response): 1710 >>> pprint(response) 1711 >>> 1712 >>> thread = api.create_envelope_recipient_shared_view_with_http_info(account_id, envelope_id, callback=callback_function) 1713 1714 :param callback function: The callback function 1715 for asynchronous request. (optional) 1716 :param str account_id: The external account number (int) or account ID Guid. (required) 1717 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1718 :param RecipientViewRequest recipient_view_request: 1719 :return: ViewUrl 1720 If the method is called asynchronously, 1721 returns the request thread. 1722 """ 1723 1724 all_params = ['account_id', 'envelope_id', 'recipient_view_request'] 1725 all_params.append('callback') 1726 all_params.append('_return_http_data_only') 1727 all_params.append('_preload_content') 1728 all_params.append('_request_timeout') 1729 1730 params = locals() 1731 for key, val in iteritems(params['kwargs']): 1732 if key not in all_params: 1733 raise TypeError( 1734 "Got an unexpected keyword argument '%s'" 1735 " to method create_envelope_recipient_shared_view" % key 1736 ) 1737 params[key] = val 1738 del params['kwargs'] 1739 # verify the required parameter 'account_id' is set 1740 if ('account_id' not in params) or (params['account_id'] is None): 1741 raise ValueError("Missing the required parameter `account_id` when calling `create_envelope_recipient_shared_view`") 1742 # verify the required parameter 'envelope_id' is set 1743 if ('envelope_id' not in params) or (params['envelope_id'] is None): 1744 raise ValueError("Missing the required parameter `envelope_id` when calling `create_envelope_recipient_shared_view`") 1745 1746 1747 collection_formats = {} 1748 1749 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/shared'.replace('{format}', 'json') 1750 path_params = {} 1751 if 'account_id' in params: 1752 path_params['accountId'] = params['account_id'] 1753 if 'envelope_id' in params: 1754 path_params['envelopeId'] = params['envelope_id'] 1755 1756 query_params = {} 1757 1758 header_params = {} 1759 1760 form_params = [] 1761 local_var_files = {} 1762 1763 body_params = None 1764 if 'recipient_view_request' in params: 1765 body_params = params['recipient_view_request'] 1766 # HTTP header `Accept` 1767 header_params['Accept'] = self.api_client.\ 1768 select_header_accept(['application/json']) 1769 1770 # Authentication setting 1771 auth_settings = [] 1772 1773 return self.api_client.call_api(resource_path, 'POST', 1774 path_params, 1775 query_params, 1776 header_params, 1777 body=body_params, 1778 post_params=form_params, 1779 files=local_var_files, 1780 response_type='ViewUrl', 1781 auth_settings=auth_settings, 1782 callback=params.get('callback'), 1783 _return_http_data_only=params.get('_return_http_data_only'), 1784 _preload_content=params.get('_preload_content', True), 1785 _request_timeout=params.get('_request_timeout'), 1786 collection_formats=collection_formats) 1787 1788 def create_envelope_transfer_rules(self, account_id, **kwargs): 1789 """ 1790 Add envelope transfer rules to an account. 1791 This method creates an envelope transfer rule. When you create an envelope transfer rule, you specify the following properties: - `eventType` - `fromGroups` - `toUser` - `toFolder` - `carbonCopyOriginalOwner` - `enabled` **Note:** Only Administrators can create envelope transfer rules. In addition, to use envelope transfer rules, the **Transfer Custody** feature must be enabled for your account. 1792 This method makes a synchronous HTTP request by default. To make an 1793 asynchronous HTTP request, please define a `callback` function 1794 to be invoked when receiving the response. 1795 >>> def callback_function(response): 1796 >>> pprint(response) 1797 >>> 1798 >>> thread = api.create_envelope_transfer_rules(account_id, callback=callback_function) 1799 1800 :param callback function: The callback function 1801 for asynchronous request. (optional) 1802 :param str account_id: The external account number (int) or account ID Guid. (required) 1803 :param EnvelopeTransferRuleRequest envelope_transfer_rule_request: 1804 :return: EnvelopeTransferRuleInformation 1805 If the method is called asynchronously, 1806 returns the request thread. 1807 """ 1808 kwargs['_return_http_data_only'] = True 1809 if kwargs.get('callback'): 1810 return self.create_envelope_transfer_rules_with_http_info(account_id, **kwargs) 1811 else: 1812 (data) = self.create_envelope_transfer_rules_with_http_info(account_id, **kwargs) 1813 return data 1814 1815 def create_envelope_transfer_rules_with_http_info(self, account_id, **kwargs): 1816 """ 1817 Add envelope transfer rules to an account. 1818 This method creates an envelope transfer rule. When you create an envelope transfer rule, you specify the following properties: - `eventType` - `fromGroups` - `toUser` - `toFolder` - `carbonCopyOriginalOwner` - `enabled` **Note:** Only Administrators can create envelope transfer rules. In addition, to use envelope transfer rules, the **Transfer Custody** feature must be enabled for your account. 1819 This method makes a synchronous HTTP request by default. To make an 1820 asynchronous HTTP request, please define a `callback` function 1821 to be invoked when receiving the response. 1822 >>> def callback_function(response): 1823 >>> pprint(response) 1824 >>> 1825 >>> thread = api.create_envelope_transfer_rules_with_http_info(account_id, callback=callback_function) 1826 1827 :param callback function: The callback function 1828 for asynchronous request. (optional) 1829 :param str account_id: The external account number (int) or account ID Guid. (required) 1830 :param EnvelopeTransferRuleRequest envelope_transfer_rule_request: 1831 :return: EnvelopeTransferRuleInformation 1832 If the method is called asynchronously, 1833 returns the request thread. 1834 """ 1835 1836 all_params = ['account_id', 'envelope_transfer_rule_request'] 1837 all_params.append('callback') 1838 all_params.append('_return_http_data_only') 1839 all_params.append('_preload_content') 1840 all_params.append('_request_timeout') 1841 1842 params = locals() 1843 for key, val in iteritems(params['kwargs']): 1844 if key not in all_params: 1845 raise TypeError( 1846 "Got an unexpected keyword argument '%s'" 1847 " to method create_envelope_transfer_rules" % key 1848 ) 1849 params[key] = val 1850 del params['kwargs'] 1851 # verify the required parameter 'account_id' is set 1852 if ('account_id' not in params) or (params['account_id'] is None): 1853 raise ValueError("Missing the required parameter `account_id` when calling `create_envelope_transfer_rules`") 1854 1855 1856 collection_formats = {} 1857 1858 resource_path = '/v2.1/accounts/{accountId}/envelopes/transfer_rules'.replace('{format}', 'json') 1859 path_params = {} 1860 if 'account_id' in params: 1861 path_params['accountId'] = params['account_id'] 1862 1863 query_params = {} 1864 1865 header_params = {} 1866 1867 form_params = [] 1868 local_var_files = {} 1869 1870 body_params = None 1871 if 'envelope_transfer_rule_request' in params: 1872 body_params = params['envelope_transfer_rule_request'] 1873 # HTTP header `Accept` 1874 header_params['Accept'] = self.api_client.\ 1875 select_header_accept(['application/json']) 1876 1877 # Authentication setting 1878 auth_settings = [] 1879 1880 return self.api_client.call_api(resource_path, 'POST', 1881 path_params, 1882 query_params, 1883 header_params, 1884 body=body_params, 1885 post_params=form_params, 1886 files=local_var_files, 1887 response_type='EnvelopeTransferRuleInformation', 1888 auth_settings=auth_settings, 1889 callback=params.get('callback'), 1890 _return_http_data_only=params.get('_return_http_data_only'), 1891 _preload_content=params.get('_preload_content', True), 1892 _request_timeout=params.get('_request_timeout'), 1893 collection_formats=collection_formats) 1894 1895 def create_envelope_workflow_step_definition(self, account_id, envelope_id, **kwargs): 1896 """ 1897 Creates and adds a new workflow step definition for an envelope's workflow 1898 This method makes a synchronous HTTP request by default. To make an 1899 asynchronous HTTP request, please define a `callback` function 1900 to be invoked when receiving the response. 1901 >>> def callback_function(response): 1902 >>> pprint(response) 1903 >>> 1904 >>> thread = api.create_envelope_workflow_step_definition(account_id, envelope_id, callback=callback_function) 1905 1906 :param callback function: The callback function 1907 for asynchronous request. (optional) 1908 :param str account_id: The external account number (int) or account ID Guid. (required) 1909 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1910 :param WorkflowStep workflow_step: 1911 :return: WorkflowStep 1912 If the method is called asynchronously, 1913 returns the request thread. 1914 """ 1915 kwargs['_return_http_data_only'] = True 1916 if kwargs.get('callback'): 1917 return self.create_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, **kwargs) 1918 else: 1919 (data) = self.create_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, **kwargs) 1920 return data 1921 1922 def create_envelope_workflow_step_definition_with_http_info(self, account_id, envelope_id, **kwargs): 1923 """ 1924 Creates and adds a new workflow step definition for an envelope's workflow 1925 This method makes a synchronous HTTP request by default. To make an 1926 asynchronous HTTP request, please define a `callback` function 1927 to be invoked when receiving the response. 1928 >>> def callback_function(response): 1929 >>> pprint(response) 1930 >>> 1931 >>> thread = api.create_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, callback=callback_function) 1932 1933 :param callback function: The callback function 1934 for asynchronous request. (optional) 1935 :param str account_id: The external account number (int) or account ID Guid. (required) 1936 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1937 :param WorkflowStep workflow_step: 1938 :return: WorkflowStep 1939 If the method is called asynchronously, 1940 returns the request thread. 1941 """ 1942 1943 all_params = ['account_id', 'envelope_id', 'workflow_step'] 1944 all_params.append('callback') 1945 all_params.append('_return_http_data_only') 1946 all_params.append('_preload_content') 1947 all_params.append('_request_timeout') 1948 1949 params = locals() 1950 for key, val in iteritems(params['kwargs']): 1951 if key not in all_params: 1952 raise TypeError( 1953 "Got an unexpected keyword argument '%s'" 1954 " to method create_envelope_workflow_step_definition" % key 1955 ) 1956 params[key] = val 1957 del params['kwargs'] 1958 # verify the required parameter 'account_id' is set 1959 if ('account_id' not in params) or (params['account_id'] is None): 1960 raise ValueError("Missing the required parameter `account_id` when calling `create_envelope_workflow_step_definition`") 1961 # verify the required parameter 'envelope_id' is set 1962 if ('envelope_id' not in params) or (params['envelope_id'] is None): 1963 raise ValueError("Missing the required parameter `envelope_id` when calling `create_envelope_workflow_step_definition`") 1964 1965 1966 collection_formats = {} 1967 1968 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps'.replace('{format}', 'json') 1969 path_params = {} 1970 if 'account_id' in params: 1971 path_params['accountId'] = params['account_id'] 1972 if 'envelope_id' in params: 1973 path_params['envelopeId'] = params['envelope_id'] 1974 1975 query_params = {} 1976 1977 header_params = {} 1978 1979 form_params = [] 1980 local_var_files = {} 1981 1982 body_params = None 1983 if 'workflow_step' in params: 1984 body_params = params['workflow_step'] 1985 # HTTP header `Accept` 1986 header_params['Accept'] = self.api_client.\ 1987 select_header_accept(['application/json']) 1988 1989 # Authentication setting 1990 auth_settings = [] 1991 1992 return self.api_client.call_api(resource_path, 'POST', 1993 path_params, 1994 query_params, 1995 header_params, 1996 body=body_params, 1997 post_params=form_params, 1998 files=local_var_files, 1999 response_type='WorkflowStep', 2000 auth_settings=auth_settings, 2001 callback=params.get('callback'), 2002 _return_http_data_only=params.get('_return_http_data_only'), 2003 _preload_content=params.get('_preload_content', True), 2004 _request_timeout=params.get('_request_timeout'), 2005 collection_formats=collection_formats) 2006 2007 def create_historical_envelope_publish_transaction(self, account_id, **kwargs): 2008 """ 2009 Submits a batch of historical envelopes for republish to an adhoc config. 2010 This method makes a synchronous HTTP request by default. To make an 2011 asynchronous HTTP request, please define a `callback` function 2012 to be invoked when receiving the response. 2013 >>> def callback_function(response): 2014 >>> pprint(response) 2015 >>> 2016 >>> thread = api.create_historical_envelope_publish_transaction(account_id, callback=callback_function) 2017 2018 :param callback function: The callback function 2019 for asynchronous request. (optional) 2020 :param str account_id: The external account number (int) or account ID Guid. (required) 2021 :param ConnectHistoricalEnvelopeRepublish connect_historical_envelope_republish: 2022 :return: EnvelopePublishTransaction 2023 If the method is called asynchronously, 2024 returns the request thread. 2025 """ 2026 kwargs['_return_http_data_only'] = True 2027 if kwargs.get('callback'): 2028 return self.create_historical_envelope_publish_transaction_with_http_info(account_id, **kwargs) 2029 else: 2030 (data) = self.create_historical_envelope_publish_transaction_with_http_info(account_id, **kwargs) 2031 return data 2032 2033 def create_historical_envelope_publish_transaction_with_http_info(self, account_id, **kwargs): 2034 """ 2035 Submits a batch of historical envelopes for republish to an adhoc config. 2036 This method makes a synchronous HTTP request by default. To make an 2037 asynchronous HTTP request, please define a `callback` function 2038 to be invoked when receiving the response. 2039 >>> def callback_function(response): 2040 >>> pprint(response) 2041 >>> 2042 >>> thread = api.create_historical_envelope_publish_transaction_with_http_info(account_id, callback=callback_function) 2043 2044 :param callback function: The callback function 2045 for asynchronous request. (optional) 2046 :param str account_id: The external account number (int) or account ID Guid. (required) 2047 :param ConnectHistoricalEnvelopeRepublish connect_historical_envelope_republish: 2048 :return: EnvelopePublishTransaction 2049 If the method is called asynchronously, 2050 returns the request thread. 2051 """ 2052 2053 all_params = ['account_id', 'connect_historical_envelope_republish'] 2054 all_params.append('callback') 2055 all_params.append('_return_http_data_only') 2056 all_params.append('_preload_content') 2057 all_params.append('_request_timeout') 2058 2059 params = locals() 2060 for key, val in iteritems(params['kwargs']): 2061 if key not in all_params: 2062 raise TypeError( 2063 "Got an unexpected keyword argument '%s'" 2064 " to method create_historical_envelope_publish_transaction" % key 2065 ) 2066 params[key] = val 2067 del params['kwargs'] 2068 # verify the required parameter 'account_id' is set 2069 if ('account_id' not in params) or (params['account_id'] is None): 2070 raise ValueError("Missing the required parameter `account_id` when calling `create_historical_envelope_publish_transaction`") 2071 2072 2073 collection_formats = {} 2074 2075 resource_path = '/v2.1/accounts/{accountId}/connect/envelopes/publish/historical'.replace('{format}', 'json') 2076 path_params = {} 2077 if 'account_id' in params: 2078 path_params['accountId'] = params['account_id'] 2079 2080 query_params = {} 2081 2082 header_params = {} 2083 2084 form_params = [] 2085 local_var_files = {} 2086 2087 body_params = None 2088 if 'connect_historical_envelope_republish' in params: 2089 body_params = params['connect_historical_envelope_republish'] 2090 # HTTP header `Accept` 2091 header_params['Accept'] = self.api_client.\ 2092 select_header_accept(['application/json']) 2093 2094 # Authentication setting 2095 auth_settings = [] 2096 2097 return self.api_client.call_api(resource_path, 'POST', 2098 path_params, 2099 query_params, 2100 header_params, 2101 body=body_params, 2102 post_params=form_params, 2103 files=local_var_files, 2104 response_type='EnvelopePublishTransaction', 2105 auth_settings=auth_settings, 2106 callback=params.get('callback'), 2107 _return_http_data_only=params.get('_return_http_data_only'), 2108 _preload_content=params.get('_preload_content', True), 2109 _request_timeout=params.get('_request_timeout'), 2110 collection_formats=collection_formats) 2111 2112 def create_lock(self, account_id, envelope_id, **kwargs): 2113 """ 2114 Lock an envelope. 2115 Locks the specified envelope, and sets the time until the lock expires, to prevent other users or recipients from accessing and changing the envelope. ###### Note: Users must have envelope locking capability enabled to use this function (userSetting `canLockEnvelopes` must be set to true for the user). 2116 This method makes a synchronous HTTP request by default. To make an 2117 asynchronous HTTP request, please define a `callback` function 2118 to be invoked when receiving the response. 2119 >>> def callback_function(response): 2120 >>> pprint(response) 2121 >>> 2122 >>> thread = api.create_lock(account_id, envelope_id, callback=callback_function) 2123 2124 :param callback function: The callback function 2125 for asynchronous request. (optional) 2126 :param str account_id: The external account number (int) or account ID Guid. (required) 2127 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2128 :param LockRequest lock_request: 2129 :return: LockInformation 2130 If the method is called asynchronously, 2131 returns the request thread. 2132 """ 2133 kwargs['_return_http_data_only'] = True 2134 if kwargs.get('callback'): 2135 return self.create_lock_with_http_info(account_id, envelope_id, **kwargs) 2136 else: 2137 (data) = self.create_lock_with_http_info(account_id, envelope_id, **kwargs) 2138 return data 2139 2140 def create_lock_with_http_info(self, account_id, envelope_id, **kwargs): 2141 """ 2142 Lock an envelope. 2143 Locks the specified envelope, and sets the time until the lock expires, to prevent other users or recipients from accessing and changing the envelope. ###### Note: Users must have envelope locking capability enabled to use this function (userSetting `canLockEnvelopes` must be set to true for the user). 2144 This method makes a synchronous HTTP request by default. To make an 2145 asynchronous HTTP request, please define a `callback` function 2146 to be invoked when receiving the response. 2147 >>> def callback_function(response): 2148 >>> pprint(response) 2149 >>> 2150 >>> thread = api.create_lock_with_http_info(account_id, envelope_id, callback=callback_function) 2151 2152 :param callback function: The callback function 2153 for asynchronous request. (optional) 2154 :param str account_id: The external account number (int) or account ID Guid. (required) 2155 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2156 :param LockRequest lock_request: 2157 :return: LockInformation 2158 If the method is called asynchronously, 2159 returns the request thread. 2160 """ 2161 2162 all_params = ['account_id', 'envelope_id', 'lock_request'] 2163 all_params.append('callback') 2164 all_params.append('_return_http_data_only') 2165 all_params.append('_preload_content') 2166 all_params.append('_request_timeout') 2167 2168 params = locals() 2169 for key, val in iteritems(params['kwargs']): 2170 if key not in all_params: 2171 raise TypeError( 2172 "Got an unexpected keyword argument '%s'" 2173 " to method create_lock" % key 2174 ) 2175 params[key] = val 2176 del params['kwargs'] 2177 # verify the required parameter 'account_id' is set 2178 if ('account_id' not in params) or (params['account_id'] is None): 2179 raise ValueError("Missing the required parameter `account_id` when calling `create_lock`") 2180 # verify the required parameter 'envelope_id' is set 2181 if ('envelope_id' not in params) or (params['envelope_id'] is None): 2182 raise ValueError("Missing the required parameter `envelope_id` when calling `create_lock`") 2183 2184 2185 collection_formats = {} 2186 2187 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/lock'.replace('{format}', 'json') 2188 path_params = {} 2189 if 'account_id' in params: 2190 path_params['accountId'] = params['account_id'] 2191 if 'envelope_id' in params: 2192 path_params['envelopeId'] = params['envelope_id'] 2193 2194 query_params = {} 2195 2196 header_params = {} 2197 2198 form_params = [] 2199 local_var_files = {} 2200 2201 body_params = None 2202 if 'lock_request' in params: 2203 body_params = params['lock_request'] 2204 # HTTP header `Accept` 2205 header_params['Accept'] = self.api_client.\ 2206 select_header_accept(['application/json']) 2207 2208 # Authentication setting 2209 auth_settings = [] 2210 2211 return self.api_client.call_api(resource_path, 'POST', 2212 path_params, 2213 query_params, 2214 header_params, 2215 body=body_params, 2216 post_params=form_params, 2217 files=local_var_files, 2218 response_type='LockInformation', 2219 auth_settings=auth_settings, 2220 callback=params.get('callback'), 2221 _return_http_data_only=params.get('_return_http_data_only'), 2222 _preload_content=params.get('_preload_content', True), 2223 _request_timeout=params.get('_request_timeout'), 2224 collection_formats=collection_formats) 2225 2226 def create_recipient(self, account_id, envelope_id, **kwargs): 2227 """ 2228 Adds one or more recipients to an envelope. 2229 Adds one or more recipients to an envelope. For an in process envelope, one that has been sent and has not been completed or voided, an email is sent to a new recipient when they are reached in the routing order. If the new recipient's routing order is before or the same as the envelope's next recipient, an email is only sent if the optional `resend_envelope` query string is set to **true**. 2230 This method makes a synchronous HTTP request by default. To make an 2231 asynchronous HTTP request, please define a `callback` function 2232 to be invoked when receiving the response. 2233 >>> def callback_function(response): 2234 >>> pprint(response) 2235 >>> 2236 >>> thread = api.create_recipient(account_id, envelope_id, callback=callback_function) 2237 2238 :param callback function: The callback function 2239 for asynchronous request. (optional) 2240 :param str account_id: The external account number (int) or account ID Guid. (required) 2241 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2242 :param str resend_envelope: When set to **true**, resends the envelope if the new recipient's routing order is before or the same as the envelope's next recipient. 2243 :param Recipients recipients: 2244 :return: Recipients 2245 If the method is called asynchronously, 2246 returns the request thread. 2247 """ 2248 kwargs['_return_http_data_only'] = True 2249 if kwargs.get('callback'): 2250 return self.create_recipient_with_http_info(account_id, envelope_id, **kwargs) 2251 else: 2252 (data) = self.create_recipient_with_http_info(account_id, envelope_id, **kwargs) 2253 return data 2254 2255 def create_recipient_with_http_info(self, account_id, envelope_id, **kwargs): 2256 """ 2257 Adds one or more recipients to an envelope. 2258 Adds one or more recipients to an envelope. For an in process envelope, one that has been sent and has not been completed or voided, an email is sent to a new recipient when they are reached in the routing order. If the new recipient's routing order is before or the same as the envelope's next recipient, an email is only sent if the optional `resend_envelope` query string is set to **true**. 2259 This method makes a synchronous HTTP request by default. To make an 2260 asynchronous HTTP request, please define a `callback` function 2261 to be invoked when receiving the response. 2262 >>> def callback_function(response): 2263 >>> pprint(response) 2264 >>> 2265 >>> thread = api.create_recipient_with_http_info(account_id, envelope_id, callback=callback_function) 2266 2267 :param callback function: The callback function 2268 for asynchronous request. (optional) 2269 :param str account_id: The external account number (int) or account ID Guid. (required) 2270 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2271 :param str resend_envelope: When set to **true**, resends the envelope if the new recipient's routing order is before or the same as the envelope's next recipient. 2272 :param Recipients recipients: 2273 :return: Recipients 2274 If the method is called asynchronously, 2275 returns the request thread. 2276 """ 2277 2278 all_params = ['account_id', 'envelope_id', 'resend_envelope', 'recipients'] 2279 all_params.append('callback') 2280 all_params.append('_return_http_data_only') 2281 all_params.append('_preload_content') 2282 all_params.append('_request_timeout') 2283 2284 params = locals() 2285 for key, val in iteritems(params['kwargs']): 2286 if key not in all_params: 2287 raise TypeError( 2288 "Got an unexpected keyword argument '%s'" 2289 " to method create_recipient" % key 2290 ) 2291 params[key] = val 2292 del params['kwargs'] 2293 # verify the required parameter 'account_id' is set 2294 if ('account_id' not in params) or (params['account_id'] is None): 2295 raise ValueError("Missing the required parameter `account_id` when calling `create_recipient`") 2296 # verify the required parameter 'envelope_id' is set 2297 if ('envelope_id' not in params) or (params['envelope_id'] is None): 2298 raise ValueError("Missing the required parameter `envelope_id` when calling `create_recipient`") 2299 2300 2301 collection_formats = {} 2302 2303 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients'.replace('{format}', 'json') 2304 path_params = {} 2305 if 'account_id' in params: 2306 path_params['accountId'] = params['account_id'] 2307 if 'envelope_id' in params: 2308 path_params['envelopeId'] = params['envelope_id'] 2309 2310 query_params = {} 2311 if 'resend_envelope' in params: 2312 query_params['resend_envelope'] = params['resend_envelope'] 2313 2314 header_params = {} 2315 2316 form_params = [] 2317 local_var_files = {} 2318 2319 body_params = None 2320 if 'recipients' in params: 2321 body_params = params['recipients'] 2322 # HTTP header `Accept` 2323 header_params['Accept'] = self.api_client.\ 2324 select_header_accept(['application/json']) 2325 2326 # Authentication setting 2327 auth_settings = [] 2328 2329 return self.api_client.call_api(resource_path, 'POST', 2330 path_params, 2331 query_params, 2332 header_params, 2333 body=body_params, 2334 post_params=form_params, 2335 files=local_var_files, 2336 response_type='Recipients', 2337 auth_settings=auth_settings, 2338 callback=params.get('callback'), 2339 _return_http_data_only=params.get('_return_http_data_only'), 2340 _preload_content=params.get('_preload_content', True), 2341 _request_timeout=params.get('_request_timeout'), 2342 collection_formats=collection_formats) 2343 2344 def create_recipient_manual_review_view(self, account_id, envelope_id, recipient_id, **kwargs): 2345 """ 2346 Provides a link to access the Identity manual review related to a recipient. 2347 This method returns the URL of the page that allows a sender to [manually review](https://support.docusign.com/en/guides/ndse-user-guide-send-documents-with-id-verification) the ID of a recipient. 2348 This method makes a synchronous HTTP request by default. To make an 2349 asynchronous HTTP request, please define a `callback` function 2350 to be invoked when receiving the response. 2351 >>> def callback_function(response): 2352 >>> pprint(response) 2353 >>> 2354 >>> thread = api.create_recipient_manual_review_view(account_id, envelope_id, recipient_id, callback=callback_function) 2355 2356 :param callback function: The callback function 2357 for asynchronous request. (optional) 2358 :param str account_id: The external account number (int) or account ID Guid. (required) 2359 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2360 :param str recipient_id: The ID of the recipient being accessed. (required) 2361 :return: ViewUrl 2362 If the method is called asynchronously, 2363 returns the request thread. 2364 """ 2365 kwargs['_return_http_data_only'] = True 2366 if kwargs.get('callback'): 2367 return self.create_recipient_manual_review_view_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 2368 else: 2369 (data) = self.create_recipient_manual_review_view_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 2370 return data 2371 2372 def create_recipient_manual_review_view_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 2373 """ 2374 Provides a link to access the Identity manual review related to a recipient. 2375 This method returns the URL of the page that allows a sender to [manually review](https://support.docusign.com/en/guides/ndse-user-guide-send-documents-with-id-verification) the ID of a recipient. 2376 This method makes a synchronous HTTP request by default. To make an 2377 asynchronous HTTP request, please define a `callback` function 2378 to be invoked when receiving the response. 2379 >>> def callback_function(response): 2380 >>> pprint(response) 2381 >>> 2382 >>> thread = api.create_recipient_manual_review_view_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 2383 2384 :param callback function: The callback function 2385 for asynchronous request. (optional) 2386 :param str account_id: The external account number (int) or account ID Guid. (required) 2387 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2388 :param str recipient_id: The ID of the recipient being accessed. (required) 2389 :return: ViewUrl 2390 If the method is called asynchronously, 2391 returns the request thread. 2392 """ 2393 2394 all_params = ['account_id', 'envelope_id', 'recipient_id'] 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 create_recipient_manual_review_view" % 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 `create_recipient_manual_review_view`") 2412 # verify the required parameter 'envelope_id' is set 2413 if ('envelope_id' not in params) or (params['envelope_id'] is None): 2414 raise ValueError("Missing the required parameter `envelope_id` when calling `create_recipient_manual_review_view`") 2415 # verify the required parameter 'recipient_id' is set 2416 if ('recipient_id' not in params) or (params['recipient_id'] is None): 2417 raise ValueError("Missing the required parameter `recipient_id` when calling `create_recipient_manual_review_view`") 2418 2419 2420 collection_formats = {} 2421 2422 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/views/identity_manual_review'.replace('{format}', 'json') 2423 path_params = {} 2424 if 'account_id' in params: 2425 path_params['accountId'] = params['account_id'] 2426 if 'envelope_id' in params: 2427 path_params['envelopeId'] = params['envelope_id'] 2428 if 'recipient_id' in params: 2429 path_params['recipientId'] = params['recipient_id'] 2430 2431 query_params = {} 2432 2433 header_params = {} 2434 2435 form_params = [] 2436 local_var_files = {} 2437 2438 body_params = None 2439 # HTTP header `Accept` 2440 header_params['Accept'] = self.api_client.\ 2441 select_header_accept(['application/json']) 2442 2443 # Authentication setting 2444 auth_settings = [] 2445 2446 return self.api_client.call_api(resource_path, 'POST', 2447 path_params, 2448 query_params, 2449 header_params, 2450 body=body_params, 2451 post_params=form_params, 2452 files=local_var_files, 2453 response_type='ViewUrl', 2454 auth_settings=auth_settings, 2455 callback=params.get('callback'), 2456 _return_http_data_only=params.get('_return_http_data_only'), 2457 _preload_content=params.get('_preload_content', True), 2458 _request_timeout=params.get('_request_timeout'), 2459 collection_formats=collection_formats) 2460 2461 def create_recipient_proof_file_link(self, account_id, envelope_id, recipient_id, **kwargs): 2462 """ 2463 Returns a link to access to the identity events stored in the proof service related to this recipient. 2464 2465 This method makes a synchronous HTTP request by default. To make an 2466 asynchronous HTTP request, please define a `callback` function 2467 to be invoked when receiving the response. 2468 >>> def callback_function(response): 2469 >>> pprint(response) 2470 >>> 2471 >>> thread = api.create_recipient_proof_file_link(account_id, envelope_id, recipient_id, callback=callback_function) 2472 2473 :param callback function: The callback function 2474 for asynchronous request. (optional) 2475 :param str account_id: The external account number (int) or account ID Guid. (required) 2476 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2477 :param str recipient_id: The ID of the recipient being accessed. (required) 2478 :return: IdEvidenceViewLink 2479 If the method is called asynchronously, 2480 returns the request thread. 2481 """ 2482 kwargs['_return_http_data_only'] = True 2483 if kwargs.get('callback'): 2484 return self.create_recipient_proof_file_link_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 2485 else: 2486 (data) = self.create_recipient_proof_file_link_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 2487 return data 2488 2489 def create_recipient_proof_file_link_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 2490 """ 2491 Returns a link to access to the identity events stored in the proof service related to this recipient. 2492 2493 This method makes a synchronous HTTP request by default. To make an 2494 asynchronous HTTP request, please define a `callback` function 2495 to be invoked when receiving the response. 2496 >>> def callback_function(response): 2497 >>> pprint(response) 2498 >>> 2499 >>> thread = api.create_recipient_proof_file_link_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 2500 2501 :param callback function: The callback function 2502 for asynchronous request. (optional) 2503 :param str account_id: The external account number (int) or account ID Guid. (required) 2504 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2505 :param str recipient_id: The ID of the recipient being accessed. (required) 2506 :return: IdEvidenceViewLink 2507 If the method is called asynchronously, 2508 returns the request thread. 2509 """ 2510 2511 all_params = ['account_id', 'envelope_id', 'recipient_id'] 2512 all_params.append('callback') 2513 all_params.append('_return_http_data_only') 2514 all_params.append('_preload_content') 2515 all_params.append('_request_timeout') 2516 2517 params = locals() 2518 for key, val in iteritems(params['kwargs']): 2519 if key not in all_params: 2520 raise TypeError( 2521 "Got an unexpected keyword argument '%s'" 2522 " to method create_recipient_proof_file_link" % key 2523 ) 2524 params[key] = val 2525 del params['kwargs'] 2526 # verify the required parameter 'account_id' is set 2527 if ('account_id' not in params) or (params['account_id'] is None): 2528 raise ValueError("Missing the required parameter `account_id` when calling `create_recipient_proof_file_link`") 2529 # verify the required parameter 'envelope_id' is set 2530 if ('envelope_id' not in params) or (params['envelope_id'] is None): 2531 raise ValueError("Missing the required parameter `envelope_id` when calling `create_recipient_proof_file_link`") 2532 # verify the required parameter 'recipient_id' is set 2533 if ('recipient_id' not in params) or (params['recipient_id'] is None): 2534 raise ValueError("Missing the required parameter `recipient_id` when calling `create_recipient_proof_file_link`") 2535 2536 2537 collection_formats = {} 2538 2539 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/identity_proof'.replace('{format}', 'json') 2540 path_params = {} 2541 if 'account_id' in params: 2542 path_params['accountId'] = params['account_id'] 2543 if 'envelope_id' in params: 2544 path_params['envelopeId'] = params['envelope_id'] 2545 if 'recipient_id' in params: 2546 path_params['recipientId'] = params['recipient_id'] 2547 2548 query_params = {} 2549 2550 header_params = {} 2551 2552 form_params = [] 2553 local_var_files = {} 2554 2555 body_params = None 2556 # HTTP header `Accept` 2557 header_params['Accept'] = self.api_client.\ 2558 select_header_accept(['application/json']) 2559 2560 # Authentication setting 2561 auth_settings = [] 2562 2563 return self.api_client.call_api(resource_path, 'POST', 2564 path_params, 2565 query_params, 2566 header_params, 2567 body=body_params, 2568 post_params=form_params, 2569 files=local_var_files, 2570 response_type='IdEvidenceViewLink', 2571 auth_settings=auth_settings, 2572 callback=params.get('callback'), 2573 _return_http_data_only=params.get('_return_http_data_only'), 2574 _preload_content=params.get('_preload_content', True), 2575 _request_timeout=params.get('_request_timeout'), 2576 collection_formats=collection_formats) 2577 2578 def create_recipient_proof_file_resource_token(self, account_id, envelope_id, recipient_id, **kwargs): 2579 """ 2580 Returns a resource token to get access to the identity events stored in the proof service related to this recipient. 2581 Creates a resource token for a sender. This token allows a sender to return identification data for a recipient using the [ID Evidence API](/docs/idevidence-api/). 2582 This method makes a synchronous HTTP request by default. To make an 2583 asynchronous HTTP request, please define a `callback` function 2584 to be invoked when receiving the response. 2585 >>> def callback_function(response): 2586 >>> pprint(response) 2587 >>> 2588 >>> thread = api.create_recipient_proof_file_resource_token(account_id, envelope_id, recipient_id, callback=callback_function) 2589 2590 :param callback function: The callback function 2591 for asynchronous request. (optional) 2592 :param str account_id: The external account number (int) or account ID Guid. (required) 2593 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2594 :param str recipient_id: The ID of the recipient being accessed. (required) 2595 :param str token_scopes: 2596 :return: IdEvidenceResourceToken 2597 If the method is called asynchronously, 2598 returns the request thread. 2599 """ 2600 kwargs['_return_http_data_only'] = True 2601 if kwargs.get('callback'): 2602 return self.create_recipient_proof_file_resource_token_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 2603 else: 2604 (data) = self.create_recipient_proof_file_resource_token_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 2605 return data 2606 2607 def create_recipient_proof_file_resource_token_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 2608 """ 2609 Returns a resource token to get access to the identity events stored in the proof service related to this recipient. 2610 Creates a resource token for a sender. This token allows a sender to return identification data for a recipient using the [ID Evidence API](/docs/idevidence-api/). 2611 This method makes a synchronous HTTP request by default. To make an 2612 asynchronous HTTP request, please define a `callback` function 2613 to be invoked when receiving the response. 2614 >>> def callback_function(response): 2615 >>> pprint(response) 2616 >>> 2617 >>> thread = api.create_recipient_proof_file_resource_token_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 2618 2619 :param callback function: The callback function 2620 for asynchronous request. (optional) 2621 :param str account_id: The external account number (int) or account ID Guid. (required) 2622 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2623 :param str recipient_id: The ID of the recipient being accessed. (required) 2624 :param str token_scopes: 2625 :return: IdEvidenceResourceToken 2626 If the method is called asynchronously, 2627 returns the request thread. 2628 """ 2629 2630 all_params = ['account_id', 'envelope_id', 'recipient_id', 'token_scopes'] 2631 all_params.append('callback') 2632 all_params.append('_return_http_data_only') 2633 all_params.append('_preload_content') 2634 all_params.append('_request_timeout') 2635 2636 params = locals() 2637 for key, val in iteritems(params['kwargs']): 2638 if key not in all_params: 2639 raise TypeError( 2640 "Got an unexpected keyword argument '%s'" 2641 " to method create_recipient_proof_file_resource_token" % key 2642 ) 2643 params[key] = val 2644 del params['kwargs'] 2645 # verify the required parameter 'account_id' is set 2646 if ('account_id' not in params) or (params['account_id'] is None): 2647 raise ValueError("Missing the required parameter `account_id` when calling `create_recipient_proof_file_resource_token`") 2648 # verify the required parameter 'envelope_id' is set 2649 if ('envelope_id' not in params) or (params['envelope_id'] is None): 2650 raise ValueError("Missing the required parameter `envelope_id` when calling `create_recipient_proof_file_resource_token`") 2651 # verify the required parameter 'recipient_id' is set 2652 if ('recipient_id' not in params) or (params['recipient_id'] is None): 2653 raise ValueError("Missing the required parameter `recipient_id` when calling `create_recipient_proof_file_resource_token`") 2654 2655 2656 collection_formats = {} 2657 2658 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/identity_proof_token'.replace('{format}', 'json') 2659 path_params = {} 2660 if 'account_id' in params: 2661 path_params['accountId'] = params['account_id'] 2662 if 'envelope_id' in params: 2663 path_params['envelopeId'] = params['envelope_id'] 2664 if 'recipient_id' in params: 2665 path_params['recipientId'] = params['recipient_id'] 2666 2667 query_params = {} 2668 if 'token_scopes' in params: 2669 query_params['token_scopes'] = params['token_scopes'] 2670 2671 header_params = {} 2672 2673 form_params = [] 2674 local_var_files = {} 2675 2676 body_params = None 2677 # HTTP header `Accept` 2678 header_params['Accept'] = self.api_client.\ 2679 select_header_accept(['application/json']) 2680 2681 # Authentication setting 2682 auth_settings = [] 2683 2684 return self.api_client.call_api(resource_path, 'POST', 2685 path_params, 2686 query_params, 2687 header_params, 2688 body=body_params, 2689 post_params=form_params, 2690 files=local_var_files, 2691 response_type='IdEvidenceResourceToken', 2692 auth_settings=auth_settings, 2693 callback=params.get('callback'), 2694 _return_http_data_only=params.get('_return_http_data_only'), 2695 _preload_content=params.get('_preload_content', True), 2696 _request_timeout=params.get('_request_timeout'), 2697 collection_formats=collection_formats) 2698 2699 def create_recipient_view(self, account_id, envelope_id, **kwargs): 2700 """ 2701 Returns a URL to the recipient view UI. 2702 Returns a URL that allows you to embed the recipient view of the DocuSign UI in your applications. This call cannot be used to view draft envelopes, since those envelopes have not been sent. Important: iFrames should not be used for embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends using a WebView. An entry is added into the Security Level section of the DocuSign Certificate of Completion that reflects the `securityDomain` and `authenticationMethod` properties used to verify the user identity. 2703 This method makes a synchronous HTTP request by default. To make an 2704 asynchronous HTTP request, please define a `callback` function 2705 to be invoked when receiving the response. 2706 >>> def callback_function(response): 2707 >>> pprint(response) 2708 >>> 2709 >>> thread = api.create_recipient_view(account_id, envelope_id, callback=callback_function) 2710 2711 :param callback function: The callback function 2712 for asynchronous request. (optional) 2713 :param str account_id: The external account number (int) or account ID Guid. (required) 2714 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2715 :param RecipientViewRequest recipient_view_request: 2716 :return: ViewUrl 2717 If the method is called asynchronously, 2718 returns the request thread. 2719 """ 2720 kwargs['_return_http_data_only'] = True 2721 if kwargs.get('callback'): 2722 return self.create_recipient_view_with_http_info(account_id, envelope_id, **kwargs) 2723 else: 2724 (data) = self.create_recipient_view_with_http_info(account_id, envelope_id, **kwargs) 2725 return data 2726 2727 def create_recipient_view_with_http_info(self, account_id, envelope_id, **kwargs): 2728 """ 2729 Returns a URL to the recipient view UI. 2730 Returns a URL that allows you to embed the recipient view of the DocuSign UI in your applications. This call cannot be used to view draft envelopes, since those envelopes have not been sent. Important: iFrames should not be used for embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends using a WebView. An entry is added into the Security Level section of the DocuSign Certificate of Completion that reflects the `securityDomain` and `authenticationMethod` properties used to verify the user identity. 2731 This method makes a synchronous HTTP request by default. To make an 2732 asynchronous HTTP request, please define a `callback` function 2733 to be invoked when receiving the response. 2734 >>> def callback_function(response): 2735 >>> pprint(response) 2736 >>> 2737 >>> thread = api.create_recipient_view_with_http_info(account_id, envelope_id, callback=callback_function) 2738 2739 :param callback function: The callback function 2740 for asynchronous request. (optional) 2741 :param str account_id: The external account number (int) or account ID Guid. (required) 2742 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2743 :param RecipientViewRequest recipient_view_request: 2744 :return: ViewUrl 2745 If the method is called asynchronously, 2746 returns the request thread. 2747 """ 2748 2749 all_params = ['account_id', 'envelope_id', 'recipient_view_request'] 2750 all_params.append('callback') 2751 all_params.append('_return_http_data_only') 2752 all_params.append('_preload_content') 2753 all_params.append('_request_timeout') 2754 2755 params = locals() 2756 for key, val in iteritems(params['kwargs']): 2757 if key not in all_params: 2758 raise TypeError( 2759 "Got an unexpected keyword argument '%s'" 2760 " to method create_recipient_view" % key 2761 ) 2762 params[key] = val 2763 del params['kwargs'] 2764 # verify the required parameter 'account_id' is set 2765 if ('account_id' not in params) or (params['account_id'] is None): 2766 raise ValueError("Missing the required parameter `account_id` when calling `create_recipient_view`") 2767 # verify the required parameter 'envelope_id' is set 2768 if ('envelope_id' not in params) or (params['envelope_id'] is None): 2769 raise ValueError("Missing the required parameter `envelope_id` when calling `create_recipient_view`") 2770 2771 2772 collection_formats = {} 2773 2774 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/recipient'.replace('{format}', 'json') 2775 path_params = {} 2776 if 'account_id' in params: 2777 path_params['accountId'] = params['account_id'] 2778 if 'envelope_id' in params: 2779 path_params['envelopeId'] = params['envelope_id'] 2780 2781 query_params = {} 2782 2783 header_params = {} 2784 2785 form_params = [] 2786 local_var_files = {} 2787 2788 body_params = None 2789 if 'recipient_view_request' in params: 2790 body_params = params['recipient_view_request'] 2791 # HTTP header `Accept` 2792 header_params['Accept'] = self.api_client.\ 2793 select_header_accept(['application/json']) 2794 2795 # Authentication setting 2796 auth_settings = [] 2797 2798 return self.api_client.call_api(resource_path, 'POST', 2799 path_params, 2800 query_params, 2801 header_params, 2802 body=body_params, 2803 post_params=form_params, 2804 files=local_var_files, 2805 response_type='ViewUrl', 2806 auth_settings=auth_settings, 2807 callback=params.get('callback'), 2808 _return_http_data_only=params.get('_return_http_data_only'), 2809 _preload_content=params.get('_preload_content', True), 2810 _request_timeout=params.get('_request_timeout'), 2811 collection_formats=collection_formats) 2812 2813 def create_responsive_html_preview(self, account_id, envelope_id, **kwargs): 2814 """ 2815 Get Responsive HTML Preview for all documents in an envelope. 2816 Creates a preview of the [responsive](/docs/esign-rest-api/esign101/concepts/responsive/), HTML versions of all of the documents in an envelope. This method enables you to preview the PDF document conversions to responsive HTML across device types prior to sending. The request body is a `documentHtmlDefinition` object, which holds the responsive signing parameters that define how to generate the HTML version of the documents. 2817 This method makes a synchronous HTTP request by default. To make an 2818 asynchronous HTTP request, please define a `callback` function 2819 to be invoked when receiving the response. 2820 >>> def callback_function(response): 2821 >>> pprint(response) 2822 >>> 2823 >>> thread = api.create_responsive_html_preview(account_id, envelope_id, callback=callback_function) 2824 2825 :param callback function: The callback function 2826 for asynchronous request. (optional) 2827 :param str account_id: The external account number (int) or account ID Guid. (required) 2828 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2829 :param DocumentHtmlDefinition document_html_definition: 2830 :return: DocumentHtmlDefinitions 2831 If the method is called asynchronously, 2832 returns the request thread. 2833 """ 2834 kwargs['_return_http_data_only'] = True 2835 if kwargs.get('callback'): 2836 return self.create_responsive_html_preview_with_http_info(account_id, envelope_id, **kwargs) 2837 else: 2838 (data) = self.create_responsive_html_preview_with_http_info(account_id, envelope_id, **kwargs) 2839 return data 2840 2841 def create_responsive_html_preview_with_http_info(self, account_id, envelope_id, **kwargs): 2842 """ 2843 Get Responsive HTML Preview for all documents in an envelope. 2844 Creates a preview of the [responsive](/docs/esign-rest-api/esign101/concepts/responsive/), HTML versions of all of the documents in an envelope. This method enables you to preview the PDF document conversions to responsive HTML across device types prior to sending. The request body is a `documentHtmlDefinition` object, which holds the responsive signing parameters that define how to generate the HTML version of the documents. 2845 This method makes a synchronous HTTP request by default. To make an 2846 asynchronous HTTP request, please define a `callback` function 2847 to be invoked when receiving the response. 2848 >>> def callback_function(response): 2849 >>> pprint(response) 2850 >>> 2851 >>> thread = api.create_responsive_html_preview_with_http_info(account_id, envelope_id, callback=callback_function) 2852 2853 :param callback function: The callback function 2854 for asynchronous request. (optional) 2855 :param str account_id: The external account number (int) or account ID Guid. (required) 2856 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2857 :param DocumentHtmlDefinition document_html_definition: 2858 :return: DocumentHtmlDefinitions 2859 If the method is called asynchronously, 2860 returns the request thread. 2861 """ 2862 2863 all_params = ['account_id', 'envelope_id', 'document_html_definition'] 2864 all_params.append('callback') 2865 all_params.append('_return_http_data_only') 2866 all_params.append('_preload_content') 2867 all_params.append('_request_timeout') 2868 2869 params = locals() 2870 for key, val in iteritems(params['kwargs']): 2871 if key not in all_params: 2872 raise TypeError( 2873 "Got an unexpected keyword argument '%s'" 2874 " to method create_responsive_html_preview" % key 2875 ) 2876 params[key] = val 2877 del params['kwargs'] 2878 # verify the required parameter 'account_id' is set 2879 if ('account_id' not in params) or (params['account_id'] is None): 2880 raise ValueError("Missing the required parameter `account_id` when calling `create_responsive_html_preview`") 2881 # verify the required parameter 'envelope_id' is set 2882 if ('envelope_id' not in params) or (params['envelope_id'] is None): 2883 raise ValueError("Missing the required parameter `envelope_id` when calling `create_responsive_html_preview`") 2884 2885 2886 collection_formats = {} 2887 2888 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/responsive_html_preview'.replace('{format}', 'json') 2889 path_params = {} 2890 if 'account_id' in params: 2891 path_params['accountId'] = params['account_id'] 2892 if 'envelope_id' in params: 2893 path_params['envelopeId'] = params['envelope_id'] 2894 2895 query_params = {} 2896 2897 header_params = {} 2898 2899 form_params = [] 2900 local_var_files = {} 2901 2902 body_params = None 2903 if 'document_html_definition' in params: 2904 body_params = params['document_html_definition'] 2905 # HTTP header `Accept` 2906 header_params['Accept'] = self.api_client.\ 2907 select_header_accept(['application/json']) 2908 2909 # Authentication setting 2910 auth_settings = [] 2911 2912 return self.api_client.call_api(resource_path, 'POST', 2913 path_params, 2914 query_params, 2915 header_params, 2916 body=body_params, 2917 post_params=form_params, 2918 files=local_var_files, 2919 response_type='DocumentHtmlDefinitions', 2920 auth_settings=auth_settings, 2921 callback=params.get('callback'), 2922 _return_http_data_only=params.get('_return_http_data_only'), 2923 _preload_content=params.get('_preload_content', True), 2924 _request_timeout=params.get('_request_timeout'), 2925 collection_formats=collection_formats) 2926 2927 def create_sender_view(self, account_id, envelope_id, **kwargs): 2928 """ 2929 Returns a URL to the sender view UI. 2930 Returns a URL that allows you to embed the sender view of the DocuSign UI in your applications. This is a one-time use login token that allows the user to be placed into the DocuSign sending view. Upon sending completion, the user is returned to the return URL provided by the API application. Important: iFrames should not be used for embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends using a WebView. 2931 This method makes a synchronous HTTP request by default. To make an 2932 asynchronous HTTP request, please define a `callback` function 2933 to be invoked when receiving the response. 2934 >>> def callback_function(response): 2935 >>> pprint(response) 2936 >>> 2937 >>> thread = api.create_sender_view(account_id, envelope_id, callback=callback_function) 2938 2939 :param callback function: The callback function 2940 for asynchronous request. (optional) 2941 :param str account_id: The external account number (int) or account ID Guid. (required) 2942 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2943 :param EnvelopeViewRequest envelope_view_request: 2944 :return: ViewUrl 2945 If the method is called asynchronously, 2946 returns the request thread. 2947 """ 2948 kwargs['_return_http_data_only'] = True 2949 if kwargs.get('callback'): 2950 return self.create_sender_view_with_http_info(account_id, envelope_id, **kwargs) 2951 else: 2952 (data) = self.create_sender_view_with_http_info(account_id, envelope_id, **kwargs) 2953 return data 2954 2955 def create_sender_view_with_http_info(self, account_id, envelope_id, **kwargs): 2956 """ 2957 Returns a URL to the sender view UI. 2958 Returns a URL that allows you to embed the sender view of the DocuSign UI in your applications. This is a one-time use login token that allows the user to be placed into the DocuSign sending view. Upon sending completion, the user is returned to the return URL provided by the API application. Important: iFrames should not be used for embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends using a WebView. 2959 This method makes a synchronous HTTP request by default. To make an 2960 asynchronous HTTP request, please define a `callback` function 2961 to be invoked when receiving the response. 2962 >>> def callback_function(response): 2963 >>> pprint(response) 2964 >>> 2965 >>> thread = api.create_sender_view_with_http_info(account_id, envelope_id, callback=callback_function) 2966 2967 :param callback function: The callback function 2968 for asynchronous request. (optional) 2969 :param str account_id: The external account number (int) or account ID Guid. (required) 2970 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2971 :param EnvelopeViewRequest envelope_view_request: 2972 :return: ViewUrl 2973 If the method is called asynchronously, 2974 returns the request thread. 2975 """ 2976 2977 all_params = ['account_id', 'envelope_id', 'envelope_view_request'] 2978 all_params.append('callback') 2979 all_params.append('_return_http_data_only') 2980 all_params.append('_preload_content') 2981 all_params.append('_request_timeout') 2982 2983 params = locals() 2984 for key, val in iteritems(params['kwargs']): 2985 if key not in all_params: 2986 raise TypeError( 2987 "Got an unexpected keyword argument '%s'" 2988 " to method create_sender_view" % key 2989 ) 2990 params[key] = val 2991 del params['kwargs'] 2992 # verify the required parameter 'account_id' is set 2993 if ('account_id' not in params) or (params['account_id'] is None): 2994 raise ValueError("Missing the required parameter `account_id` when calling `create_sender_view`") 2995 # verify the required parameter 'envelope_id' is set 2996 if ('envelope_id' not in params) or (params['envelope_id'] is None): 2997 raise ValueError("Missing the required parameter `envelope_id` when calling `create_sender_view`") 2998 2999 3000 collection_formats = {} 3001 3002 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/sender'.replace('{format}', 'json') 3003 path_params = {} 3004 if 'account_id' in params: 3005 path_params['accountId'] = params['account_id'] 3006 if 'envelope_id' in params: 3007 path_params['envelopeId'] = params['envelope_id'] 3008 3009 query_params = {} 3010 3011 header_params = {} 3012 3013 form_params = [] 3014 local_var_files = {} 3015 3016 body_params = None 3017 if 'envelope_view_request' in params: 3018 body_params = params['envelope_view_request'] 3019 # HTTP header `Accept` 3020 header_params['Accept'] = self.api_client.\ 3021 select_header_accept(['application/json']) 3022 3023 # Authentication setting 3024 auth_settings = [] 3025 3026 return self.api_client.call_api(resource_path, 'POST', 3027 path_params, 3028 query_params, 3029 header_params, 3030 body=body_params, 3031 post_params=form_params, 3032 files=local_var_files, 3033 response_type='ViewUrl', 3034 auth_settings=auth_settings, 3035 callback=params.get('callback'), 3036 _return_http_data_only=params.get('_return_http_data_only'), 3037 _preload_content=params.get('_preload_content', True), 3038 _request_timeout=params.get('_request_timeout'), 3039 collection_formats=collection_formats) 3040 3041 def create_tabs(self, account_id, envelope_id, recipient_id, **kwargs): 3042 """ 3043 Adds tabs for a recipient. 3044 Adds one or more tabs for a recipient. 3045 This method makes a synchronous HTTP request by default. To make an 3046 asynchronous HTTP request, please define a `callback` function 3047 to be invoked when receiving the response. 3048 >>> def callback_function(response): 3049 >>> pprint(response) 3050 >>> 3051 >>> thread = api.create_tabs(account_id, envelope_id, recipient_id, callback=callback_function) 3052 3053 :param callback function: The callback function 3054 for asynchronous request. (optional) 3055 :param str account_id: The external account number (int) or account ID Guid. (required) 3056 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3057 :param str recipient_id: The ID of the recipient being accessed. (required) 3058 :param Tabs tabs: 3059 :return: Tabs 3060 If the method is called asynchronously, 3061 returns the request thread. 3062 """ 3063 kwargs['_return_http_data_only'] = True 3064 if kwargs.get('callback'): 3065 return self.create_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 3066 else: 3067 (data) = self.create_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 3068 return data 3069 3070 def create_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 3071 """ 3072 Adds tabs for a recipient. 3073 Adds one or more tabs for a recipient. 3074 This method makes a synchronous HTTP request by default. To make an 3075 asynchronous HTTP request, please define a `callback` function 3076 to be invoked when receiving the response. 3077 >>> def callback_function(response): 3078 >>> pprint(response) 3079 >>> 3080 >>> thread = api.create_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 3081 3082 :param callback function: The callback function 3083 for asynchronous request. (optional) 3084 :param str account_id: The external account number (int) or account ID Guid. (required) 3085 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3086 :param str recipient_id: The ID of the recipient being accessed. (required) 3087 :param Tabs tabs: 3088 :return: Tabs 3089 If the method is called asynchronously, 3090 returns the request thread. 3091 """ 3092 3093 all_params = ['account_id', 'envelope_id', 'recipient_id', 'tabs'] 3094 all_params.append('callback') 3095 all_params.append('_return_http_data_only') 3096 all_params.append('_preload_content') 3097 all_params.append('_request_timeout') 3098 3099 params = locals() 3100 for key, val in iteritems(params['kwargs']): 3101 if key not in all_params: 3102 raise TypeError( 3103 "Got an unexpected keyword argument '%s'" 3104 " to method create_tabs" % key 3105 ) 3106 params[key] = val 3107 del params['kwargs'] 3108 # verify the required parameter 'account_id' is set 3109 if ('account_id' not in params) or (params['account_id'] is None): 3110 raise ValueError("Missing the required parameter `account_id` when calling `create_tabs`") 3111 # verify the required parameter 'envelope_id' is set 3112 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3113 raise ValueError("Missing the required parameter `envelope_id` when calling `create_tabs`") 3114 # verify the required parameter 'recipient_id' is set 3115 if ('recipient_id' not in params) or (params['recipient_id'] is None): 3116 raise ValueError("Missing the required parameter `recipient_id` when calling `create_tabs`") 3117 3118 3119 collection_formats = {} 3120 3121 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/tabs'.replace('{format}', 'json') 3122 path_params = {} 3123 if 'account_id' in params: 3124 path_params['accountId'] = params['account_id'] 3125 if 'envelope_id' in params: 3126 path_params['envelopeId'] = params['envelope_id'] 3127 if 'recipient_id' in params: 3128 path_params['recipientId'] = params['recipient_id'] 3129 3130 query_params = {} 3131 3132 header_params = {} 3133 3134 form_params = [] 3135 local_var_files = {} 3136 3137 body_params = None 3138 if 'tabs' in params: 3139 body_params = params['tabs'] 3140 # HTTP header `Accept` 3141 header_params['Accept'] = self.api_client.\ 3142 select_header_accept(['application/json']) 3143 3144 # Authentication setting 3145 auth_settings = [] 3146 3147 return self.api_client.call_api(resource_path, 'POST', 3148 path_params, 3149 query_params, 3150 header_params, 3151 body=body_params, 3152 post_params=form_params, 3153 files=local_var_files, 3154 response_type='Tabs', 3155 auth_settings=auth_settings, 3156 callback=params.get('callback'), 3157 _return_http_data_only=params.get('_return_http_data_only'), 3158 _preload_content=params.get('_preload_content', True), 3159 _request_timeout=params.get('_request_timeout'), 3160 collection_formats=collection_formats) 3161 3162 def create_template_workflow_step_definition(self, account_id, template_id, **kwargs): 3163 """ 3164 Creates and adds a new workflow step definition for a template's workflow 3165 This method makes a synchronous HTTP request by default. To make an 3166 asynchronous HTTP request, please define a `callback` function 3167 to be invoked when receiving the response. 3168 >>> def callback_function(response): 3169 >>> pprint(response) 3170 >>> 3171 >>> thread = api.create_template_workflow_step_definition(account_id, template_id, callback=callback_function) 3172 3173 :param callback function: The callback function 3174 for asynchronous request. (optional) 3175 :param str account_id: The external account number (int) or account ID Guid. (required) 3176 :param str template_id: The ID of the template being accessed. (required) 3177 :param WorkflowStep workflow_step: 3178 :return: WorkflowStep 3179 If the method is called asynchronously, 3180 returns the request thread. 3181 """ 3182 kwargs['_return_http_data_only'] = True 3183 if kwargs.get('callback'): 3184 return self.create_template_workflow_step_definition_with_http_info(account_id, template_id, **kwargs) 3185 else: 3186 (data) = self.create_template_workflow_step_definition_with_http_info(account_id, template_id, **kwargs) 3187 return data 3188 3189 def create_template_workflow_step_definition_with_http_info(self, account_id, template_id, **kwargs): 3190 """ 3191 Creates and adds a new workflow step definition for a template's workflow 3192 This method makes a synchronous HTTP request by default. To make an 3193 asynchronous HTTP request, please define a `callback` function 3194 to be invoked when receiving the response. 3195 >>> def callback_function(response): 3196 >>> pprint(response) 3197 >>> 3198 >>> thread = api.create_template_workflow_step_definition_with_http_info(account_id, template_id, callback=callback_function) 3199 3200 :param callback function: The callback function 3201 for asynchronous request. (optional) 3202 :param str account_id: The external account number (int) or account ID Guid. (required) 3203 :param str template_id: The ID of the template being accessed. (required) 3204 :param WorkflowStep workflow_step: 3205 :return: WorkflowStep 3206 If the method is called asynchronously, 3207 returns the request thread. 3208 """ 3209 3210 all_params = ['account_id', 'template_id', 'workflow_step'] 3211 all_params.append('callback') 3212 all_params.append('_return_http_data_only') 3213 all_params.append('_preload_content') 3214 all_params.append('_request_timeout') 3215 3216 params = locals() 3217 for key, val in iteritems(params['kwargs']): 3218 if key not in all_params: 3219 raise TypeError( 3220 "Got an unexpected keyword argument '%s'" 3221 " to method create_template_workflow_step_definition" % key 3222 ) 3223 params[key] = val 3224 del params['kwargs'] 3225 # verify the required parameter 'account_id' is set 3226 if ('account_id' not in params) or (params['account_id'] is None): 3227 raise ValueError("Missing the required parameter `account_id` when calling `create_template_workflow_step_definition`") 3228 # verify the required parameter 'template_id' is set 3229 if ('template_id' not in params) or (params['template_id'] is None): 3230 raise ValueError("Missing the required parameter `template_id` when calling `create_template_workflow_step_definition`") 3231 3232 3233 collection_formats = {} 3234 3235 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps'.replace('{format}', 'json') 3236 path_params = {} 3237 if 'account_id' in params: 3238 path_params['accountId'] = params['account_id'] 3239 if 'template_id' in params: 3240 path_params['templateId'] = params['template_id'] 3241 3242 query_params = {} 3243 3244 header_params = {} 3245 3246 form_params = [] 3247 local_var_files = {} 3248 3249 body_params = None 3250 if 'workflow_step' in params: 3251 body_params = params['workflow_step'] 3252 # HTTP header `Accept` 3253 header_params['Accept'] = self.api_client.\ 3254 select_header_accept(['application/json']) 3255 3256 # Authentication setting 3257 auth_settings = [] 3258 3259 return self.api_client.call_api(resource_path, 'POST', 3260 path_params, 3261 query_params, 3262 header_params, 3263 body=body_params, 3264 post_params=form_params, 3265 files=local_var_files, 3266 response_type='WorkflowStep', 3267 auth_settings=auth_settings, 3268 callback=params.get('callback'), 3269 _return_http_data_only=params.get('_return_http_data_only'), 3270 _preload_content=params.get('_preload_content', True), 3271 _request_timeout=params.get('_request_timeout'), 3272 collection_formats=collection_formats) 3273 3274 def delete_attachments(self, account_id, envelope_id, **kwargs): 3275 """ 3276 Delete one or more attachments from a DRAFT envelope. 3277 Deletes one or more attachments from a draft envelope. 3278 This method makes a synchronous HTTP request by default. To make an 3279 asynchronous HTTP request, please define a `callback` function 3280 to be invoked when receiving the response. 3281 >>> def callback_function(response): 3282 >>> pprint(response) 3283 >>> 3284 >>> thread = api.delete_attachments(account_id, envelope_id, callback=callback_function) 3285 3286 :param callback function: The callback function 3287 for asynchronous request. (optional) 3288 :param str account_id: The external account number (int) or account ID Guid. (required) 3289 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3290 :param EnvelopeAttachmentsRequest envelope_attachments_request: 3291 :return: EnvelopeAttachmentsResult 3292 If the method is called asynchronously, 3293 returns the request thread. 3294 """ 3295 kwargs['_return_http_data_only'] = True 3296 if kwargs.get('callback'): 3297 return self.delete_attachments_with_http_info(account_id, envelope_id, **kwargs) 3298 else: 3299 (data) = self.delete_attachments_with_http_info(account_id, envelope_id, **kwargs) 3300 return data 3301 3302 def delete_attachments_with_http_info(self, account_id, envelope_id, **kwargs): 3303 """ 3304 Delete one or more attachments from a DRAFT envelope. 3305 Deletes one or more attachments from a draft envelope. 3306 This method makes a synchronous HTTP request by default. To make an 3307 asynchronous HTTP request, please define a `callback` function 3308 to be invoked when receiving the response. 3309 >>> def callback_function(response): 3310 >>> pprint(response) 3311 >>> 3312 >>> thread = api.delete_attachments_with_http_info(account_id, envelope_id, callback=callback_function) 3313 3314 :param callback function: The callback function 3315 for asynchronous request. (optional) 3316 :param str account_id: The external account number (int) or account ID Guid. (required) 3317 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3318 :param EnvelopeAttachmentsRequest envelope_attachments_request: 3319 :return: EnvelopeAttachmentsResult 3320 If the method is called asynchronously, 3321 returns the request thread. 3322 """ 3323 3324 all_params = ['account_id', 'envelope_id', 'envelope_attachments_request'] 3325 all_params.append('callback') 3326 all_params.append('_return_http_data_only') 3327 all_params.append('_preload_content') 3328 all_params.append('_request_timeout') 3329 3330 params = locals() 3331 for key, val in iteritems(params['kwargs']): 3332 if key not in all_params: 3333 raise TypeError( 3334 "Got an unexpected keyword argument '%s'" 3335 " to method delete_attachments" % key 3336 ) 3337 params[key] = val 3338 del params['kwargs'] 3339 # verify the required parameter 'account_id' is set 3340 if ('account_id' not in params) or (params['account_id'] is None): 3341 raise ValueError("Missing the required parameter `account_id` when calling `delete_attachments`") 3342 # verify the required parameter 'envelope_id' is set 3343 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3344 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_attachments`") 3345 3346 3347 collection_formats = {} 3348 3349 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments'.replace('{format}', 'json') 3350 path_params = {} 3351 if 'account_id' in params: 3352 path_params['accountId'] = params['account_id'] 3353 if 'envelope_id' in params: 3354 path_params['envelopeId'] = params['envelope_id'] 3355 3356 query_params = {} 3357 3358 header_params = {} 3359 3360 form_params = [] 3361 local_var_files = {} 3362 3363 body_params = None 3364 if 'envelope_attachments_request' in params: 3365 body_params = params['envelope_attachments_request'] 3366 # HTTP header `Accept` 3367 header_params['Accept'] = self.api_client.\ 3368 select_header_accept(['application/json']) 3369 3370 # Authentication setting 3371 auth_settings = [] 3372 3373 return self.api_client.call_api(resource_path, 'DELETE', 3374 path_params, 3375 query_params, 3376 header_params, 3377 body=body_params, 3378 post_params=form_params, 3379 files=local_var_files, 3380 response_type='EnvelopeAttachmentsResult', 3381 auth_settings=auth_settings, 3382 callback=params.get('callback'), 3383 _return_http_data_only=params.get('_return_http_data_only'), 3384 _preload_content=params.get('_preload_content', True), 3385 _request_timeout=params.get('_request_timeout'), 3386 collection_formats=collection_formats) 3387 3388 def delete_chunked_upload(self, account_id, chunked_upload_id, **kwargs): 3389 """ 3390 Delete an existing ChunkedUpload. 3391 Deletes a chunked upload that has been committed but not yet consumed. This method cannot be used to delete the following types of chunked uploads, which the system deletes automatically: - Chunked uploads that have been consumed by use in another API call. - Expired chunked uploads. **Note:** If you are aware of a chunked upload that can be discarded, the best practice is to explicitly delete it. If you wait for the system to automatically delete it after it expires, the chunked upload will continue to count against your quota. 3392 This method makes a synchronous HTTP request by default. To make an 3393 asynchronous HTTP request, please define a `callback` function 3394 to be invoked when receiving the response. 3395 >>> def callback_function(response): 3396 >>> pprint(response) 3397 >>> 3398 >>> thread = api.delete_chunked_upload(account_id, chunked_upload_id, callback=callback_function) 3399 3400 :param callback function: The callback function 3401 for asynchronous request. (optional) 3402 :param str account_id: The external account number (int) or account ID Guid. (required) 3403 :param str chunked_upload_id: (required) 3404 :return: ChunkedUploadResponse 3405 If the method is called asynchronously, 3406 returns the request thread. 3407 """ 3408 kwargs['_return_http_data_only'] = True 3409 if kwargs.get('callback'): 3410 return self.delete_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 3411 else: 3412 (data) = self.delete_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 3413 return data 3414 3415 def delete_chunked_upload_with_http_info(self, account_id, chunked_upload_id, **kwargs): 3416 """ 3417 Delete an existing ChunkedUpload. 3418 Deletes a chunked upload that has been committed but not yet consumed. This method cannot be used to delete the following types of chunked uploads, which the system deletes automatically: - Chunked uploads that have been consumed by use in another API call. - Expired chunked uploads. **Note:** If you are aware of a chunked upload that can be discarded, the best practice is to explicitly delete it. If you wait for the system to automatically delete it after it expires, the chunked upload will continue to count against your quota. 3419 This method makes a synchronous HTTP request by default. To make an 3420 asynchronous HTTP request, please define a `callback` function 3421 to be invoked when receiving the response. 3422 >>> def callback_function(response): 3423 >>> pprint(response) 3424 >>> 3425 >>> thread = api.delete_chunked_upload_with_http_info(account_id, chunked_upload_id, callback=callback_function) 3426 3427 :param callback function: The callback function 3428 for asynchronous request. (optional) 3429 :param str account_id: The external account number (int) or account ID Guid. (required) 3430 :param str chunked_upload_id: (required) 3431 :return: ChunkedUploadResponse 3432 If the method is called asynchronously, 3433 returns the request thread. 3434 """ 3435 3436 all_params = ['account_id', 'chunked_upload_id'] 3437 all_params.append('callback') 3438 all_params.append('_return_http_data_only') 3439 all_params.append('_preload_content') 3440 all_params.append('_request_timeout') 3441 3442 params = locals() 3443 for key, val in iteritems(params['kwargs']): 3444 if key not in all_params: 3445 raise TypeError( 3446 "Got an unexpected keyword argument '%s'" 3447 " to method delete_chunked_upload" % key 3448 ) 3449 params[key] = val 3450 del params['kwargs'] 3451 # verify the required parameter 'account_id' is set 3452 if ('account_id' not in params) or (params['account_id'] is None): 3453 raise ValueError("Missing the required parameter `account_id` when calling `delete_chunked_upload`") 3454 # verify the required parameter 'chunked_upload_id' is set 3455 if ('chunked_upload_id' not in params) or (params['chunked_upload_id'] is None): 3456 raise ValueError("Missing the required parameter `chunked_upload_id` when calling `delete_chunked_upload`") 3457 3458 3459 collection_formats = {} 3460 3461 resource_path = '/v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}'.replace('{format}', 'json') 3462 path_params = {} 3463 if 'account_id' in params: 3464 path_params['accountId'] = params['account_id'] 3465 if 'chunked_upload_id' in params: 3466 path_params['chunkedUploadId'] = params['chunked_upload_id'] 3467 3468 query_params = {} 3469 3470 header_params = {} 3471 3472 form_params = [] 3473 local_var_files = {} 3474 3475 body_params = None 3476 # HTTP header `Accept` 3477 header_params['Accept'] = self.api_client.\ 3478 select_header_accept(['application/json']) 3479 3480 # Authentication setting 3481 auth_settings = [] 3482 3483 return self.api_client.call_api(resource_path, 'DELETE', 3484 path_params, 3485 query_params, 3486 header_params, 3487 body=body_params, 3488 post_params=form_params, 3489 files=local_var_files, 3490 response_type='ChunkedUploadResponse', 3491 auth_settings=auth_settings, 3492 callback=params.get('callback'), 3493 _return_http_data_only=params.get('_return_http_data_only'), 3494 _preload_content=params.get('_preload_content', True), 3495 _request_timeout=params.get('_request_timeout'), 3496 collection_formats=collection_formats) 3497 3498 def delete_custom_fields(self, account_id, envelope_id, **kwargs): 3499 """ 3500 Deletes envelope custom fields for draft and in-process envelopes. 3501 Deletes envelope custom fields for draft and in-process envelopes. 3502 This method makes a synchronous HTTP request by default. To make an 3503 asynchronous HTTP request, please define a `callback` function 3504 to be invoked when receiving the response. 3505 >>> def callback_function(response): 3506 >>> pprint(response) 3507 >>> 3508 >>> thread = api.delete_custom_fields(account_id, envelope_id, callback=callback_function) 3509 3510 :param callback function: The callback function 3511 for asynchronous request. (optional) 3512 :param str account_id: The external account number (int) or account ID Guid. (required) 3513 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3514 :param CustomFields custom_fields: 3515 :return: CustomFields 3516 If the method is called asynchronously, 3517 returns the request thread. 3518 """ 3519 kwargs['_return_http_data_only'] = True 3520 if kwargs.get('callback'): 3521 return self.delete_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 3522 else: 3523 (data) = self.delete_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 3524 return data 3525 3526 def delete_custom_fields_with_http_info(self, account_id, envelope_id, **kwargs): 3527 """ 3528 Deletes envelope custom fields for draft and in-process envelopes. 3529 Deletes envelope custom fields for draft and in-process envelopes. 3530 This method makes a synchronous HTTP request by default. To make an 3531 asynchronous HTTP request, please define a `callback` function 3532 to be invoked when receiving the response. 3533 >>> def callback_function(response): 3534 >>> pprint(response) 3535 >>> 3536 >>> thread = api.delete_custom_fields_with_http_info(account_id, envelope_id, callback=callback_function) 3537 3538 :param callback function: The callback function 3539 for asynchronous request. (optional) 3540 :param str account_id: The external account number (int) or account ID Guid. (required) 3541 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3542 :param CustomFields custom_fields: 3543 :return: CustomFields 3544 If the method is called asynchronously, 3545 returns the request thread. 3546 """ 3547 3548 all_params = ['account_id', 'envelope_id', 'custom_fields'] 3549 all_params.append('callback') 3550 all_params.append('_return_http_data_only') 3551 all_params.append('_preload_content') 3552 all_params.append('_request_timeout') 3553 3554 params = locals() 3555 for key, val in iteritems(params['kwargs']): 3556 if key not in all_params: 3557 raise TypeError( 3558 "Got an unexpected keyword argument '%s'" 3559 " to method delete_custom_fields" % key 3560 ) 3561 params[key] = val 3562 del params['kwargs'] 3563 # verify the required parameter 'account_id' is set 3564 if ('account_id' not in params) or (params['account_id'] is None): 3565 raise ValueError("Missing the required parameter `account_id` when calling `delete_custom_fields`") 3566 # verify the required parameter 'envelope_id' is set 3567 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3568 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_custom_fields`") 3569 3570 3571 collection_formats = {} 3572 3573 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/custom_fields'.replace('{format}', 'json') 3574 path_params = {} 3575 if 'account_id' in params: 3576 path_params['accountId'] = params['account_id'] 3577 if 'envelope_id' in params: 3578 path_params['envelopeId'] = params['envelope_id'] 3579 3580 query_params = {} 3581 3582 header_params = {} 3583 3584 form_params = [] 3585 local_var_files = {} 3586 3587 body_params = None 3588 if 'custom_fields' in params: 3589 body_params = params['custom_fields'] 3590 # HTTP header `Accept` 3591 header_params['Accept'] = self.api_client.\ 3592 select_header_accept(['application/json']) 3593 3594 # Authentication setting 3595 auth_settings = [] 3596 3597 return self.api_client.call_api(resource_path, 'DELETE', 3598 path_params, 3599 query_params, 3600 header_params, 3601 body=body_params, 3602 post_params=form_params, 3603 files=local_var_files, 3604 response_type='CustomFields', 3605 auth_settings=auth_settings, 3606 callback=params.get('callback'), 3607 _return_http_data_only=params.get('_return_http_data_only'), 3608 _preload_content=params.get('_preload_content', True), 3609 _request_timeout=params.get('_request_timeout'), 3610 collection_formats=collection_formats) 3611 3612 def delete_document_fields(self, account_id, document_id, envelope_id, **kwargs): 3613 """ 3614 Deletes custom document fields from an existing envelope document. 3615 Deletes custom document fields from an existing envelope document. 3616 This method makes a synchronous HTTP request by default. To make an 3617 asynchronous HTTP request, please define a `callback` function 3618 to be invoked when receiving the response. 3619 >>> def callback_function(response): 3620 >>> pprint(response) 3621 >>> 3622 >>> thread = api.delete_document_fields(account_id, document_id, envelope_id, callback=callback_function) 3623 3624 :param callback function: The callback function 3625 for asynchronous request. (optional) 3626 :param str account_id: The external account number (int) or account ID Guid. (required) 3627 :param str document_id: The ID of the document being accessed. (required) 3628 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3629 :param DocumentFieldsInformation document_fields_information: 3630 :return: DocumentFieldsInformation 3631 If the method is called asynchronously, 3632 returns the request thread. 3633 """ 3634 kwargs['_return_http_data_only'] = True 3635 if kwargs.get('callback'): 3636 return self.delete_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 3637 else: 3638 (data) = self.delete_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 3639 return data 3640 3641 def delete_document_fields_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 3642 """ 3643 Deletes custom document fields from an existing envelope document. 3644 Deletes custom document fields from an existing envelope document. 3645 This method makes a synchronous HTTP request by default. To make an 3646 asynchronous HTTP request, please define a `callback` function 3647 to be invoked when receiving the response. 3648 >>> def callback_function(response): 3649 >>> pprint(response) 3650 >>> 3651 >>> thread = api.delete_document_fields_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 3652 3653 :param callback function: The callback function 3654 for asynchronous request. (optional) 3655 :param str account_id: The external account number (int) or account ID Guid. (required) 3656 :param str document_id: The ID of the document being accessed. (required) 3657 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3658 :param DocumentFieldsInformation document_fields_information: 3659 :return: DocumentFieldsInformation 3660 If the method is called asynchronously, 3661 returns the request thread. 3662 """ 3663 3664 all_params = ['account_id', 'document_id', 'envelope_id', 'document_fields_information'] 3665 all_params.append('callback') 3666 all_params.append('_return_http_data_only') 3667 all_params.append('_preload_content') 3668 all_params.append('_request_timeout') 3669 3670 params = locals() 3671 for key, val in iteritems(params['kwargs']): 3672 if key not in all_params: 3673 raise TypeError( 3674 "Got an unexpected keyword argument '%s'" 3675 " to method delete_document_fields" % key 3676 ) 3677 params[key] = val 3678 del params['kwargs'] 3679 # verify the required parameter 'account_id' is set 3680 if ('account_id' not in params) or (params['account_id'] is None): 3681 raise ValueError("Missing the required parameter `account_id` when calling `delete_document_fields`") 3682 # verify the required parameter 'document_id' is set 3683 if ('document_id' not in params) or (params['document_id'] is None): 3684 raise ValueError("Missing the required parameter `document_id` when calling `delete_document_fields`") 3685 # verify the required parameter 'envelope_id' is set 3686 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3687 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_document_fields`") 3688 3689 3690 collection_formats = {} 3691 3692 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/fields'.replace('{format}', 'json') 3693 path_params = {} 3694 if 'account_id' in params: 3695 path_params['accountId'] = params['account_id'] 3696 if 'document_id' in params: 3697 path_params['documentId'] = params['document_id'] 3698 if 'envelope_id' in params: 3699 path_params['envelopeId'] = params['envelope_id'] 3700 3701 query_params = {} 3702 3703 header_params = {} 3704 3705 form_params = [] 3706 local_var_files = {} 3707 3708 body_params = None 3709 if 'document_fields_information' in params: 3710 body_params = params['document_fields_information'] 3711 # HTTP header `Accept` 3712 header_params['Accept'] = self.api_client.\ 3713 select_header_accept(['application/json']) 3714 3715 # Authentication setting 3716 auth_settings = [] 3717 3718 return self.api_client.call_api(resource_path, 'DELETE', 3719 path_params, 3720 query_params, 3721 header_params, 3722 body=body_params, 3723 post_params=form_params, 3724 files=local_var_files, 3725 response_type='DocumentFieldsInformation', 3726 auth_settings=auth_settings, 3727 callback=params.get('callback'), 3728 _return_http_data_only=params.get('_return_http_data_only'), 3729 _preload_content=params.get('_preload_content', True), 3730 _request_timeout=params.get('_request_timeout'), 3731 collection_formats=collection_formats) 3732 3733 def delete_document_page(self, account_id, document_id, envelope_id, page_number, **kwargs): 3734 """ 3735 Deletes a page from a document in an envelope. 3736 Deletes a page from a document in an envelope based on the page number. 3737 This method makes a synchronous HTTP request by default. To make an 3738 asynchronous HTTP request, please define a `callback` function 3739 to be invoked when receiving the response. 3740 >>> def callback_function(response): 3741 >>> pprint(response) 3742 >>> 3743 >>> thread = api.delete_document_page(account_id, document_id, envelope_id, page_number, callback=callback_function) 3744 3745 :param callback function: The callback function 3746 for asynchronous request. (optional) 3747 :param str account_id: The external account number (int) or account ID Guid. (required) 3748 :param str document_id: The ID of the document being accessed. (required) 3749 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3750 :param str page_number: The page number being accessed. (required) 3751 :return: None 3752 If the method is called asynchronously, 3753 returns the request thread. 3754 """ 3755 kwargs['_return_http_data_only'] = True 3756 if kwargs.get('callback'): 3757 return self.delete_document_page_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 3758 else: 3759 (data) = self.delete_document_page_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 3760 return data 3761 3762 def delete_document_page_with_http_info(self, account_id, document_id, envelope_id, page_number, **kwargs): 3763 """ 3764 Deletes a page from a document in an envelope. 3765 Deletes a page from a document in an envelope based on the page number. 3766 This method makes a synchronous HTTP request by default. To make an 3767 asynchronous HTTP request, please define a `callback` function 3768 to be invoked when receiving the response. 3769 >>> def callback_function(response): 3770 >>> pprint(response) 3771 >>> 3772 >>> thread = api.delete_document_page_with_http_info(account_id, document_id, envelope_id, page_number, callback=callback_function) 3773 3774 :param callback function: The callback function 3775 for asynchronous request. (optional) 3776 :param str account_id: The external account number (int) or account ID Guid. (required) 3777 :param str document_id: The ID of the document being accessed. (required) 3778 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3779 :param str page_number: The page number being accessed. (required) 3780 :return: None 3781 If the method is called asynchronously, 3782 returns the request thread. 3783 """ 3784 3785 all_params = ['account_id', 'document_id', 'envelope_id', 'page_number'] 3786 all_params.append('callback') 3787 all_params.append('_return_http_data_only') 3788 all_params.append('_preload_content') 3789 all_params.append('_request_timeout') 3790 3791 params = locals() 3792 for key, val in iteritems(params['kwargs']): 3793 if key not in all_params: 3794 raise TypeError( 3795 "Got an unexpected keyword argument '%s'" 3796 " to method delete_document_page" % key 3797 ) 3798 params[key] = val 3799 del params['kwargs'] 3800 # verify the required parameter 'account_id' is set 3801 if ('account_id' not in params) or (params['account_id'] is None): 3802 raise ValueError("Missing the required parameter `account_id` when calling `delete_document_page`") 3803 # verify the required parameter 'document_id' is set 3804 if ('document_id' not in params) or (params['document_id'] is None): 3805 raise ValueError("Missing the required parameter `document_id` when calling `delete_document_page`") 3806 # verify the required parameter 'envelope_id' is set 3807 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3808 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_document_page`") 3809 # verify the required parameter 'page_number' is set 3810 if ('page_number' not in params) or (params['page_number'] is None): 3811 raise ValueError("Missing the required parameter `page_number` when calling `delete_document_page`") 3812 3813 3814 collection_formats = {} 3815 3816 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/pages/{pageNumber}'.replace('{format}', 'json') 3817 path_params = {} 3818 if 'account_id' in params: 3819 path_params['accountId'] = params['account_id'] 3820 if 'document_id' in params: 3821 path_params['documentId'] = params['document_id'] 3822 if 'envelope_id' in params: 3823 path_params['envelopeId'] = params['envelope_id'] 3824 if 'page_number' in params: 3825 path_params['pageNumber'] = params['page_number'] 3826 3827 query_params = {} 3828 3829 header_params = {} 3830 3831 form_params = [] 3832 local_var_files = {} 3833 3834 body_params = None 3835 # HTTP header `Accept` 3836 header_params['Accept'] = self.api_client.\ 3837 select_header_accept(['application/json']) 3838 3839 # Authentication setting 3840 auth_settings = [] 3841 3842 return self.api_client.call_api(resource_path, 'DELETE', 3843 path_params, 3844 query_params, 3845 header_params, 3846 body=body_params, 3847 post_params=form_params, 3848 files=local_var_files, 3849 response_type=None, 3850 auth_settings=auth_settings, 3851 callback=params.get('callback'), 3852 _return_http_data_only=params.get('_return_http_data_only'), 3853 _preload_content=params.get('_preload_content', True), 3854 _request_timeout=params.get('_request_timeout'), 3855 collection_formats=collection_formats) 3856 3857 def delete_document_tabs(self, account_id, document_id, envelope_id, **kwargs): 3858 """ 3859 Deletes tabs from an envelope document 3860 Deletes tabs from the document specified by `documentId` in the envelope specified by `envelopeId`. 3861 This method makes a synchronous HTTP request by default. To make an 3862 asynchronous HTTP request, please define a `callback` function 3863 to be invoked when receiving the response. 3864 >>> def callback_function(response): 3865 >>> pprint(response) 3866 >>> 3867 >>> thread = api.delete_document_tabs(account_id, document_id, envelope_id, callback=callback_function) 3868 3869 :param callback function: The callback function 3870 for asynchronous request. (optional) 3871 :param str account_id: The external account number (int) or account ID Guid. (required) 3872 :param str document_id: The ID of the document being accessed. (required) 3873 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3874 :param Tabs tabs: 3875 :return: Tabs 3876 If the method is called asynchronously, 3877 returns the request thread. 3878 """ 3879 kwargs['_return_http_data_only'] = True 3880 if kwargs.get('callback'): 3881 return self.delete_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 3882 else: 3883 (data) = self.delete_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 3884 return data 3885 3886 def delete_document_tabs_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 3887 """ 3888 Deletes tabs from an envelope document 3889 Deletes tabs from the document specified by `documentId` in the envelope specified by `envelopeId`. 3890 This method makes a synchronous HTTP request by default. To make an 3891 asynchronous HTTP request, please define a `callback` function 3892 to be invoked when receiving the response. 3893 >>> def callback_function(response): 3894 >>> pprint(response) 3895 >>> 3896 >>> thread = api.delete_document_tabs_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 3897 3898 :param callback function: The callback function 3899 for asynchronous request. (optional) 3900 :param str account_id: The external account number (int) or account ID Guid. (required) 3901 :param str document_id: The ID of the document being accessed. (required) 3902 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3903 :param Tabs tabs: 3904 :return: Tabs 3905 If the method is called asynchronously, 3906 returns the request thread. 3907 """ 3908 3909 all_params = ['account_id', 'document_id', 'envelope_id', 'tabs'] 3910 all_params.append('callback') 3911 all_params.append('_return_http_data_only') 3912 all_params.append('_preload_content') 3913 all_params.append('_request_timeout') 3914 3915 params = locals() 3916 for key, val in iteritems(params['kwargs']): 3917 if key not in all_params: 3918 raise TypeError( 3919 "Got an unexpected keyword argument '%s'" 3920 " to method delete_document_tabs" % key 3921 ) 3922 params[key] = val 3923 del params['kwargs'] 3924 # verify the required parameter 'account_id' is set 3925 if ('account_id' not in params) or (params['account_id'] is None): 3926 raise ValueError("Missing the required parameter `account_id` when calling `delete_document_tabs`") 3927 # verify the required parameter 'document_id' is set 3928 if ('document_id' not in params) or (params['document_id'] is None): 3929 raise ValueError("Missing the required parameter `document_id` when calling `delete_document_tabs`") 3930 # verify the required parameter 'envelope_id' is set 3931 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3932 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_document_tabs`") 3933 3934 3935 collection_formats = {} 3936 3937 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/tabs'.replace('{format}', 'json') 3938 path_params = {} 3939 if 'account_id' in params: 3940 path_params['accountId'] = params['account_id'] 3941 if 'document_id' in params: 3942 path_params['documentId'] = params['document_id'] 3943 if 'envelope_id' in params: 3944 path_params['envelopeId'] = params['envelope_id'] 3945 3946 query_params = {} 3947 3948 header_params = {} 3949 3950 form_params = [] 3951 local_var_files = {} 3952 3953 body_params = None 3954 if 'tabs' in params: 3955 body_params = params['tabs'] 3956 # HTTP header `Accept` 3957 header_params['Accept'] = self.api_client.\ 3958 select_header_accept(['application/json']) 3959 3960 # Authentication setting 3961 auth_settings = [] 3962 3963 return self.api_client.call_api(resource_path, 'DELETE', 3964 path_params, 3965 query_params, 3966 header_params, 3967 body=body_params, 3968 post_params=form_params, 3969 files=local_var_files, 3970 response_type='Tabs', 3971 auth_settings=auth_settings, 3972 callback=params.get('callback'), 3973 _return_http_data_only=params.get('_return_http_data_only'), 3974 _preload_content=params.get('_preload_content', True), 3975 _request_timeout=params.get('_request_timeout'), 3976 collection_formats=collection_formats) 3977 3978 def delete_documents(self, account_id, envelope_id, **kwargs): 3979 """ 3980 Deletes documents from a draft envelope. 3981 Deletes one or more documents from an existing draft envelope. 3982 This method makes a synchronous HTTP request by default. To make an 3983 asynchronous HTTP request, please define a `callback` function 3984 to be invoked when receiving the response. 3985 >>> def callback_function(response): 3986 >>> pprint(response) 3987 >>> 3988 >>> thread = api.delete_documents(account_id, envelope_id, callback=callback_function) 3989 3990 :param callback function: The callback function 3991 for asynchronous request. (optional) 3992 :param str account_id: The external account number (int) or account ID Guid. (required) 3993 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3994 :param EnvelopeDefinition envelope_definition: 3995 :return: EnvelopeDocumentsResult 3996 If the method is called asynchronously, 3997 returns the request thread. 3998 """ 3999 kwargs['_return_http_data_only'] = True 4000 if kwargs.get('callback'): 4001 return self.delete_documents_with_http_info(account_id, envelope_id, **kwargs) 4002 else: 4003 (data) = self.delete_documents_with_http_info(account_id, envelope_id, **kwargs) 4004 return data 4005 4006 def delete_documents_with_http_info(self, account_id, envelope_id, **kwargs): 4007 """ 4008 Deletes documents from a draft envelope. 4009 Deletes one or more documents from an existing draft envelope. 4010 This method makes a synchronous HTTP request by default. To make an 4011 asynchronous HTTP request, please define a `callback` function 4012 to be invoked when receiving the response. 4013 >>> def callback_function(response): 4014 >>> pprint(response) 4015 >>> 4016 >>> thread = api.delete_documents_with_http_info(account_id, envelope_id, callback=callback_function) 4017 4018 :param callback function: The callback function 4019 for asynchronous request. (optional) 4020 :param str account_id: The external account number (int) or account ID Guid. (required) 4021 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4022 :param EnvelopeDefinition envelope_definition: 4023 :return: EnvelopeDocumentsResult 4024 If the method is called asynchronously, 4025 returns the request thread. 4026 """ 4027 4028 all_params = ['account_id', 'envelope_id', 'envelope_definition'] 4029 all_params.append('callback') 4030 all_params.append('_return_http_data_only') 4031 all_params.append('_preload_content') 4032 all_params.append('_request_timeout') 4033 4034 params = locals() 4035 for key, val in iteritems(params['kwargs']): 4036 if key not in all_params: 4037 raise TypeError( 4038 "Got an unexpected keyword argument '%s'" 4039 " to method delete_documents" % key 4040 ) 4041 params[key] = val 4042 del params['kwargs'] 4043 # verify the required parameter 'account_id' is set 4044 if ('account_id' not in params) or (params['account_id'] is None): 4045 raise ValueError("Missing the required parameter `account_id` when calling `delete_documents`") 4046 # verify the required parameter 'envelope_id' is set 4047 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4048 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_documents`") 4049 4050 4051 collection_formats = {} 4052 4053 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents'.replace('{format}', 'json') 4054 path_params = {} 4055 if 'account_id' in params: 4056 path_params['accountId'] = params['account_id'] 4057 if 'envelope_id' in params: 4058 path_params['envelopeId'] = params['envelope_id'] 4059 4060 query_params = {} 4061 4062 header_params = {} 4063 4064 form_params = [] 4065 local_var_files = {} 4066 4067 body_params = None 4068 if 'envelope_definition' in params: 4069 body_params = params['envelope_definition'] 4070 # HTTP header `Accept` 4071 header_params['Accept'] = self.api_client.\ 4072 select_header_accept(['application/json']) 4073 4074 # Authentication setting 4075 auth_settings = [] 4076 4077 return self.api_client.call_api(resource_path, 'DELETE', 4078 path_params, 4079 query_params, 4080 header_params, 4081 body=body_params, 4082 post_params=form_params, 4083 files=local_var_files, 4084 response_type='EnvelopeDocumentsResult', 4085 auth_settings=auth_settings, 4086 callback=params.get('callback'), 4087 _return_http_data_only=params.get('_return_http_data_only'), 4088 _preload_content=params.get('_preload_content', True), 4089 _request_timeout=params.get('_request_timeout'), 4090 collection_formats=collection_formats) 4091 4092 def delete_email_settings(self, account_id, envelope_id, **kwargs): 4093 """ 4094 Deletes the email setting overrides for an envelope. 4095 Deletes all existing email override settings for the envelope. If you want to delete an individual email override setting, use the PUT and set the value to an empty string. Note that deleting email settings will only affect email communications that occur after the deletion and the normal account email settings are used for future email communications. 4096 This method makes a synchronous HTTP request by default. To make an 4097 asynchronous HTTP request, please define a `callback` function 4098 to be invoked when receiving the response. 4099 >>> def callback_function(response): 4100 >>> pprint(response) 4101 >>> 4102 >>> thread = api.delete_email_settings(account_id, envelope_id, callback=callback_function) 4103 4104 :param callback function: The callback function 4105 for asynchronous request. (optional) 4106 :param str account_id: The external account number (int) or account ID Guid. (required) 4107 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4108 :return: EmailSettings 4109 If the method is called asynchronously, 4110 returns the request thread. 4111 """ 4112 kwargs['_return_http_data_only'] = True 4113 if kwargs.get('callback'): 4114 return self.delete_email_settings_with_http_info(account_id, envelope_id, **kwargs) 4115 else: 4116 (data) = self.delete_email_settings_with_http_info(account_id, envelope_id, **kwargs) 4117 return data 4118 4119 def delete_email_settings_with_http_info(self, account_id, envelope_id, **kwargs): 4120 """ 4121 Deletes the email setting overrides for an envelope. 4122 Deletes all existing email override settings for the envelope. If you want to delete an individual email override setting, use the PUT and set the value to an empty string. Note that deleting email settings will only affect email communications that occur after the deletion and the normal account email settings are used for future email communications. 4123 This method makes a synchronous HTTP request by default. To make an 4124 asynchronous HTTP request, please define a `callback` function 4125 to be invoked when receiving the response. 4126 >>> def callback_function(response): 4127 >>> pprint(response) 4128 >>> 4129 >>> thread = api.delete_email_settings_with_http_info(account_id, envelope_id, callback=callback_function) 4130 4131 :param callback function: The callback function 4132 for asynchronous request. (optional) 4133 :param str account_id: The external account number (int) or account ID Guid. (required) 4134 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4135 :return: EmailSettings 4136 If the method is called asynchronously, 4137 returns the request thread. 4138 """ 4139 4140 all_params = ['account_id', 'envelope_id'] 4141 all_params.append('callback') 4142 all_params.append('_return_http_data_only') 4143 all_params.append('_preload_content') 4144 all_params.append('_request_timeout') 4145 4146 params = locals() 4147 for key, val in iteritems(params['kwargs']): 4148 if key not in all_params: 4149 raise TypeError( 4150 "Got an unexpected keyword argument '%s'" 4151 " to method delete_email_settings" % key 4152 ) 4153 params[key] = val 4154 del params['kwargs'] 4155 # verify the required parameter 'account_id' is set 4156 if ('account_id' not in params) or (params['account_id'] is None): 4157 raise ValueError("Missing the required parameter `account_id` when calling `delete_email_settings`") 4158 # verify the required parameter 'envelope_id' is set 4159 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4160 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_email_settings`") 4161 4162 4163 collection_formats = {} 4164 4165 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/email_settings'.replace('{format}', 'json') 4166 path_params = {} 4167 if 'account_id' in params: 4168 path_params['accountId'] = params['account_id'] 4169 if 'envelope_id' in params: 4170 path_params['envelopeId'] = params['envelope_id'] 4171 4172 query_params = {} 4173 4174 header_params = {} 4175 4176 form_params = [] 4177 local_var_files = {} 4178 4179 body_params = None 4180 # HTTP header `Accept` 4181 header_params['Accept'] = self.api_client.\ 4182 select_header_accept(['application/json']) 4183 4184 # Authentication setting 4185 auth_settings = [] 4186 4187 return self.api_client.call_api(resource_path, 'DELETE', 4188 path_params, 4189 query_params, 4190 header_params, 4191 body=body_params, 4192 post_params=form_params, 4193 files=local_var_files, 4194 response_type='EmailSettings', 4195 auth_settings=auth_settings, 4196 callback=params.get('callback'), 4197 _return_http_data_only=params.get('_return_http_data_only'), 4198 _preload_content=params.get('_preload_content', True), 4199 _request_timeout=params.get('_request_timeout'), 4200 collection_formats=collection_formats) 4201 4202 def delete_envelope_correct_view(self, account_id, envelope_id, **kwargs): 4203 """ 4204 Revokes the correction view URL to the Envelope UI 4205 Revokes the correction view URL to the Envelope UI. 4206 This method makes a synchronous HTTP request by default. To make an 4207 asynchronous HTTP request, please define a `callback` function 4208 to be invoked when receiving the response. 4209 >>> def callback_function(response): 4210 >>> pprint(response) 4211 >>> 4212 >>> thread = api.delete_envelope_correct_view(account_id, envelope_id, callback=callback_function) 4213 4214 :param callback function: The callback function 4215 for asynchronous request. (optional) 4216 :param str account_id: The external account number (int) or account ID Guid. (required) 4217 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4218 :param CorrectViewRequest correct_view_request: 4219 :return: None 4220 If the method is called asynchronously, 4221 returns the request thread. 4222 """ 4223 kwargs['_return_http_data_only'] = True 4224 if kwargs.get('callback'): 4225 return self.delete_envelope_correct_view_with_http_info(account_id, envelope_id, **kwargs) 4226 else: 4227 (data) = self.delete_envelope_correct_view_with_http_info(account_id, envelope_id, **kwargs) 4228 return data 4229 4230 def delete_envelope_correct_view_with_http_info(self, account_id, envelope_id, **kwargs): 4231 """ 4232 Revokes the correction view URL to the Envelope UI 4233 Revokes the correction view URL to the Envelope UI. 4234 This method makes a synchronous HTTP request by default. To make an 4235 asynchronous HTTP request, please define a `callback` function 4236 to be invoked when receiving the response. 4237 >>> def callback_function(response): 4238 >>> pprint(response) 4239 >>> 4240 >>> thread = api.delete_envelope_correct_view_with_http_info(account_id, envelope_id, callback=callback_function) 4241 4242 :param callback function: The callback function 4243 for asynchronous request. (optional) 4244 :param str account_id: The external account number (int) or account ID Guid. (required) 4245 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4246 :param CorrectViewRequest correct_view_request: 4247 :return: None 4248 If the method is called asynchronously, 4249 returns the request thread. 4250 """ 4251 4252 all_params = ['account_id', 'envelope_id', 'correct_view_request'] 4253 all_params.append('callback') 4254 all_params.append('_return_http_data_only') 4255 all_params.append('_preload_content') 4256 all_params.append('_request_timeout') 4257 4258 params = locals() 4259 for key, val in iteritems(params['kwargs']): 4260 if key not in all_params: 4261 raise TypeError( 4262 "Got an unexpected keyword argument '%s'" 4263 " to method delete_envelope_correct_view" % key 4264 ) 4265 params[key] = val 4266 del params['kwargs'] 4267 # verify the required parameter 'account_id' is set 4268 if ('account_id' not in params) or (params['account_id'] is None): 4269 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_correct_view`") 4270 # verify the required parameter 'envelope_id' is set 4271 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4272 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_envelope_correct_view`") 4273 4274 4275 collection_formats = {} 4276 4277 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/correct'.replace('{format}', 'json') 4278 path_params = {} 4279 if 'account_id' in params: 4280 path_params['accountId'] = params['account_id'] 4281 if 'envelope_id' in params: 4282 path_params['envelopeId'] = params['envelope_id'] 4283 4284 query_params = {} 4285 4286 header_params = {} 4287 4288 form_params = [] 4289 local_var_files = {} 4290 4291 body_params = None 4292 if 'correct_view_request' in params: 4293 body_params = params['correct_view_request'] 4294 # HTTP header `Accept` 4295 header_params['Accept'] = self.api_client.\ 4296 select_header_accept(['application/json']) 4297 4298 # Authentication setting 4299 auth_settings = [] 4300 4301 return self.api_client.call_api(resource_path, 'DELETE', 4302 path_params, 4303 query_params, 4304 header_params, 4305 body=body_params, 4306 post_params=form_params, 4307 files=local_var_files, 4308 response_type=None, 4309 auth_settings=auth_settings, 4310 callback=params.get('callback'), 4311 _return_http_data_only=params.get('_return_http_data_only'), 4312 _preload_content=params.get('_preload_content', True), 4313 _request_timeout=params.get('_request_timeout'), 4314 collection_formats=collection_formats) 4315 4316 def delete_envelope_delayed_routing_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 4317 """ 4318 Deletes the delayed routing rules for the specified envelope workflow step. 4319 This method makes a synchronous HTTP request by default. To make an 4320 asynchronous HTTP request, please define a `callback` function 4321 to be invoked when receiving the response. 4322 >>> def callback_function(response): 4323 >>> pprint(response) 4324 >>> 4325 >>> thread = api.delete_envelope_delayed_routing_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 4326 4327 :param callback function: The callback function 4328 for asynchronous request. (optional) 4329 :param str account_id: The external account number (int) or account ID Guid. (required) 4330 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4331 :param str workflow_step_id: (required) 4332 :return: None 4333 If the method is called asynchronously, 4334 returns the request thread. 4335 """ 4336 kwargs['_return_http_data_only'] = True 4337 if kwargs.get('callback'): 4338 return self.delete_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 4339 else: 4340 (data) = self.delete_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 4341 return data 4342 4343 def delete_envelope_delayed_routing_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 4344 """ 4345 Deletes the delayed routing rules for the specified envelope workflow step. 4346 This method makes a synchronous HTTP request by default. To make an 4347 asynchronous HTTP request, please define a `callback` function 4348 to be invoked when receiving the response. 4349 >>> def callback_function(response): 4350 >>> pprint(response) 4351 >>> 4352 >>> thread = api.delete_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 4353 4354 :param callback function: The callback function 4355 for asynchronous request. (optional) 4356 :param str account_id: The external account number (int) or account ID Guid. (required) 4357 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4358 :param str workflow_step_id: (required) 4359 :return: None 4360 If the method is called asynchronously, 4361 returns the request thread. 4362 """ 4363 4364 all_params = ['account_id', 'envelope_id', 'workflow_step_id'] 4365 all_params.append('callback') 4366 all_params.append('_return_http_data_only') 4367 all_params.append('_preload_content') 4368 all_params.append('_request_timeout') 4369 4370 params = locals() 4371 for key, val in iteritems(params['kwargs']): 4372 if key not in all_params: 4373 raise TypeError( 4374 "Got an unexpected keyword argument '%s'" 4375 " to method delete_envelope_delayed_routing_definition" % key 4376 ) 4377 params[key] = val 4378 del params['kwargs'] 4379 # verify the required parameter 'account_id' is set 4380 if ('account_id' not in params) or (params['account_id'] is None): 4381 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_delayed_routing_definition`") 4382 # verify the required parameter 'envelope_id' is set 4383 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4384 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_envelope_delayed_routing_definition`") 4385 # verify the required parameter 'workflow_step_id' is set 4386 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 4387 raise ValueError("Missing the required parameter `workflow_step_id` when calling `delete_envelope_delayed_routing_definition`") 4388 4389 4390 collection_formats = {} 4391 4392 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 4393 path_params = {} 4394 if 'account_id' in params: 4395 path_params['accountId'] = params['account_id'] 4396 if 'envelope_id' in params: 4397 path_params['envelopeId'] = params['envelope_id'] 4398 if 'workflow_step_id' in params: 4399 path_params['workflowStepId'] = params['workflow_step_id'] 4400 4401 query_params = {} 4402 4403 header_params = {} 4404 4405 form_params = [] 4406 local_var_files = {} 4407 4408 body_params = None 4409 # HTTP header `Accept` 4410 header_params['Accept'] = self.api_client.\ 4411 select_header_accept(['application/json']) 4412 4413 # Authentication setting 4414 auth_settings = [] 4415 4416 return self.api_client.call_api(resource_path, 'DELETE', 4417 path_params, 4418 query_params, 4419 header_params, 4420 body=body_params, 4421 post_params=form_params, 4422 files=local_var_files, 4423 response_type=None, 4424 auth_settings=auth_settings, 4425 callback=params.get('callback'), 4426 _return_http_data_only=params.get('_return_http_data_only'), 4427 _preload_content=params.get('_preload_content', True), 4428 _request_timeout=params.get('_request_timeout'), 4429 collection_formats=collection_formats) 4430 4431 def delete_envelope_scheduled_sending_definition(self, account_id, envelope_id, **kwargs): 4432 """ 4433 Deletes the scheduled sending rules for the envelope's workflow. 4434 This method makes a synchronous HTTP request by default. To make an 4435 asynchronous HTTP request, please define a `callback` function 4436 to be invoked when receiving the response. 4437 >>> def callback_function(response): 4438 >>> pprint(response) 4439 >>> 4440 >>> thread = api.delete_envelope_scheduled_sending_definition(account_id, envelope_id, callback=callback_function) 4441 4442 :param callback function: The callback function 4443 for asynchronous request. (optional) 4444 :param str account_id: The external account number (int) or account ID Guid. (required) 4445 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4446 :return: None 4447 If the method is called asynchronously, 4448 returns the request thread. 4449 """ 4450 kwargs['_return_http_data_only'] = True 4451 if kwargs.get('callback'): 4452 return self.delete_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 4453 else: 4454 (data) = self.delete_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 4455 return data 4456 4457 def delete_envelope_scheduled_sending_definition_with_http_info(self, account_id, envelope_id, **kwargs): 4458 """ 4459 Deletes the scheduled sending rules for the envelope's workflow. 4460 This method makes a synchronous HTTP request by default. To make an 4461 asynchronous HTTP request, please define a `callback` function 4462 to be invoked when receiving the response. 4463 >>> def callback_function(response): 4464 >>> pprint(response) 4465 >>> 4466 >>> thread = api.delete_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, callback=callback_function) 4467 4468 :param callback function: The callback function 4469 for asynchronous request. (optional) 4470 :param str account_id: The external account number (int) or account ID Guid. (required) 4471 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4472 :return: None 4473 If the method is called asynchronously, 4474 returns the request thread. 4475 """ 4476 4477 all_params = ['account_id', 'envelope_id'] 4478 all_params.append('callback') 4479 all_params.append('_return_http_data_only') 4480 all_params.append('_preload_content') 4481 all_params.append('_request_timeout') 4482 4483 params = locals() 4484 for key, val in iteritems(params['kwargs']): 4485 if key not in all_params: 4486 raise TypeError( 4487 "Got an unexpected keyword argument '%s'" 4488 " to method delete_envelope_scheduled_sending_definition" % key 4489 ) 4490 params[key] = val 4491 del params['kwargs'] 4492 # verify the required parameter 'account_id' is set 4493 if ('account_id' not in params) or (params['account_id'] is None): 4494 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_scheduled_sending_definition`") 4495 # verify the required parameter 'envelope_id' is set 4496 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4497 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_envelope_scheduled_sending_definition`") 4498 4499 4500 collection_formats = {} 4501 4502 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/scheduledSending'.replace('{format}', 'json') 4503 path_params = {} 4504 if 'account_id' in params: 4505 path_params['accountId'] = params['account_id'] 4506 if 'envelope_id' in params: 4507 path_params['envelopeId'] = params['envelope_id'] 4508 4509 query_params = {} 4510 4511 header_params = {} 4512 4513 form_params = [] 4514 local_var_files = {} 4515 4516 body_params = None 4517 # HTTP header `Accept` 4518 header_params['Accept'] = self.api_client.\ 4519 select_header_accept(['application/json']) 4520 4521 # Authentication setting 4522 auth_settings = [] 4523 4524 return self.api_client.call_api(resource_path, 'DELETE', 4525 path_params, 4526 query_params, 4527 header_params, 4528 body=body_params, 4529 post_params=form_params, 4530 files=local_var_files, 4531 response_type=None, 4532 auth_settings=auth_settings, 4533 callback=params.get('callback'), 4534 _return_http_data_only=params.get('_return_http_data_only'), 4535 _preload_content=params.get('_preload_content', True), 4536 _request_timeout=params.get('_request_timeout'), 4537 collection_formats=collection_formats) 4538 4539 def delete_envelope_transfer_rules(self, account_id, envelope_transfer_rule_id, **kwargs): 4540 """ 4541 Delete envelope transfer rules for an account. 4542 This method deletes an envelope transfer rule. **Note:** Only Administrators can delete envelope transfer rules. In addition, to use envelope transfer rules, the **Transfer Custody** feature must be enabled for your account. 4543 This method makes a synchronous HTTP request by default. To make an 4544 asynchronous HTTP request, please define a `callback` function 4545 to be invoked when receiving the response. 4546 >>> def callback_function(response): 4547 >>> pprint(response) 4548 >>> 4549 >>> thread = api.delete_envelope_transfer_rules(account_id, envelope_transfer_rule_id, callback=callback_function) 4550 4551 :param callback function: The callback function 4552 for asynchronous request. (optional) 4553 :param str account_id: The external account number (int) or account ID Guid. (required) 4554 :param str envelope_transfer_rule_id: (required) 4555 :return: None 4556 If the method is called asynchronously, 4557 returns the request thread. 4558 """ 4559 kwargs['_return_http_data_only'] = True 4560 if kwargs.get('callback'): 4561 return self.delete_envelope_transfer_rules_with_http_info(account_id, envelope_transfer_rule_id, **kwargs) 4562 else: 4563 (data) = self.delete_envelope_transfer_rules_with_http_info(account_id, envelope_transfer_rule_id, **kwargs) 4564 return data 4565 4566 def delete_envelope_transfer_rules_with_http_info(self, account_id, envelope_transfer_rule_id, **kwargs): 4567 """ 4568 Delete envelope transfer rules for an account. 4569 This method deletes an envelope transfer rule. **Note:** Only Administrators can delete envelope transfer rules. In addition, to use envelope transfer rules, the **Transfer Custody** feature must be enabled for your account. 4570 This method makes a synchronous HTTP request by default. To make an 4571 asynchronous HTTP request, please define a `callback` function 4572 to be invoked when receiving the response. 4573 >>> def callback_function(response): 4574 >>> pprint(response) 4575 >>> 4576 >>> thread = api.delete_envelope_transfer_rules_with_http_info(account_id, envelope_transfer_rule_id, callback=callback_function) 4577 4578 :param callback function: The callback function 4579 for asynchronous request. (optional) 4580 :param str account_id: The external account number (int) or account ID Guid. (required) 4581 :param str envelope_transfer_rule_id: (required) 4582 :return: None 4583 If the method is called asynchronously, 4584 returns the request thread. 4585 """ 4586 4587 all_params = ['account_id', 'envelope_transfer_rule_id'] 4588 all_params.append('callback') 4589 all_params.append('_return_http_data_only') 4590 all_params.append('_preload_content') 4591 all_params.append('_request_timeout') 4592 4593 params = locals() 4594 for key, val in iteritems(params['kwargs']): 4595 if key not in all_params: 4596 raise TypeError( 4597 "Got an unexpected keyword argument '%s'" 4598 " to method delete_envelope_transfer_rules" % key 4599 ) 4600 params[key] = val 4601 del params['kwargs'] 4602 # verify the required parameter 'account_id' is set 4603 if ('account_id' not in params) or (params['account_id'] is None): 4604 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_transfer_rules`") 4605 # verify the required parameter 'envelope_transfer_rule_id' is set 4606 if ('envelope_transfer_rule_id' not in params) or (params['envelope_transfer_rule_id'] is None): 4607 raise ValueError("Missing the required parameter `envelope_transfer_rule_id` when calling `delete_envelope_transfer_rules`") 4608 4609 4610 collection_formats = {} 4611 4612 resource_path = '/v2.1/accounts/{accountId}/envelopes/transfer_rules/{envelopeTransferRuleId}'.replace('{format}', 'json') 4613 path_params = {} 4614 if 'account_id' in params: 4615 path_params['accountId'] = params['account_id'] 4616 if 'envelope_transfer_rule_id' in params: 4617 path_params['envelopeTransferRuleId'] = params['envelope_transfer_rule_id'] 4618 4619 query_params = {} 4620 4621 header_params = {} 4622 4623 form_params = [] 4624 local_var_files = {} 4625 4626 body_params = None 4627 # HTTP header `Accept` 4628 header_params['Accept'] = self.api_client.\ 4629 select_header_accept(['application/json']) 4630 4631 # Authentication setting 4632 auth_settings = [] 4633 4634 return self.api_client.call_api(resource_path, 'DELETE', 4635 path_params, 4636 query_params, 4637 header_params, 4638 body=body_params, 4639 post_params=form_params, 4640 files=local_var_files, 4641 response_type=None, 4642 auth_settings=auth_settings, 4643 callback=params.get('callback'), 4644 _return_http_data_only=params.get('_return_http_data_only'), 4645 _preload_content=params.get('_preload_content', True), 4646 _request_timeout=params.get('_request_timeout'), 4647 collection_formats=collection_formats) 4648 4649 def delete_envelope_workflow_definition(self, account_id, envelope_id, **kwargs): 4650 """ 4651 Delete the workflow definition for an envelope. 4652 Deletes the specified envelope's workflow definition if it has one. 4653 This method makes a synchronous HTTP request by default. To make an 4654 asynchronous HTTP request, please define a `callback` function 4655 to be invoked when receiving the response. 4656 >>> def callback_function(response): 4657 >>> pprint(response) 4658 >>> 4659 >>> thread = api.delete_envelope_workflow_definition(account_id, envelope_id, callback=callback_function) 4660 4661 :param callback function: The callback function 4662 for asynchronous request. (optional) 4663 :param str account_id: The external account number (int) or account ID Guid. (required) 4664 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4665 :return: None 4666 If the method is called asynchronously, 4667 returns the request thread. 4668 """ 4669 kwargs['_return_http_data_only'] = True 4670 if kwargs.get('callback'): 4671 return self.delete_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 4672 else: 4673 (data) = self.delete_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 4674 return data 4675 4676 def delete_envelope_workflow_definition_with_http_info(self, account_id, envelope_id, **kwargs): 4677 """ 4678 Delete the workflow definition for an envelope. 4679 Deletes the specified envelope's workflow definition if it has one. 4680 This method makes a synchronous HTTP request by default. To make an 4681 asynchronous HTTP request, please define a `callback` function 4682 to be invoked when receiving the response. 4683 >>> def callback_function(response): 4684 >>> pprint(response) 4685 >>> 4686 >>> thread = api.delete_envelope_workflow_definition_with_http_info(account_id, envelope_id, callback=callback_function) 4687 4688 :param callback function: The callback function 4689 for asynchronous request. (optional) 4690 :param str account_id: The external account number (int) or account ID Guid. (required) 4691 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4692 :return: None 4693 If the method is called asynchronously, 4694 returns the request thread. 4695 """ 4696 4697 all_params = ['account_id', 'envelope_id'] 4698 all_params.append('callback') 4699 all_params.append('_return_http_data_only') 4700 all_params.append('_preload_content') 4701 all_params.append('_request_timeout') 4702 4703 params = locals() 4704 for key, val in iteritems(params['kwargs']): 4705 if key not in all_params: 4706 raise TypeError( 4707 "Got an unexpected keyword argument '%s'" 4708 " to method delete_envelope_workflow_definition" % key 4709 ) 4710 params[key] = val 4711 del params['kwargs'] 4712 # verify the required parameter 'account_id' is set 4713 if ('account_id' not in params) or (params['account_id'] is None): 4714 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_workflow_definition`") 4715 # verify the required parameter 'envelope_id' is set 4716 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4717 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_envelope_workflow_definition`") 4718 4719 4720 collection_formats = {} 4721 4722 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow'.replace('{format}', 'json') 4723 path_params = {} 4724 if 'account_id' in params: 4725 path_params['accountId'] = params['account_id'] 4726 if 'envelope_id' in params: 4727 path_params['envelopeId'] = params['envelope_id'] 4728 4729 query_params = {} 4730 4731 header_params = {} 4732 4733 form_params = [] 4734 local_var_files = {} 4735 4736 body_params = None 4737 # HTTP header `Accept` 4738 header_params['Accept'] = self.api_client.\ 4739 select_header_accept(['application/json']) 4740 4741 # Authentication setting 4742 auth_settings = [] 4743 4744 return self.api_client.call_api(resource_path, 'DELETE', 4745 path_params, 4746 query_params, 4747 header_params, 4748 body=body_params, 4749 post_params=form_params, 4750 files=local_var_files, 4751 response_type=None, 4752 auth_settings=auth_settings, 4753 callback=params.get('callback'), 4754 _return_http_data_only=params.get('_return_http_data_only'), 4755 _preload_content=params.get('_preload_content', True), 4756 _request_timeout=params.get('_request_timeout'), 4757 collection_formats=collection_formats) 4758 4759 def delete_envelope_workflow_step_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 4760 """ 4761 Deletes the envelope workflow step definition for an envelope's workflow by step id. 4762 This method makes a synchronous HTTP request by default. To make an 4763 asynchronous HTTP request, please define a `callback` function 4764 to be invoked when receiving the response. 4765 >>> def callback_function(response): 4766 >>> pprint(response) 4767 >>> 4768 >>> thread = api.delete_envelope_workflow_step_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 4769 4770 :param callback function: The callback function 4771 for asynchronous request. (optional) 4772 :param str account_id: The external account number (int) or account ID Guid. (required) 4773 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4774 :param str workflow_step_id: (required) 4775 :return: None 4776 If the method is called asynchronously, 4777 returns the request thread. 4778 """ 4779 kwargs['_return_http_data_only'] = True 4780 if kwargs.get('callback'): 4781 return self.delete_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 4782 else: 4783 (data) = self.delete_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 4784 return data 4785 4786 def delete_envelope_workflow_step_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 4787 """ 4788 Deletes the envelope workflow step definition for an envelope's workflow by step id. 4789 This method makes a synchronous HTTP request by default. To make an 4790 asynchronous HTTP request, please define a `callback` function 4791 to be invoked when receiving the response. 4792 >>> def callback_function(response): 4793 >>> pprint(response) 4794 >>> 4795 >>> thread = api.delete_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 4796 4797 :param callback function: The callback function 4798 for asynchronous request. (optional) 4799 :param str account_id: The external account number (int) or account ID Guid. (required) 4800 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4801 :param str workflow_step_id: (required) 4802 :return: None 4803 If the method is called asynchronously, 4804 returns the request thread. 4805 """ 4806 4807 all_params = ['account_id', 'envelope_id', 'workflow_step_id'] 4808 all_params.append('callback') 4809 all_params.append('_return_http_data_only') 4810 all_params.append('_preload_content') 4811 all_params.append('_request_timeout') 4812 4813 params = locals() 4814 for key, val in iteritems(params['kwargs']): 4815 if key not in all_params: 4816 raise TypeError( 4817 "Got an unexpected keyword argument '%s'" 4818 " to method delete_envelope_workflow_step_definition" % key 4819 ) 4820 params[key] = val 4821 del params['kwargs'] 4822 # verify the required parameter 'account_id' is set 4823 if ('account_id' not in params) or (params['account_id'] is None): 4824 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_workflow_step_definition`") 4825 # verify the required parameter 'envelope_id' is set 4826 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4827 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_envelope_workflow_step_definition`") 4828 # verify the required parameter 'workflow_step_id' is set 4829 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 4830 raise ValueError("Missing the required parameter `workflow_step_id` when calling `delete_envelope_workflow_step_definition`") 4831 4832 4833 collection_formats = {} 4834 4835 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 4836 path_params = {} 4837 if 'account_id' in params: 4838 path_params['accountId'] = params['account_id'] 4839 if 'envelope_id' in params: 4840 path_params['envelopeId'] = params['envelope_id'] 4841 if 'workflow_step_id' in params: 4842 path_params['workflowStepId'] = params['workflow_step_id'] 4843 4844 query_params = {} 4845 4846 header_params = {} 4847 4848 form_params = [] 4849 local_var_files = {} 4850 4851 body_params = None 4852 # HTTP header `Accept` 4853 header_params['Accept'] = self.api_client.\ 4854 select_header_accept(['application/json']) 4855 4856 # Authentication setting 4857 auth_settings = [] 4858 4859 return self.api_client.call_api(resource_path, 'DELETE', 4860 path_params, 4861 query_params, 4862 header_params, 4863 body=body_params, 4864 post_params=form_params, 4865 files=local_var_files, 4866 response_type=None, 4867 auth_settings=auth_settings, 4868 callback=params.get('callback'), 4869 _return_http_data_only=params.get('_return_http_data_only'), 4870 _preload_content=params.get('_preload_content', True), 4871 _request_timeout=params.get('_request_timeout'), 4872 collection_formats=collection_formats) 4873 4874 def delete_lock(self, account_id, envelope_id, **kwargs): 4875 """ 4876 Deletes an envelope lock. 4877 Deletes the lock from the specified envelope. The `X-DocuSign-Edit` header must be included in the request. 4878 This method makes a synchronous HTTP request by default. To make an 4879 asynchronous HTTP request, please define a `callback` function 4880 to be invoked when receiving the response. 4881 >>> def callback_function(response): 4882 >>> pprint(response) 4883 >>> 4884 >>> thread = api.delete_lock(account_id, envelope_id, callback=callback_function) 4885 4886 :param callback function: The callback function 4887 for asynchronous request. (optional) 4888 :param str account_id: The external account number (int) or account ID Guid. (required) 4889 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4890 :return: LockInformation 4891 If the method is called asynchronously, 4892 returns the request thread. 4893 """ 4894 kwargs['_return_http_data_only'] = True 4895 if kwargs.get('callback'): 4896 return self.delete_lock_with_http_info(account_id, envelope_id, **kwargs) 4897 else: 4898 (data) = self.delete_lock_with_http_info(account_id, envelope_id, **kwargs) 4899 return data 4900 4901 def delete_lock_with_http_info(self, account_id, envelope_id, **kwargs): 4902 """ 4903 Deletes an envelope lock. 4904 Deletes the lock from the specified envelope. The `X-DocuSign-Edit` header must be included in the request. 4905 This method makes a synchronous HTTP request by default. To make an 4906 asynchronous HTTP request, please define a `callback` function 4907 to be invoked when receiving the response. 4908 >>> def callback_function(response): 4909 >>> pprint(response) 4910 >>> 4911 >>> thread = api.delete_lock_with_http_info(account_id, envelope_id, callback=callback_function) 4912 4913 :param callback function: The callback function 4914 for asynchronous request. (optional) 4915 :param str account_id: The external account number (int) or account ID Guid. (required) 4916 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4917 :return: LockInformation 4918 If the method is called asynchronously, 4919 returns the request thread. 4920 """ 4921 4922 all_params = ['account_id', 'envelope_id'] 4923 all_params.append('callback') 4924 all_params.append('_return_http_data_only') 4925 all_params.append('_preload_content') 4926 all_params.append('_request_timeout') 4927 4928 params = locals() 4929 for key, val in iteritems(params['kwargs']): 4930 if key not in all_params: 4931 raise TypeError( 4932 "Got an unexpected keyword argument '%s'" 4933 " to method delete_lock" % key 4934 ) 4935 params[key] = val 4936 del params['kwargs'] 4937 # verify the required parameter 'account_id' is set 4938 if ('account_id' not in params) or (params['account_id'] is None): 4939 raise ValueError("Missing the required parameter `account_id` when calling `delete_lock`") 4940 # verify the required parameter 'envelope_id' is set 4941 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4942 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_lock`") 4943 4944 4945 collection_formats = {} 4946 4947 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/lock'.replace('{format}', 'json') 4948 path_params = {} 4949 if 'account_id' in params: 4950 path_params['accountId'] = params['account_id'] 4951 if 'envelope_id' in params: 4952 path_params['envelopeId'] = params['envelope_id'] 4953 4954 query_params = {} 4955 4956 header_params = {} 4957 4958 form_params = [] 4959 local_var_files = {} 4960 4961 body_params = None 4962 # HTTP header `Accept` 4963 header_params['Accept'] = self.api_client.\ 4964 select_header_accept(['application/json']) 4965 4966 # Authentication setting 4967 auth_settings = [] 4968 4969 return self.api_client.call_api(resource_path, 'DELETE', 4970 path_params, 4971 query_params, 4972 header_params, 4973 body=body_params, 4974 post_params=form_params, 4975 files=local_var_files, 4976 response_type='LockInformation', 4977 auth_settings=auth_settings, 4978 callback=params.get('callback'), 4979 _return_http_data_only=params.get('_return_http_data_only'), 4980 _preload_content=params.get('_preload_content', True), 4981 _request_timeout=params.get('_request_timeout'), 4982 collection_formats=collection_formats) 4983 4984 def delete_recipient(self, account_id, envelope_id, recipient_id, **kwargs): 4985 """ 4986 Deletes a recipient from an envelope. 4987 Deletes the specified recipient file from the specified envelope. This cannot be used if the envelope has been sent. 4988 This method makes a synchronous HTTP request by default. To make an 4989 asynchronous HTTP request, please define a `callback` function 4990 to be invoked when receiving the response. 4991 >>> def callback_function(response): 4992 >>> pprint(response) 4993 >>> 4994 >>> thread = api.delete_recipient(account_id, envelope_id, recipient_id, callback=callback_function) 4995 4996 :param callback function: The callback function 4997 for asynchronous request. (optional) 4998 :param str account_id: The external account number (int) or account ID Guid. (required) 4999 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5000 :param str recipient_id: The ID of the recipient being accessed. (required) 5001 :return: Recipients 5002 If the method is called asynchronously, 5003 returns the request thread. 5004 """ 5005 kwargs['_return_http_data_only'] = True 5006 if kwargs.get('callback'): 5007 return self.delete_recipient_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 5008 else: 5009 (data) = self.delete_recipient_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 5010 return data 5011 5012 def delete_recipient_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 5013 """ 5014 Deletes a recipient from an envelope. 5015 Deletes the specified recipient file from the specified envelope. This cannot be used if the envelope has been sent. 5016 This method makes a synchronous HTTP request by default. To make an 5017 asynchronous HTTP request, please define a `callback` function 5018 to be invoked when receiving the response. 5019 >>> def callback_function(response): 5020 >>> pprint(response) 5021 >>> 5022 >>> thread = api.delete_recipient_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 5023 5024 :param callback function: The callback function 5025 for asynchronous request. (optional) 5026 :param str account_id: The external account number (int) or account ID Guid. (required) 5027 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5028 :param str recipient_id: The ID of the recipient being accessed. (required) 5029 :return: Recipients 5030 If the method is called asynchronously, 5031 returns the request thread. 5032 """ 5033 5034 all_params = ['account_id', 'envelope_id', 'recipient_id'] 5035 all_params.append('callback') 5036 all_params.append('_return_http_data_only') 5037 all_params.append('_preload_content') 5038 all_params.append('_request_timeout') 5039 5040 params = locals() 5041 for key, val in iteritems(params['kwargs']): 5042 if key not in all_params: 5043 raise TypeError( 5044 "Got an unexpected keyword argument '%s'" 5045 " to method delete_recipient" % key 5046 ) 5047 params[key] = val 5048 del params['kwargs'] 5049 # verify the required parameter 'account_id' is set 5050 if ('account_id' not in params) or (params['account_id'] is None): 5051 raise ValueError("Missing the required parameter `account_id` when calling `delete_recipient`") 5052 # verify the required parameter 'envelope_id' is set 5053 if ('envelope_id' not in params) or (params['envelope_id'] is None): 5054 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_recipient`") 5055 # verify the required parameter 'recipient_id' is set 5056 if ('recipient_id' not in params) or (params['recipient_id'] is None): 5057 raise ValueError("Missing the required parameter `recipient_id` when calling `delete_recipient`") 5058 5059 5060 collection_formats = {} 5061 5062 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}'.replace('{format}', 'json') 5063 path_params = {} 5064 if 'account_id' in params: 5065 path_params['accountId'] = params['account_id'] 5066 if 'envelope_id' in params: 5067 path_params['envelopeId'] = params['envelope_id'] 5068 if 'recipient_id' in params: 5069 path_params['recipientId'] = params['recipient_id'] 5070 5071 query_params = {} 5072 5073 header_params = {} 5074 5075 form_params = [] 5076 local_var_files = {} 5077 5078 body_params = None 5079 # HTTP header `Accept` 5080 header_params['Accept'] = self.api_client.\ 5081 select_header_accept(['application/json']) 5082 5083 # Authentication setting 5084 auth_settings = [] 5085 5086 return self.api_client.call_api(resource_path, 'DELETE', 5087 path_params, 5088 query_params, 5089 header_params, 5090 body=body_params, 5091 post_params=form_params, 5092 files=local_var_files, 5093 response_type='Recipients', 5094 auth_settings=auth_settings, 5095 callback=params.get('callback'), 5096 _return_http_data_only=params.get('_return_http_data_only'), 5097 _preload_content=params.get('_preload_content', True), 5098 _request_timeout=params.get('_request_timeout'), 5099 collection_formats=collection_formats) 5100 5101 def delete_recipients(self, account_id, envelope_id, **kwargs): 5102 """ 5103 Deletes recipients from an envelope. 5104 Deletes one or more recipients from a draft or sent envelope. Recipients to be deleted are listed in the request, with the `recipientId` being used as the key for deleting recipients. If the envelope is `In Process`, meaning that it has been sent and has not been completed or voided, recipients that have completed their actions cannot be deleted. 5105 This method makes a synchronous HTTP request by default. To make an 5106 asynchronous HTTP request, please define a `callback` function 5107 to be invoked when receiving the response. 5108 >>> def callback_function(response): 5109 >>> pprint(response) 5110 >>> 5111 >>> thread = api.delete_recipients(account_id, envelope_id, callback=callback_function) 5112 5113 :param callback function: The callback function 5114 for asynchronous request. (optional) 5115 :param str account_id: The external account number (int) or account ID Guid. (required) 5116 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5117 :param Recipients recipients: 5118 :return: Recipients 5119 If the method is called asynchronously, 5120 returns the request thread. 5121 """ 5122 kwargs['_return_http_data_only'] = True 5123 if kwargs.get('callback'): 5124 return self.delete_recipients_with_http_info(account_id, envelope_id, **kwargs) 5125 else: 5126 (data) = self.delete_recipients_with_http_info(account_id, envelope_id, **kwargs) 5127 return data 5128 5129 def delete_recipients_with_http_info(self, account_id, envelope_id, **kwargs): 5130 """ 5131 Deletes recipients from an envelope. 5132 Deletes one or more recipients from a draft or sent envelope. Recipients to be deleted are listed in the request, with the `recipientId` being used as the key for deleting recipients. If the envelope is `In Process`, meaning that it has been sent and has not been completed or voided, recipients that have completed their actions cannot be deleted. 5133 This method makes a synchronous HTTP request by default. To make an 5134 asynchronous HTTP request, please define a `callback` function 5135 to be invoked when receiving the response. 5136 >>> def callback_function(response): 5137 >>> pprint(response) 5138 >>> 5139 >>> thread = api.delete_recipients_with_http_info(account_id, envelope_id, callback=callback_function) 5140 5141 :param callback function: The callback function 5142 for asynchronous request. (optional) 5143 :param str account_id: The external account number (int) or account ID Guid. (required) 5144 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5145 :param Recipients recipients: 5146 :return: Recipients 5147 If the method is called asynchronously, 5148 returns the request thread. 5149 """ 5150 5151 all_params = ['account_id', 'envelope_id', 'recipients'] 5152 all_params.append('callback') 5153 all_params.append('_return_http_data_only') 5154 all_params.append('_preload_content') 5155 all_params.append('_request_timeout') 5156 5157 params = locals() 5158 for key, val in iteritems(params['kwargs']): 5159 if key not in all_params: 5160 raise TypeError( 5161 "Got an unexpected keyword argument '%s'" 5162 " to method delete_recipients" % key 5163 ) 5164 params[key] = val 5165 del params['kwargs'] 5166 # verify the required parameter 'account_id' is set 5167 if ('account_id' not in params) or (params['account_id'] is None): 5168 raise ValueError("Missing the required parameter `account_id` when calling `delete_recipients`") 5169 # verify the required parameter 'envelope_id' is set 5170 if ('envelope_id' not in params) or (params['envelope_id'] is None): 5171 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_recipients`") 5172 5173 5174 collection_formats = {} 5175 5176 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients'.replace('{format}', 'json') 5177 path_params = {} 5178 if 'account_id' in params: 5179 path_params['accountId'] = params['account_id'] 5180 if 'envelope_id' in params: 5181 path_params['envelopeId'] = params['envelope_id'] 5182 5183 query_params = {} 5184 5185 header_params = {} 5186 5187 form_params = [] 5188 local_var_files = {} 5189 5190 body_params = None 5191 if 'recipients' in params: 5192 body_params = params['recipients'] 5193 # HTTP header `Accept` 5194 header_params['Accept'] = self.api_client.\ 5195 select_header_accept(['application/json']) 5196 5197 # Authentication setting 5198 auth_settings = [] 5199 5200 return self.api_client.call_api(resource_path, 'DELETE', 5201 path_params, 5202 query_params, 5203 header_params, 5204 body=body_params, 5205 post_params=form_params, 5206 files=local_var_files, 5207 response_type='Recipients', 5208 auth_settings=auth_settings, 5209 callback=params.get('callback'), 5210 _return_http_data_only=params.get('_return_http_data_only'), 5211 _preload_content=params.get('_preload_content', True), 5212 _request_timeout=params.get('_request_timeout'), 5213 collection_formats=collection_formats) 5214 5215 def delete_tabs(self, account_id, envelope_id, recipient_id, **kwargs): 5216 """ 5217 Deletes the tabs associated with a recipient. 5218 Deletes one or more tabs associated with a recipient in a draft envelope. 5219 This method makes a synchronous HTTP request by default. To make an 5220 asynchronous HTTP request, please define a `callback` function 5221 to be invoked when receiving the response. 5222 >>> def callback_function(response): 5223 >>> pprint(response) 5224 >>> 5225 >>> thread = api.delete_tabs(account_id, envelope_id, recipient_id, callback=callback_function) 5226 5227 :param callback function: The callback function 5228 for asynchronous request. (optional) 5229 :param str account_id: The external account number (int) or account ID Guid. (required) 5230 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5231 :param str recipient_id: The ID of the recipient being accessed. (required) 5232 :param Tabs tabs: 5233 :return: Tabs 5234 If the method is called asynchronously, 5235 returns the request thread. 5236 """ 5237 kwargs['_return_http_data_only'] = True 5238 if kwargs.get('callback'): 5239 return self.delete_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 5240 else: 5241 (data) = self.delete_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 5242 return data 5243 5244 def delete_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 5245 """ 5246 Deletes the tabs associated with a recipient. 5247 Deletes one or more tabs associated with a recipient in a draft envelope. 5248 This method makes a synchronous HTTP request by default. To make an 5249 asynchronous HTTP request, please define a `callback` function 5250 to be invoked when receiving the response. 5251 >>> def callback_function(response): 5252 >>> pprint(response) 5253 >>> 5254 >>> thread = api.delete_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 5255 5256 :param callback function: The callback function 5257 for asynchronous request. (optional) 5258 :param str account_id: The external account number (int) or account ID Guid. (required) 5259 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5260 :param str recipient_id: The ID of the recipient being accessed. (required) 5261 :param Tabs tabs: 5262 :return: Tabs 5263 If the method is called asynchronously, 5264 returns the request thread. 5265 """ 5266 5267 all_params = ['account_id', 'envelope_id', 'recipient_id', 'tabs'] 5268 all_params.append('callback') 5269 all_params.append('_return_http_data_only') 5270 all_params.append('_preload_content') 5271 all_params.append('_request_timeout') 5272 5273 params = locals() 5274 for key, val in iteritems(params['kwargs']): 5275 if key not in all_params: 5276 raise TypeError( 5277 "Got an unexpected keyword argument '%s'" 5278 " to method delete_tabs" % key 5279 ) 5280 params[key] = val 5281 del params['kwargs'] 5282 # verify the required parameter 'account_id' is set 5283 if ('account_id' not in params) or (params['account_id'] is None): 5284 raise ValueError("Missing the required parameter `account_id` when calling `delete_tabs`") 5285 # verify the required parameter 'envelope_id' is set 5286 if ('envelope_id' not in params) or (params['envelope_id'] is None): 5287 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_tabs`") 5288 # verify the required parameter 'recipient_id' is set 5289 if ('recipient_id' not in params) or (params['recipient_id'] is None): 5290 raise ValueError("Missing the required parameter `recipient_id` when calling `delete_tabs`") 5291 5292 5293 collection_formats = {} 5294 5295 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/tabs'.replace('{format}', 'json') 5296 path_params = {} 5297 if 'account_id' in params: 5298 path_params['accountId'] = params['account_id'] 5299 if 'envelope_id' in params: 5300 path_params['envelopeId'] = params['envelope_id'] 5301 if 'recipient_id' in params: 5302 path_params['recipientId'] = params['recipient_id'] 5303 5304 query_params = {} 5305 5306 header_params = {} 5307 5308 form_params = [] 5309 local_var_files = {} 5310 5311 body_params = None 5312 if 'tabs' in params: 5313 body_params = params['tabs'] 5314 # HTTP header `Accept` 5315 header_params['Accept'] = self.api_client.\ 5316 select_header_accept(['application/json']) 5317 5318 # Authentication setting 5319 auth_settings = [] 5320 5321 return self.api_client.call_api(resource_path, 'DELETE', 5322 path_params, 5323 query_params, 5324 header_params, 5325 body=body_params, 5326 post_params=form_params, 5327 files=local_var_files, 5328 response_type='Tabs', 5329 auth_settings=auth_settings, 5330 callback=params.get('callback'), 5331 _return_http_data_only=params.get('_return_http_data_only'), 5332 _preload_content=params.get('_preload_content', True), 5333 _request_timeout=params.get('_request_timeout'), 5334 collection_formats=collection_formats) 5335 5336 def delete_template_delayed_routing_definition(self, account_id, template_id, workflow_step_id, **kwargs): 5337 """ 5338 Deletes the delayed routing rules for the specified template workflow step. 5339 This method makes a synchronous HTTP request by default. To make an 5340 asynchronous HTTP request, please define a `callback` function 5341 to be invoked when receiving the response. 5342 >>> def callback_function(response): 5343 >>> pprint(response) 5344 >>> 5345 >>> thread = api.delete_template_delayed_routing_definition(account_id, template_id, workflow_step_id, callback=callback_function) 5346 5347 :param callback function: The callback function 5348 for asynchronous request. (optional) 5349 :param str account_id: The external account number (int) or account ID Guid. (required) 5350 :param str template_id: The ID of the template being accessed. (required) 5351 :param str workflow_step_id: (required) 5352 :return: None 5353 If the method is called asynchronously, 5354 returns the request thread. 5355 """ 5356 kwargs['_return_http_data_only'] = True 5357 if kwargs.get('callback'): 5358 return self.delete_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 5359 else: 5360 (data) = self.delete_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 5361 return data 5362 5363 def delete_template_delayed_routing_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 5364 """ 5365 Deletes the delayed routing rules for the specified template workflow step. 5366 This method makes a synchronous HTTP request by default. To make an 5367 asynchronous HTTP request, please define a `callback` function 5368 to be invoked when receiving the response. 5369 >>> def callback_function(response): 5370 >>> pprint(response) 5371 >>> 5372 >>> thread = api.delete_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 5373 5374 :param callback function: The callback function 5375 for asynchronous request. (optional) 5376 :param str account_id: The external account number (int) or account ID Guid. (required) 5377 :param str template_id: The ID of the template being accessed. (required) 5378 :param str workflow_step_id: (required) 5379 :return: None 5380 If the method is called asynchronously, 5381 returns the request thread. 5382 """ 5383 5384 all_params = ['account_id', 'template_id', 'workflow_step_id'] 5385 all_params.append('callback') 5386 all_params.append('_return_http_data_only') 5387 all_params.append('_preload_content') 5388 all_params.append('_request_timeout') 5389 5390 params = locals() 5391 for key, val in iteritems(params['kwargs']): 5392 if key not in all_params: 5393 raise TypeError( 5394 "Got an unexpected keyword argument '%s'" 5395 " to method delete_template_delayed_routing_definition" % key 5396 ) 5397 params[key] = val 5398 del params['kwargs'] 5399 # verify the required parameter 'account_id' is set 5400 if ('account_id' not in params) or (params['account_id'] is None): 5401 raise ValueError("Missing the required parameter `account_id` when calling `delete_template_delayed_routing_definition`") 5402 # verify the required parameter 'template_id' is set 5403 if ('template_id' not in params) or (params['template_id'] is None): 5404 raise ValueError("Missing the required parameter `template_id` when calling `delete_template_delayed_routing_definition`") 5405 # verify the required parameter 'workflow_step_id' is set 5406 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 5407 raise ValueError("Missing the required parameter `workflow_step_id` when calling `delete_template_delayed_routing_definition`") 5408 5409 5410 collection_formats = {} 5411 5412 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 5413 path_params = {} 5414 if 'account_id' in params: 5415 path_params['accountId'] = params['account_id'] 5416 if 'template_id' in params: 5417 path_params['templateId'] = params['template_id'] 5418 if 'workflow_step_id' in params: 5419 path_params['workflowStepId'] = params['workflow_step_id'] 5420 5421 query_params = {} 5422 5423 header_params = {} 5424 5425 form_params = [] 5426 local_var_files = {} 5427 5428 body_params = None 5429 # HTTP header `Accept` 5430 header_params['Accept'] = self.api_client.\ 5431 select_header_accept(['application/json']) 5432 5433 # Authentication setting 5434 auth_settings = [] 5435 5436 return self.api_client.call_api(resource_path, 'DELETE', 5437 path_params, 5438 query_params, 5439 header_params, 5440 body=body_params, 5441 post_params=form_params, 5442 files=local_var_files, 5443 response_type=None, 5444 auth_settings=auth_settings, 5445 callback=params.get('callback'), 5446 _return_http_data_only=params.get('_return_http_data_only'), 5447 _preload_content=params.get('_preload_content', True), 5448 _request_timeout=params.get('_request_timeout'), 5449 collection_formats=collection_formats) 5450 5451 def delete_template_scheduled_sending_definition(self, account_id, template_id, **kwargs): 5452 """ 5453 Deletes the scheduled sending rules for the template's workflow. 5454 This method makes a synchronous HTTP request by default. To make an 5455 asynchronous HTTP request, please define a `callback` function 5456 to be invoked when receiving the response. 5457 >>> def callback_function(response): 5458 >>> pprint(response) 5459 >>> 5460 >>> thread = api.delete_template_scheduled_sending_definition(account_id, template_id, callback=callback_function) 5461 5462 :param callback function: The callback function 5463 for asynchronous request. (optional) 5464 :param str account_id: The external account number (int) or account ID Guid. (required) 5465 :param str template_id: The ID of the template being accessed. (required) 5466 :return: None 5467 If the method is called asynchronously, 5468 returns the request thread. 5469 """ 5470 kwargs['_return_http_data_only'] = True 5471 if kwargs.get('callback'): 5472 return self.delete_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 5473 else: 5474 (data) = self.delete_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 5475 return data 5476 5477 def delete_template_scheduled_sending_definition_with_http_info(self, account_id, template_id, **kwargs): 5478 """ 5479 Deletes the scheduled sending rules for the template's workflow. 5480 This method makes a synchronous HTTP request by default. To make an 5481 asynchronous HTTP request, please define a `callback` function 5482 to be invoked when receiving the response. 5483 >>> def callback_function(response): 5484 >>> pprint(response) 5485 >>> 5486 >>> thread = api.delete_template_scheduled_sending_definition_with_http_info(account_id, template_id, callback=callback_function) 5487 5488 :param callback function: The callback function 5489 for asynchronous request. (optional) 5490 :param str account_id: The external account number (int) or account ID Guid. (required) 5491 :param str template_id: The ID of the template being accessed. (required) 5492 :return: None 5493 If the method is called asynchronously, 5494 returns the request thread. 5495 """ 5496 5497 all_params = ['account_id', 'template_id'] 5498 all_params.append('callback') 5499 all_params.append('_return_http_data_only') 5500 all_params.append('_preload_content') 5501 all_params.append('_request_timeout') 5502 5503 params = locals() 5504 for key, val in iteritems(params['kwargs']): 5505 if key not in all_params: 5506 raise TypeError( 5507 "Got an unexpected keyword argument '%s'" 5508 " to method delete_template_scheduled_sending_definition" % key 5509 ) 5510 params[key] = val 5511 del params['kwargs'] 5512 # verify the required parameter 'account_id' is set 5513 if ('account_id' not in params) or (params['account_id'] is None): 5514 raise ValueError("Missing the required parameter `account_id` when calling `delete_template_scheduled_sending_definition`") 5515 # verify the required parameter 'template_id' is set 5516 if ('template_id' not in params) or (params['template_id'] is None): 5517 raise ValueError("Missing the required parameter `template_id` when calling `delete_template_scheduled_sending_definition`") 5518 5519 5520 collection_formats = {} 5521 5522 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/scheduledSending'.replace('{format}', 'json') 5523 path_params = {} 5524 if 'account_id' in params: 5525 path_params['accountId'] = params['account_id'] 5526 if 'template_id' in params: 5527 path_params['templateId'] = params['template_id'] 5528 5529 query_params = {} 5530 5531 header_params = {} 5532 5533 form_params = [] 5534 local_var_files = {} 5535 5536 body_params = None 5537 # HTTP header `Accept` 5538 header_params['Accept'] = self.api_client.\ 5539 select_header_accept(['application/json']) 5540 5541 # Authentication setting 5542 auth_settings = [] 5543 5544 return self.api_client.call_api(resource_path, 'DELETE', 5545 path_params, 5546 query_params, 5547 header_params, 5548 body=body_params, 5549 post_params=form_params, 5550 files=local_var_files, 5551 response_type=None, 5552 auth_settings=auth_settings, 5553 callback=params.get('callback'), 5554 _return_http_data_only=params.get('_return_http_data_only'), 5555 _preload_content=params.get('_preload_content', True), 5556 _request_timeout=params.get('_request_timeout'), 5557 collection_formats=collection_formats) 5558 5559 def delete_template_workflow_definition(self, account_id, template_id, **kwargs): 5560 """ 5561 Delete the workflow definition for a template. 5562 Deletes the specified template's workflow definition if it has one. 5563 This method makes a synchronous HTTP request by default. To make an 5564 asynchronous HTTP request, please define a `callback` function 5565 to be invoked when receiving the response. 5566 >>> def callback_function(response): 5567 >>> pprint(response) 5568 >>> 5569 >>> thread = api.delete_template_workflow_definition(account_id, template_id, callback=callback_function) 5570 5571 :param callback function: The callback function 5572 for asynchronous request. (optional) 5573 :param str account_id: The external account number (int) or account ID Guid. (required) 5574 :param str template_id: The ID of the template being accessed. (required) 5575 :return: None 5576 If the method is called asynchronously, 5577 returns the request thread. 5578 """ 5579 kwargs['_return_http_data_only'] = True 5580 if kwargs.get('callback'): 5581 return self.delete_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 5582 else: 5583 (data) = self.delete_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 5584 return data 5585 5586 def delete_template_workflow_definition_with_http_info(self, account_id, template_id, **kwargs): 5587 """ 5588 Delete the workflow definition for a template. 5589 Deletes the specified template's workflow definition if it has one. 5590 This method makes a synchronous HTTP request by default. To make an 5591 asynchronous HTTP request, please define a `callback` function 5592 to be invoked when receiving the response. 5593 >>> def callback_function(response): 5594 >>> pprint(response) 5595 >>> 5596 >>> thread = api.delete_template_workflow_definition_with_http_info(account_id, template_id, callback=callback_function) 5597 5598 :param callback function: The callback function 5599 for asynchronous request. (optional) 5600 :param str account_id: The external account number (int) or account ID Guid. (required) 5601 :param str template_id: The ID of the template being accessed. (required) 5602 :return: None 5603 If the method is called asynchronously, 5604 returns the request thread. 5605 """ 5606 5607 all_params = ['account_id', 'template_id'] 5608 all_params.append('callback') 5609 all_params.append('_return_http_data_only') 5610 all_params.append('_preload_content') 5611 all_params.append('_request_timeout') 5612 5613 params = locals() 5614 for key, val in iteritems(params['kwargs']): 5615 if key not in all_params: 5616 raise TypeError( 5617 "Got an unexpected keyword argument '%s'" 5618 " to method delete_template_workflow_definition" % key 5619 ) 5620 params[key] = val 5621 del params['kwargs'] 5622 # verify the required parameter 'account_id' is set 5623 if ('account_id' not in params) or (params['account_id'] is None): 5624 raise ValueError("Missing the required parameter `account_id` when calling `delete_template_workflow_definition`") 5625 # verify the required parameter 'template_id' is set 5626 if ('template_id' not in params) or (params['template_id'] is None): 5627 raise ValueError("Missing the required parameter `template_id` when calling `delete_template_workflow_definition`") 5628 5629 5630 collection_formats = {} 5631 5632 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow'.replace('{format}', 'json') 5633 path_params = {} 5634 if 'account_id' in params: 5635 path_params['accountId'] = params['account_id'] 5636 if 'template_id' in params: 5637 path_params['templateId'] = params['template_id'] 5638 5639 query_params = {} 5640 5641 header_params = {} 5642 5643 form_params = [] 5644 local_var_files = {} 5645 5646 body_params = None 5647 # HTTP header `Accept` 5648 header_params['Accept'] = self.api_client.\ 5649 select_header_accept(['application/json']) 5650 5651 # Authentication setting 5652 auth_settings = [] 5653 5654 return self.api_client.call_api(resource_path, 'DELETE', 5655 path_params, 5656 query_params, 5657 header_params, 5658 body=body_params, 5659 post_params=form_params, 5660 files=local_var_files, 5661 response_type=None, 5662 auth_settings=auth_settings, 5663 callback=params.get('callback'), 5664 _return_http_data_only=params.get('_return_http_data_only'), 5665 _preload_content=params.get('_preload_content', True), 5666 _request_timeout=params.get('_request_timeout'), 5667 collection_formats=collection_formats) 5668 5669 def delete_template_workflow_step_definition(self, account_id, template_id, workflow_step_id, **kwargs): 5670 """ 5671 Deletes the workflow step definition for an template's workflow by step id. 5672 This method makes a synchronous HTTP request by default. To make an 5673 asynchronous HTTP request, please define a `callback` function 5674 to be invoked when receiving the response. 5675 >>> def callback_function(response): 5676 >>> pprint(response) 5677 >>> 5678 >>> thread = api.delete_template_workflow_step_definition(account_id, template_id, workflow_step_id, callback=callback_function) 5679 5680 :param callback function: The callback function 5681 for asynchronous request. (optional) 5682 :param str account_id: The external account number (int) or account ID Guid. (required) 5683 :param str template_id: The ID of the template being accessed. (required) 5684 :param str workflow_step_id: (required) 5685 :return: None 5686 If the method is called asynchronously, 5687 returns the request thread. 5688 """ 5689 kwargs['_return_http_data_only'] = True 5690 if kwargs.get('callback'): 5691 return self.delete_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 5692 else: 5693 (data) = self.delete_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 5694 return data 5695 5696 def delete_template_workflow_step_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 5697 """ 5698 Deletes the workflow step definition for an template's workflow by step id. 5699 This method makes a synchronous HTTP request by default. To make an 5700 asynchronous HTTP request, please define a `callback` function 5701 to be invoked when receiving the response. 5702 >>> def callback_function(response): 5703 >>> pprint(response) 5704 >>> 5705 >>> thread = api.delete_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 5706 5707 :param callback function: The callback function 5708 for asynchronous request. (optional) 5709 :param str account_id: The external account number (int) or account ID Guid. (required) 5710 :param str template_id: The ID of the template being accessed. (required) 5711 :param str workflow_step_id: (required) 5712 :return: None 5713 If the method is called asynchronously, 5714 returns the request thread. 5715 """ 5716 5717 all_params = ['account_id', 'template_id', 'workflow_step_id'] 5718 all_params.append('callback') 5719 all_params.append('_return_http_data_only') 5720 all_params.append('_preload_content') 5721 all_params.append('_request_timeout') 5722 5723 params = locals() 5724 for key, val in iteritems(params['kwargs']): 5725 if key not in all_params: 5726 raise TypeError( 5727 "Got an unexpected keyword argument '%s'" 5728 " to method delete_template_workflow_step_definition" % key 5729 ) 5730 params[key] = val 5731 del params['kwargs'] 5732 # verify the required parameter 'account_id' is set 5733 if ('account_id' not in params) or (params['account_id'] is None): 5734 raise ValueError("Missing the required parameter `account_id` when calling `delete_template_workflow_step_definition`") 5735 # verify the required parameter 'template_id' is set 5736 if ('template_id' not in params) or (params['template_id'] is None): 5737 raise ValueError("Missing the required parameter `template_id` when calling `delete_template_workflow_step_definition`") 5738 # verify the required parameter 'workflow_step_id' is set 5739 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 5740 raise ValueError("Missing the required parameter `workflow_step_id` when calling `delete_template_workflow_step_definition`") 5741 5742 5743 collection_formats = {} 5744 5745 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 5746 path_params = {} 5747 if 'account_id' in params: 5748 path_params['accountId'] = params['account_id'] 5749 if 'template_id' in params: 5750 path_params['templateId'] = params['template_id'] 5751 if 'workflow_step_id' in params: 5752 path_params['workflowStepId'] = params['workflow_step_id'] 5753 5754 query_params = {} 5755 5756 header_params = {} 5757 5758 form_params = [] 5759 local_var_files = {} 5760 5761 body_params = None 5762 # HTTP header `Accept` 5763 header_params['Accept'] = self.api_client.\ 5764 select_header_accept(['application/json']) 5765 5766 # Authentication setting 5767 auth_settings = [] 5768 5769 return self.api_client.call_api(resource_path, 'DELETE', 5770 path_params, 5771 query_params, 5772 header_params, 5773 body=body_params, 5774 post_params=form_params, 5775 files=local_var_files, 5776 response_type=None, 5777 auth_settings=auth_settings, 5778 callback=params.get('callback'), 5779 _return_http_data_only=params.get('_return_http_data_only'), 5780 _preload_content=params.get('_preload_content', True), 5781 _request_timeout=params.get('_request_timeout'), 5782 collection_formats=collection_formats) 5783 5784 def delete_templates_from_document(self, account_id, document_id, envelope_id, template_id, **kwargs): 5785 """ 5786 Deletes a template from a document in an existing envelope. 5787 Deletes the specified template from a document in an existing envelope. 5788 This method makes a synchronous HTTP request by default. To make an 5789 asynchronous HTTP request, please define a `callback` function 5790 to be invoked when receiving the response. 5791 >>> def callback_function(response): 5792 >>> pprint(response) 5793 >>> 5794 >>> thread = api.delete_templates_from_document(account_id, document_id, envelope_id, template_id, callback=callback_function) 5795 5796 :param callback function: The callback function 5797 for asynchronous request. (optional) 5798 :param str account_id: The external account number (int) or account ID Guid. (required) 5799 :param str document_id: The ID of the document being accessed. (required) 5800 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5801 :param str template_id: The ID of the template being accessed. (required) 5802 :return: None 5803 If the method is called asynchronously, 5804 returns the request thread. 5805 """ 5806 kwargs['_return_http_data_only'] = True 5807 if kwargs.get('callback'): 5808 return self.delete_templates_from_document_with_http_info(account_id, document_id, envelope_id, template_id, **kwargs) 5809 else: 5810 (data) = self.delete_templates_from_document_with_http_info(account_id, document_id, envelope_id, template_id, **kwargs) 5811 return data 5812 5813 def delete_templates_from_document_with_http_info(self, account_id, document_id, envelope_id, template_id, **kwargs): 5814 """ 5815 Deletes a template from a document in an existing envelope. 5816 Deletes the specified template from a document in an existing envelope. 5817 This method makes a synchronous HTTP request by default. To make an 5818 asynchronous HTTP request, please define a `callback` function 5819 to be invoked when receiving the response. 5820 >>> def callback_function(response): 5821 >>> pprint(response) 5822 >>> 5823 >>> thread = api.delete_templates_from_document_with_http_info(account_id, document_id, envelope_id, template_id, callback=callback_function) 5824 5825 :param callback function: The callback function 5826 for asynchronous request. (optional) 5827 :param str account_id: The external account number (int) or account ID Guid. (required) 5828 :param str document_id: The ID of the document being accessed. (required) 5829 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5830 :param str template_id: The ID of the template being accessed. (required) 5831 :return: None 5832 If the method is called asynchronously, 5833 returns the request thread. 5834 """ 5835 5836 all_params = ['account_id', 'document_id', 'envelope_id', 'template_id'] 5837 all_params.append('callback') 5838 all_params.append('_return_http_data_only') 5839 all_params.append('_preload_content') 5840 all_params.append('_request_timeout') 5841 5842 params = locals() 5843 for key, val in iteritems(params['kwargs']): 5844 if key not in all_params: 5845 raise TypeError( 5846 "Got an unexpected keyword argument '%s'" 5847 " to method delete_templates_from_document" % key 5848 ) 5849 params[key] = val 5850 del params['kwargs'] 5851 # verify the required parameter 'account_id' is set 5852 if ('account_id' not in params) or (params['account_id'] is None): 5853 raise ValueError("Missing the required parameter `account_id` when calling `delete_templates_from_document`") 5854 # verify the required parameter 'document_id' is set 5855 if ('document_id' not in params) or (params['document_id'] is None): 5856 raise ValueError("Missing the required parameter `document_id` when calling `delete_templates_from_document`") 5857 # verify the required parameter 'envelope_id' is set 5858 if ('envelope_id' not in params) or (params['envelope_id'] is None): 5859 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_templates_from_document`") 5860 # verify the required parameter 'template_id' is set 5861 if ('template_id' not in params) or (params['template_id'] is None): 5862 raise ValueError("Missing the required parameter `template_id` when calling `delete_templates_from_document`") 5863 5864 5865 collection_formats = {} 5866 5867 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/templates/{templateId}'.replace('{format}', 'json') 5868 path_params = {} 5869 if 'account_id' in params: 5870 path_params['accountId'] = params['account_id'] 5871 if 'document_id' in params: 5872 path_params['documentId'] = params['document_id'] 5873 if 'envelope_id' in params: 5874 path_params['envelopeId'] = params['envelope_id'] 5875 if 'template_id' in params: 5876 path_params['templateId'] = params['template_id'] 5877 5878 query_params = {} 5879 5880 header_params = {} 5881 5882 form_params = [] 5883 local_var_files = {} 5884 5885 body_params = None 5886 # HTTP header `Accept` 5887 header_params['Accept'] = self.api_client.\ 5888 select_header_accept(['application/json']) 5889 5890 # Authentication setting 5891 auth_settings = [] 5892 5893 return self.api_client.call_api(resource_path, 'DELETE', 5894 path_params, 5895 query_params, 5896 header_params, 5897 body=body_params, 5898 post_params=form_params, 5899 files=local_var_files, 5900 response_type=None, 5901 auth_settings=auth_settings, 5902 callback=params.get('callback'), 5903 _return_http_data_only=params.get('_return_http_data_only'), 5904 _preload_content=params.get('_preload_content', True), 5905 _request_timeout=params.get('_request_timeout'), 5906 collection_formats=collection_formats) 5907 5908 def get_attachment(self, account_id, attachment_id, envelope_id, **kwargs): 5909 """ 5910 Retrieves an attachment from the envelope. 5911 Retrieves an attachment from an envelope. 5912 This method makes a synchronous HTTP request by default. To make an 5913 asynchronous HTTP request, please define a `callback` function 5914 to be invoked when receiving the response. 5915 >>> def callback_function(response): 5916 >>> pprint(response) 5917 >>> 5918 >>> thread = api.get_attachment(account_id, attachment_id, envelope_id, callback=callback_function) 5919 5920 :param callback function: The callback function 5921 for asynchronous request. (optional) 5922 :param str account_id: The external account number (int) or account ID Guid. (required) 5923 :param str attachment_id: (required) 5924 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5925 :return: file 5926 If the method is called asynchronously, 5927 returns the request thread. 5928 """ 5929 kwargs['_return_http_data_only'] = True 5930 if kwargs.get('callback'): 5931 return self.get_attachment_with_http_info(account_id, attachment_id, envelope_id, **kwargs) 5932 else: 5933 (data) = self.get_attachment_with_http_info(account_id, attachment_id, envelope_id, **kwargs) 5934 return data 5935 5936 def get_attachment_with_http_info(self, account_id, attachment_id, envelope_id, **kwargs): 5937 """ 5938 Retrieves an attachment from the envelope. 5939 Retrieves an attachment from an envelope. 5940 This method makes a synchronous HTTP request by default. To make an 5941 asynchronous HTTP request, please define a `callback` function 5942 to be invoked when receiving the response. 5943 >>> def callback_function(response): 5944 >>> pprint(response) 5945 >>> 5946 >>> thread = api.get_attachment_with_http_info(account_id, attachment_id, envelope_id, callback=callback_function) 5947 5948 :param callback function: The callback function 5949 for asynchronous request. (optional) 5950 :param str account_id: The external account number (int) or account ID Guid. (required) 5951 :param str attachment_id: (required) 5952 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5953 :return: file 5954 If the method is called asynchronously, 5955 returns the request thread. 5956 """ 5957 5958 all_params = ['account_id', 'attachment_id', 'envelope_id'] 5959 all_params.append('callback') 5960 all_params.append('_return_http_data_only') 5961 all_params.append('_preload_content') 5962 all_params.append('_request_timeout') 5963 5964 params = locals() 5965 for key, val in iteritems(params['kwargs']): 5966 if key not in all_params: 5967 raise TypeError( 5968 "Got an unexpected keyword argument '%s'" 5969 " to method get_attachment" % key 5970 ) 5971 params[key] = val 5972 del params['kwargs'] 5973 # verify the required parameter 'account_id' is set 5974 if ('account_id' not in params) or (params['account_id'] is None): 5975 raise ValueError("Missing the required parameter `account_id` when calling `get_attachment`") 5976 # verify the required parameter 'attachment_id' is set 5977 if ('attachment_id' not in params) or (params['attachment_id'] is None): 5978 raise ValueError("Missing the required parameter `attachment_id` when calling `get_attachment`") 5979 # verify the required parameter 'envelope_id' is set 5980 if ('envelope_id' not in params) or (params['envelope_id'] is None): 5981 raise ValueError("Missing the required parameter `envelope_id` when calling `get_attachment`") 5982 5983 5984 collection_formats = {} 5985 5986 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments/{attachmentId}'.replace('{format}', 'json') 5987 path_params = {} 5988 if 'account_id' in params: 5989 path_params['accountId'] = params['account_id'] 5990 if 'attachment_id' in params: 5991 path_params['attachmentId'] = params['attachment_id'] 5992 if 'envelope_id' in params: 5993 path_params['envelopeId'] = params['envelope_id'] 5994 5995 query_params = {} 5996 5997 header_params = {} 5998 5999 form_params = [] 6000 local_var_files = {} 6001 6002 body_params = None 6003 # HTTP header `Accept` 6004 header_params['Accept'] = self.api_client.\ 6005 select_header_accept(['application/octet-stream']) 6006 6007 # Authentication setting 6008 auth_settings = [] 6009 6010 return self.api_client.call_api(resource_path, 'GET', 6011 path_params, 6012 query_params, 6013 header_params, 6014 body=body_params, 6015 post_params=form_params, 6016 files=local_var_files, 6017 response_type='file', 6018 auth_settings=auth_settings, 6019 callback=params.get('callback'), 6020 _return_http_data_only=params.get('_return_http_data_only'), 6021 _preload_content=params.get('_preload_content', True), 6022 _request_timeout=params.get('_request_timeout'), 6023 collection_formats=collection_formats) 6024 6025 def get_attachments(self, account_id, envelope_id, **kwargs): 6026 """ 6027 Returns a list of attachments associated with the specified envelope 6028 Returns a list of attachments associated with a specified envelope 6029 This method makes a synchronous HTTP request by default. To make an 6030 asynchronous HTTP request, please define a `callback` function 6031 to be invoked when receiving the response. 6032 >>> def callback_function(response): 6033 >>> pprint(response) 6034 >>> 6035 >>> thread = api.get_attachments(account_id, envelope_id, callback=callback_function) 6036 6037 :param callback function: The callback function 6038 for asynchronous request. (optional) 6039 :param str account_id: The external account number (int) or account ID Guid. (required) 6040 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6041 :return: EnvelopeAttachmentsResult 6042 If the method is called asynchronously, 6043 returns the request thread. 6044 """ 6045 kwargs['_return_http_data_only'] = True 6046 if kwargs.get('callback'): 6047 return self.get_attachments_with_http_info(account_id, envelope_id, **kwargs) 6048 else: 6049 (data) = self.get_attachments_with_http_info(account_id, envelope_id, **kwargs) 6050 return data 6051 6052 def get_attachments_with_http_info(self, account_id, envelope_id, **kwargs): 6053 """ 6054 Returns a list of attachments associated with the specified envelope 6055 Returns a list of attachments associated with a specified envelope 6056 This method makes a synchronous HTTP request by default. To make an 6057 asynchronous HTTP request, please define a `callback` function 6058 to be invoked when receiving the response. 6059 >>> def callback_function(response): 6060 >>> pprint(response) 6061 >>> 6062 >>> thread = api.get_attachments_with_http_info(account_id, envelope_id, callback=callback_function) 6063 6064 :param callback function: The callback function 6065 for asynchronous request. (optional) 6066 :param str account_id: The external account number (int) or account ID Guid. (required) 6067 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6068 :return: EnvelopeAttachmentsResult 6069 If the method is called asynchronously, 6070 returns the request thread. 6071 """ 6072 6073 all_params = ['account_id', 'envelope_id'] 6074 all_params.append('callback') 6075 all_params.append('_return_http_data_only') 6076 all_params.append('_preload_content') 6077 all_params.append('_request_timeout') 6078 6079 params = locals() 6080 for key, val in iteritems(params['kwargs']): 6081 if key not in all_params: 6082 raise TypeError( 6083 "Got an unexpected keyword argument '%s'" 6084 " to method get_attachments" % key 6085 ) 6086 params[key] = val 6087 del params['kwargs'] 6088 # verify the required parameter 'account_id' is set 6089 if ('account_id' not in params) or (params['account_id'] is None): 6090 raise ValueError("Missing the required parameter `account_id` when calling `get_attachments`") 6091 # verify the required parameter 'envelope_id' is set 6092 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6093 raise ValueError("Missing the required parameter `envelope_id` when calling `get_attachments`") 6094 6095 6096 collection_formats = {} 6097 6098 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments'.replace('{format}', 'json') 6099 path_params = {} 6100 if 'account_id' in params: 6101 path_params['accountId'] = params['account_id'] 6102 if 'envelope_id' in params: 6103 path_params['envelopeId'] = params['envelope_id'] 6104 6105 query_params = {} 6106 6107 header_params = {} 6108 6109 form_params = [] 6110 local_var_files = {} 6111 6112 body_params = None 6113 # HTTP header `Accept` 6114 header_params['Accept'] = self.api_client.\ 6115 select_header_accept(['application/json']) 6116 6117 # Authentication setting 6118 auth_settings = [] 6119 6120 return self.api_client.call_api(resource_path, 'GET', 6121 path_params, 6122 query_params, 6123 header_params, 6124 body=body_params, 6125 post_params=form_params, 6126 files=local_var_files, 6127 response_type='EnvelopeAttachmentsResult', 6128 auth_settings=auth_settings, 6129 callback=params.get('callback'), 6130 _return_http_data_only=params.get('_return_http_data_only'), 6131 _preload_content=params.get('_preload_content', True), 6132 _request_timeout=params.get('_request_timeout'), 6133 collection_formats=collection_formats) 6134 6135 def get_chunked_upload(self, account_id, chunked_upload_id, **kwargs): 6136 """ 6137 Retrieves the current metadata of a ChunkedUpload. 6138 Returns the details (but not the content) about a chunked upload. **Note:** You cannot obtain details about a chunked upload that has expired, been deleted, or consumed by other actions. 6139 This method makes a synchronous HTTP request by default. To make an 6140 asynchronous HTTP request, please define a `callback` function 6141 to be invoked when receiving the response. 6142 >>> def callback_function(response): 6143 >>> pprint(response) 6144 >>> 6145 >>> thread = api.get_chunked_upload(account_id, chunked_upload_id, callback=callback_function) 6146 6147 :param callback function: The callback function 6148 for asynchronous request. (optional) 6149 :param str account_id: The external account number (int) or account ID Guid. (required) 6150 :param str chunked_upload_id: (required) 6151 :param str include: 6152 :return: ChunkedUploadResponse 6153 If the method is called asynchronously, 6154 returns the request thread. 6155 """ 6156 kwargs['_return_http_data_only'] = True 6157 if kwargs.get('callback'): 6158 return self.get_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 6159 else: 6160 (data) = self.get_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 6161 return data 6162 6163 def get_chunked_upload_with_http_info(self, account_id, chunked_upload_id, **kwargs): 6164 """ 6165 Retrieves the current metadata of a ChunkedUpload. 6166 Returns the details (but not the content) about a chunked upload. **Note:** You cannot obtain details about a chunked upload that has expired, been deleted, or consumed by other actions. 6167 This method makes a synchronous HTTP request by default. To make an 6168 asynchronous HTTP request, please define a `callback` function 6169 to be invoked when receiving the response. 6170 >>> def callback_function(response): 6171 >>> pprint(response) 6172 >>> 6173 >>> thread = api.get_chunked_upload_with_http_info(account_id, chunked_upload_id, callback=callback_function) 6174 6175 :param callback function: The callback function 6176 for asynchronous request. (optional) 6177 :param str account_id: The external account number (int) or account ID Guid. (required) 6178 :param str chunked_upload_id: (required) 6179 :param str include: 6180 :return: ChunkedUploadResponse 6181 If the method is called asynchronously, 6182 returns the request thread. 6183 """ 6184 6185 all_params = ['account_id', 'chunked_upload_id', 'include'] 6186 all_params.append('callback') 6187 all_params.append('_return_http_data_only') 6188 all_params.append('_preload_content') 6189 all_params.append('_request_timeout') 6190 6191 params = locals() 6192 for key, val in iteritems(params['kwargs']): 6193 if key not in all_params: 6194 raise TypeError( 6195 "Got an unexpected keyword argument '%s'" 6196 " to method get_chunked_upload" % key 6197 ) 6198 params[key] = val 6199 del params['kwargs'] 6200 # verify the required parameter 'account_id' is set 6201 if ('account_id' not in params) or (params['account_id'] is None): 6202 raise ValueError("Missing the required parameter `account_id` when calling `get_chunked_upload`") 6203 # verify the required parameter 'chunked_upload_id' is set 6204 if ('chunked_upload_id' not in params) or (params['chunked_upload_id'] is None): 6205 raise ValueError("Missing the required parameter `chunked_upload_id` when calling `get_chunked_upload`") 6206 6207 6208 collection_formats = {} 6209 6210 resource_path = '/v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}'.replace('{format}', 'json') 6211 path_params = {} 6212 if 'account_id' in params: 6213 path_params['accountId'] = params['account_id'] 6214 if 'chunked_upload_id' in params: 6215 path_params['chunkedUploadId'] = params['chunked_upload_id'] 6216 6217 query_params = {} 6218 if 'include' in params: 6219 query_params['include'] = params['include'] 6220 6221 header_params = {} 6222 6223 form_params = [] 6224 local_var_files = {} 6225 6226 body_params = None 6227 # HTTP header `Accept` 6228 header_params['Accept'] = self.api_client.\ 6229 select_header_accept(['application/json']) 6230 6231 # Authentication setting 6232 auth_settings = [] 6233 6234 return self.api_client.call_api(resource_path, 'GET', 6235 path_params, 6236 query_params, 6237 header_params, 6238 body=body_params, 6239 post_params=form_params, 6240 files=local_var_files, 6241 response_type='ChunkedUploadResponse', 6242 auth_settings=auth_settings, 6243 callback=params.get('callback'), 6244 _return_http_data_only=params.get('_return_http_data_only'), 6245 _preload_content=params.get('_preload_content', True), 6246 _request_timeout=params.get('_request_timeout'), 6247 collection_formats=collection_formats) 6248 6249 def get_comments_transcript(self, account_id, envelope_id, **kwargs): 6250 """ 6251 Gets comment transcript for envelope and user 6252 Retrieves a PDF file containing all of the comments that senders and recipients have added to the documents in an envelope. The response body of this method is the PDF file as a byte stream. **Note:** Comments are disabled by default. To use the comments feature, an account administrator must enable comments on the account (in the `accountSettingsInformation` object, set the `enableSigningExtensionComments` property to **true**). 6253 This method makes a synchronous HTTP request by default. To make an 6254 asynchronous HTTP request, please define a `callback` function 6255 to be invoked when receiving the response. 6256 >>> def callback_function(response): 6257 >>> pprint(response) 6258 >>> 6259 >>> thread = api.get_comments_transcript(account_id, envelope_id, callback=callback_function) 6260 6261 :param callback function: The callback function 6262 for asynchronous request. (optional) 6263 :param str account_id: The external account number (int) or account ID Guid. (required) 6264 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6265 :param str encoding: 6266 :return: file 6267 If the method is called asynchronously, 6268 returns the request thread. 6269 """ 6270 kwargs['_return_http_data_only'] = True 6271 if kwargs.get('callback'): 6272 return self.get_comments_transcript_with_http_info(account_id, envelope_id, **kwargs) 6273 else: 6274 (data) = self.get_comments_transcript_with_http_info(account_id, envelope_id, **kwargs) 6275 return data 6276 6277 def get_comments_transcript_with_http_info(self, account_id, envelope_id, **kwargs): 6278 """ 6279 Gets comment transcript for envelope and user 6280 Retrieves a PDF file containing all of the comments that senders and recipients have added to the documents in an envelope. The response body of this method is the PDF file as a byte stream. **Note:** Comments are disabled by default. To use the comments feature, an account administrator must enable comments on the account (in the `accountSettingsInformation` object, set the `enableSigningExtensionComments` property to **true**). 6281 This method makes a synchronous HTTP request by default. To make an 6282 asynchronous HTTP request, please define a `callback` function 6283 to be invoked when receiving the response. 6284 >>> def callback_function(response): 6285 >>> pprint(response) 6286 >>> 6287 >>> thread = api.get_comments_transcript_with_http_info(account_id, envelope_id, callback=callback_function) 6288 6289 :param callback function: The callback function 6290 for asynchronous request. (optional) 6291 :param str account_id: The external account number (int) or account ID Guid. (required) 6292 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6293 :param str encoding: 6294 :return: file 6295 If the method is called asynchronously, 6296 returns the request thread. 6297 """ 6298 6299 all_params = ['account_id', 'envelope_id', 'encoding'] 6300 all_params.append('callback') 6301 all_params.append('_return_http_data_only') 6302 all_params.append('_preload_content') 6303 all_params.append('_request_timeout') 6304 6305 params = locals() 6306 for key, val in iteritems(params['kwargs']): 6307 if key not in all_params: 6308 raise TypeError( 6309 "Got an unexpected keyword argument '%s'" 6310 " to method get_comments_transcript" % key 6311 ) 6312 params[key] = val 6313 del params['kwargs'] 6314 # verify the required parameter 'account_id' is set 6315 if ('account_id' not in params) or (params['account_id'] is None): 6316 raise ValueError("Missing the required parameter `account_id` when calling `get_comments_transcript`") 6317 # verify the required parameter 'envelope_id' is set 6318 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6319 raise ValueError("Missing the required parameter `envelope_id` when calling `get_comments_transcript`") 6320 6321 6322 collection_formats = {} 6323 6324 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/comments/transcript'.replace('{format}', 'json') 6325 path_params = {} 6326 if 'account_id' in params: 6327 path_params['accountId'] = params['account_id'] 6328 if 'envelope_id' in params: 6329 path_params['envelopeId'] = params['envelope_id'] 6330 6331 query_params = {} 6332 if 'encoding' in params: 6333 query_params['encoding'] = params['encoding'] 6334 6335 header_params = {} 6336 6337 form_params = [] 6338 local_var_files = {} 6339 6340 body_params = None 6341 # HTTP header `Accept` 6342 header_params['Accept'] = self.api_client.\ 6343 select_header_accept(['application/pdf']) 6344 6345 # Authentication setting 6346 auth_settings = [] 6347 6348 return self.api_client.call_api(resource_path, 'GET', 6349 path_params, 6350 query_params, 6351 header_params, 6352 body=body_params, 6353 post_params=form_params, 6354 files=local_var_files, 6355 response_type='file', 6356 auth_settings=auth_settings, 6357 callback=params.get('callback'), 6358 _return_http_data_only=params.get('_return_http_data_only'), 6359 _preload_content=params.get('_preload_content', True), 6360 _request_timeout=params.get('_request_timeout'), 6361 collection_formats=collection_formats) 6362 6363 def get_consumer_disclosure(self, account_id, envelope_id, lang_code, recipient_id, **kwargs): 6364 """ 6365 Reserved: Gets the Electronic Record and Signature Disclosure associated with the account. 6366 Reserved: Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, associated with the account. 6367 This method makes a synchronous HTTP request by default. To make an 6368 asynchronous HTTP request, please define a `callback` function 6369 to be invoked when receiving the response. 6370 >>> def callback_function(response): 6371 >>> pprint(response) 6372 >>> 6373 >>> thread = api.get_consumer_disclosure(account_id, envelope_id, lang_code, recipient_id, callback=callback_function) 6374 6375 :param callback function: The callback function 6376 for asynchronous request. (optional) 6377 :param str account_id: The external account number (int) or account ID Guid. (required) 6378 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6379 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 6380 :param str recipient_id: The ID of the recipient being accessed. (required) 6381 :param str lang_code2: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. 6382 :return: ConsumerDisclosure 6383 If the method is called asynchronously, 6384 returns the request thread. 6385 """ 6386 kwargs['_return_http_data_only'] = True 6387 if kwargs.get('callback'): 6388 return self.get_consumer_disclosure_with_http_info(account_id, envelope_id, lang_code, recipient_id, **kwargs) 6389 else: 6390 (data) = self.get_consumer_disclosure_with_http_info(account_id, envelope_id, lang_code, recipient_id, **kwargs) 6391 return data 6392 6393 def get_consumer_disclosure_with_http_info(self, account_id, envelope_id, lang_code, recipient_id, **kwargs): 6394 """ 6395 Reserved: Gets the Electronic Record and Signature Disclosure associated with the account. 6396 Reserved: Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, associated with the account. 6397 This method makes a synchronous HTTP request by default. To make an 6398 asynchronous HTTP request, please define a `callback` function 6399 to be invoked when receiving the response. 6400 >>> def callback_function(response): 6401 >>> pprint(response) 6402 >>> 6403 >>> thread = api.get_consumer_disclosure_with_http_info(account_id, envelope_id, lang_code, recipient_id, callback=callback_function) 6404 6405 :param callback function: The callback function 6406 for asynchronous request. (optional) 6407 :param str account_id: The external account number (int) or account ID Guid. (required) 6408 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6409 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 6410 :param str recipient_id: The ID of the recipient being accessed. (required) 6411 :param str lang_code2: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. 6412 :return: ConsumerDisclosure 6413 If the method is called asynchronously, 6414 returns the request thread. 6415 """ 6416 6417 all_params = ['account_id', 'envelope_id', 'lang_code', 'recipient_id', 'lang_code2'] 6418 all_params.append('callback') 6419 all_params.append('_return_http_data_only') 6420 all_params.append('_preload_content') 6421 all_params.append('_request_timeout') 6422 6423 params = locals() 6424 for key, val in iteritems(params['kwargs']): 6425 if key not in all_params: 6426 raise TypeError( 6427 "Got an unexpected keyword argument '%s'" 6428 " to method get_consumer_disclosure" % key 6429 ) 6430 params[key] = val 6431 del params['kwargs'] 6432 # verify the required parameter 'account_id' is set 6433 if ('account_id' not in params) or (params['account_id'] is None): 6434 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure`") 6435 # verify the required parameter 'envelope_id' is set 6436 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6437 raise ValueError("Missing the required parameter `envelope_id` when calling `get_consumer_disclosure`") 6438 # verify the required parameter 'lang_code' is set 6439 if ('lang_code' not in params) or (params['lang_code'] is None): 6440 raise ValueError("Missing the required parameter `lang_code` when calling `get_consumer_disclosure`") 6441 # verify the required parameter 'recipient_id' is set 6442 if ('recipient_id' not in params) or (params['recipient_id'] is None): 6443 raise ValueError("Missing the required parameter `recipient_id` when calling `get_consumer_disclosure`") 6444 6445 6446 collection_formats = {} 6447 6448 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 6449 path_params = {} 6450 if 'account_id' in params: 6451 path_params['accountId'] = params['account_id'] 6452 if 'envelope_id' in params: 6453 path_params['envelopeId'] = params['envelope_id'] 6454 if 'lang_code' in params: 6455 path_params['langCode'] = params['lang_code'] 6456 if 'recipient_id' in params: 6457 path_params['recipientId'] = params['recipient_id'] 6458 6459 query_params = {} 6460 if 'lang_code2' in params: 6461 query_params['langCode'] = params['lang_code2'] 6462 6463 header_params = {} 6464 6465 form_params = [] 6466 local_var_files = {} 6467 6468 body_params = None 6469 # HTTP header `Accept` 6470 header_params['Accept'] = self.api_client.\ 6471 select_header_accept(['application/json']) 6472 6473 # Authentication setting 6474 auth_settings = [] 6475 6476 return self.api_client.call_api(resource_path, 'GET', 6477 path_params, 6478 query_params, 6479 header_params, 6480 body=body_params, 6481 post_params=form_params, 6482 files=local_var_files, 6483 response_type='ConsumerDisclosure', 6484 auth_settings=auth_settings, 6485 callback=params.get('callback'), 6486 _return_http_data_only=params.get('_return_http_data_only'), 6487 _preload_content=params.get('_preload_content', True), 6488 _request_timeout=params.get('_request_timeout'), 6489 collection_formats=collection_formats) 6490 6491 def get_consumer_disclosure_default(self, account_id, envelope_id, recipient_id, **kwargs): 6492 """ 6493 Gets the Electronic Record and Signature Disclosure associated with the account. 6494 Retrieves the Electronic Record and Signature Disclosure, with html formatting, associated with the account. You can use an optional query string to set the language for the disclosure. 6495 This method makes a synchronous HTTP request by default. To make an 6496 asynchronous HTTP request, please define a `callback` function 6497 to be invoked when receiving the response. 6498 >>> def callback_function(response): 6499 >>> pprint(response) 6500 >>> 6501 >>> thread = api.get_consumer_disclosure_default(account_id, envelope_id, recipient_id, callback=callback_function) 6502 6503 :param callback function: The callback function 6504 for asynchronous request. (optional) 6505 :param str account_id: The external account number (int) or account ID Guid. (required) 6506 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6507 :param str recipient_id: The ID of the recipient being accessed. (required) 6508 :param str lang_code: 6509 :return: ConsumerDisclosure 6510 If the method is called asynchronously, 6511 returns the request thread. 6512 """ 6513 kwargs['_return_http_data_only'] = True 6514 if kwargs.get('callback'): 6515 return self.get_consumer_disclosure_default_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 6516 else: 6517 (data) = self.get_consumer_disclosure_default_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 6518 return data 6519 6520 def get_consumer_disclosure_default_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 6521 """ 6522 Gets the Electronic Record and Signature Disclosure associated with the account. 6523 Retrieves the Electronic Record and Signature Disclosure, with html formatting, associated with the account. You can use an optional query string to set the language for the disclosure. 6524 This method makes a synchronous HTTP request by default. To make an 6525 asynchronous HTTP request, please define a `callback` function 6526 to be invoked when receiving the response. 6527 >>> def callback_function(response): 6528 >>> pprint(response) 6529 >>> 6530 >>> thread = api.get_consumer_disclosure_default_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 6531 6532 :param callback function: The callback function 6533 for asynchronous request. (optional) 6534 :param str account_id: The external account number (int) or account ID Guid. (required) 6535 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6536 :param str recipient_id: The ID of the recipient being accessed. (required) 6537 :param str lang_code: 6538 :return: ConsumerDisclosure 6539 If the method is called asynchronously, 6540 returns the request thread. 6541 """ 6542 6543 all_params = ['account_id', 'envelope_id', 'recipient_id', 'lang_code'] 6544 all_params.append('callback') 6545 all_params.append('_return_http_data_only') 6546 all_params.append('_preload_content') 6547 all_params.append('_request_timeout') 6548 6549 params = locals() 6550 for key, val in iteritems(params['kwargs']): 6551 if key not in all_params: 6552 raise TypeError( 6553 "Got an unexpected keyword argument '%s'" 6554 " to method get_consumer_disclosure_default" % key 6555 ) 6556 params[key] = val 6557 del params['kwargs'] 6558 # verify the required parameter 'account_id' is set 6559 if ('account_id' not in params) or (params['account_id'] is None): 6560 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure_default`") 6561 # verify the required parameter 'envelope_id' is set 6562 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6563 raise ValueError("Missing the required parameter `envelope_id` when calling `get_consumer_disclosure_default`") 6564 # verify the required parameter 'recipient_id' is set 6565 if ('recipient_id' not in params) or (params['recipient_id'] is None): 6566 raise ValueError("Missing the required parameter `recipient_id` when calling `get_consumer_disclosure_default`") 6567 6568 6569 collection_formats = {} 6570 6571 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/consumer_disclosure'.replace('{format}', 'json') 6572 path_params = {} 6573 if 'account_id' in params: 6574 path_params['accountId'] = params['account_id'] 6575 if 'envelope_id' in params: 6576 path_params['envelopeId'] = params['envelope_id'] 6577 if 'recipient_id' in params: 6578 path_params['recipientId'] = params['recipient_id'] 6579 6580 query_params = {} 6581 if 'lang_code' in params: 6582 query_params['langCode'] = params['lang_code'] 6583 6584 header_params = {} 6585 6586 form_params = [] 6587 local_var_files = {} 6588 6589 body_params = None 6590 # HTTP header `Accept` 6591 header_params['Accept'] = self.api_client.\ 6592 select_header_accept(['application/json']) 6593 6594 # Authentication setting 6595 auth_settings = [] 6596 6597 return self.api_client.call_api(resource_path, 'GET', 6598 path_params, 6599 query_params, 6600 header_params, 6601 body=body_params, 6602 post_params=form_params, 6603 files=local_var_files, 6604 response_type='ConsumerDisclosure', 6605 auth_settings=auth_settings, 6606 callback=params.get('callback'), 6607 _return_http_data_only=params.get('_return_http_data_only'), 6608 _preload_content=params.get('_preload_content', True), 6609 _request_timeout=params.get('_request_timeout'), 6610 collection_formats=collection_formats) 6611 6612 def get_document(self, account_id, document_id, envelope_id, **kwargs): 6613 """ 6614 Gets a document from an envelope. 6615 Retrieves the specified document from the envelope. If the account has the Highlight Data Changes feature enabled, there is an option to request that any changes in the envelope be highlighted. You can also use this method to retrieve a PDF containing the combined content of all documents and the certificate. If the account has the Highlight Data Changes feature enabled, there is an option to request that any changes in the envelope be highlighted. To retrieve the combined content replace the `{documentId}` parameter in the endpoint with `combined`. /accounts/{accountId}/envelopes/{envelopeId}/documents/combined 6616 This method makes a synchronous HTTP request by default. To make an 6617 asynchronous HTTP request, please define a `callback` function 6618 to be invoked when receiving the response. 6619 >>> def callback_function(response): 6620 >>> pprint(response) 6621 >>> 6622 >>> thread = api.get_document(account_id, document_id, envelope_id, callback=callback_function) 6623 6624 :param callback function: The callback function 6625 for asynchronous request. (optional) 6626 :param str account_id: The external account number (int) or account ID Guid. (required) 6627 :param str document_id: The ID of the document being accessed. (required) 6628 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6629 :param str certificate: When set to **false**, the envelope signing certificate is removed from the download. 6630 :param str documents_by_userid: 6631 :param str encoding: 6632 :param str encrypt: When set to **true**, the PDF bytes returned in the response are encrypted for all the key managers configured on your DocuSign account. The documents can be decrypted with the KeyManager Decrypt Document API. 6633 :param str language: Specifies the language for the Certificate of Completion in the response. The supported languages, with the language value shown in parenthesis, are: Chinese Simplified (zh_CN), , Chinese Traditional (zh_TW), Dutch (nl), English US (en), French (fr), German (de), Italian (it), Japanese (ja), Korean (ko), Portuguese (pt), Portuguese (Brazil) (pt_BR), Russian (ru), Spanish (es). 6634 :param str recipient_id: 6635 :param str shared_user_id: 6636 :param str show_changes: When set to **true**, any changed fields for the returned PDF are highlighted in yellow and optional signatures or initials outlined in red. 6637 :param str watermark: When set to **true**, the account has the watermark feature enabled, and the envelope is not complete, the watermark for the account is added to the PDF documents. This option can remove the watermark. 6638 :return: file 6639 If the method is called asynchronously, 6640 returns the request thread. 6641 """ 6642 kwargs['_return_http_data_only'] = True 6643 if kwargs.get('callback'): 6644 return self.get_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 6645 else: 6646 (data) = self.get_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 6647 return data 6648 6649 def get_document_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 6650 """ 6651 Gets a document from an envelope. 6652 Retrieves the specified document from the envelope. If the account has the Highlight Data Changes feature enabled, there is an option to request that any changes in the envelope be highlighted. You can also use this method to retrieve a PDF containing the combined content of all documents and the certificate. If the account has the Highlight Data Changes feature enabled, there is an option to request that any changes in the envelope be highlighted. To retrieve the combined content replace the `{documentId}` parameter in the endpoint with `combined`. /accounts/{accountId}/envelopes/{envelopeId}/documents/combined 6653 This method makes a synchronous HTTP request by default. To make an 6654 asynchronous HTTP request, please define a `callback` function 6655 to be invoked when receiving the response. 6656 >>> def callback_function(response): 6657 >>> pprint(response) 6658 >>> 6659 >>> thread = api.get_document_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 6660 6661 :param callback function: The callback function 6662 for asynchronous request. (optional) 6663 :param str account_id: The external account number (int) or account ID Guid. (required) 6664 :param str document_id: The ID of the document being accessed. (required) 6665 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6666 :param str certificate: When set to **false**, the envelope signing certificate is removed from the download. 6667 :param str documents_by_userid: 6668 :param str encoding: 6669 :param str encrypt: When set to **true**, the PDF bytes returned in the response are encrypted for all the key managers configured on your DocuSign account. The documents can be decrypted with the KeyManager Decrypt Document API. 6670 :param str language: Specifies the language for the Certificate of Completion in the response. The supported languages, with the language value shown in parenthesis, are: Chinese Simplified (zh_CN), , Chinese Traditional (zh_TW), Dutch (nl), English US (en), French (fr), German (de), Italian (it), Japanese (ja), Korean (ko), Portuguese (pt), Portuguese (Brazil) (pt_BR), Russian (ru), Spanish (es). 6671 :param str recipient_id: 6672 :param str shared_user_id: 6673 :param str show_changes: When set to **true**, any changed fields for the returned PDF are highlighted in yellow and optional signatures or initials outlined in red. 6674 :param str watermark: When set to **true**, the account has the watermark feature enabled, and the envelope is not complete, the watermark for the account is added to the PDF documents. This option can remove the watermark. 6675 :return: file 6676 If the method is called asynchronously, 6677 returns the request thread. 6678 """ 6679 6680 all_params = ['account_id', 'document_id', 'envelope_id', 'certificate', 'documents_by_userid', 'encoding', 'encrypt', 'language', 'recipient_id', 'shared_user_id', 'show_changes', 'watermark'] 6681 all_params.append('callback') 6682 all_params.append('_return_http_data_only') 6683 all_params.append('_preload_content') 6684 all_params.append('_request_timeout') 6685 6686 params = locals() 6687 for key, val in iteritems(params['kwargs']): 6688 if key not in all_params: 6689 raise TypeError( 6690 "Got an unexpected keyword argument '%s'" 6691 " to method get_document" % key 6692 ) 6693 params[key] = val 6694 del params['kwargs'] 6695 # verify the required parameter 'account_id' is set 6696 if ('account_id' not in params) or (params['account_id'] is None): 6697 raise ValueError("Missing the required parameter `account_id` when calling `get_document`") 6698 # verify the required parameter 'document_id' is set 6699 if ('document_id' not in params) or (params['document_id'] is None): 6700 raise ValueError("Missing the required parameter `document_id` when calling `get_document`") 6701 # verify the required parameter 'envelope_id' is set 6702 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6703 raise ValueError("Missing the required parameter `envelope_id` when calling `get_document`") 6704 6705 6706 collection_formats = {} 6707 6708 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}'.replace('{format}', 'json') 6709 path_params = {} 6710 if 'account_id' in params: 6711 path_params['accountId'] = params['account_id'] 6712 if 'document_id' in params: 6713 path_params['documentId'] = params['document_id'] 6714 if 'envelope_id' in params: 6715 path_params['envelopeId'] = params['envelope_id'] 6716 6717 query_params = {} 6718 if 'certificate' in params: 6719 query_params['certificate'] = params['certificate'] 6720 if 'documents_by_userid' in params: 6721 query_params['documents_by_userid'] = params['documents_by_userid'] 6722 if 'encoding' in params: 6723 query_params['encoding'] = params['encoding'] 6724 if 'encrypt' in params: 6725 query_params['encrypt'] = params['encrypt'] 6726 if 'language' in params: 6727 query_params['language'] = params['language'] 6728 if 'recipient_id' in params: 6729 query_params['recipient_id'] = params['recipient_id'] 6730 if 'shared_user_id' in params: 6731 query_params['shared_user_id'] = params['shared_user_id'] 6732 if 'show_changes' in params: 6733 query_params['show_changes'] = params['show_changes'] 6734 if 'watermark' in params: 6735 query_params['watermark'] = params['watermark'] 6736 6737 header_params = {} 6738 6739 form_params = [] 6740 local_var_files = {} 6741 6742 body_params = None 6743 # HTTP header `Accept` 6744 header_params['Accept'] = self.api_client.\ 6745 select_header_accept(['application/pdf']) 6746 6747 # Authentication setting 6748 auth_settings = [] 6749 6750 return self.api_client.call_api(resource_path, 'GET', 6751 path_params, 6752 query_params, 6753 header_params, 6754 body=body_params, 6755 post_params=form_params, 6756 files=local_var_files, 6757 response_type='file', 6758 auth_settings=auth_settings, 6759 callback=params.get('callback'), 6760 _return_http_data_only=params.get('_return_http_data_only'), 6761 _preload_content=params.get('_preload_content', True), 6762 _request_timeout=params.get('_request_timeout'), 6763 collection_formats=collection_formats) 6764 6765 def get_document_page_image(self, account_id, document_id, envelope_id, page_number, **kwargs): 6766 """ 6767 Gets a page image from an envelope for display. 6768 Retrieves a page image for display from the specified envelope. 6769 This method makes a synchronous HTTP request by default. To make an 6770 asynchronous HTTP request, please define a `callback` function 6771 to be invoked when receiving the response. 6772 >>> def callback_function(response): 6773 >>> pprint(response) 6774 >>> 6775 >>> thread = api.get_document_page_image(account_id, document_id, envelope_id, page_number, callback=callback_function) 6776 6777 :param callback function: The callback function 6778 for asynchronous request. (optional) 6779 :param str account_id: The external account number (int) or account ID Guid. (required) 6780 :param str document_id: The ID of the document being accessed. (required) 6781 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6782 :param str page_number: The page number being accessed. (required) 6783 :param str dpi: Sets the dpi for the image. 6784 :param str max_height: Sets the maximum height for the page image in pixels. The dpi is recalculated based on this setting. 6785 :param str max_width: Sets the maximum width for the page image in pixels. The dpi is recalculated based on this setting. 6786 :param str show_changes: 6787 :return: file 6788 If the method is called asynchronously, 6789 returns the request thread. 6790 """ 6791 kwargs['_return_http_data_only'] = True 6792 if kwargs.get('callback'): 6793 return self.get_document_page_image_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 6794 else: 6795 (data) = self.get_document_page_image_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 6796 return data 6797 6798 def get_document_page_image_with_http_info(self, account_id, document_id, envelope_id, page_number, **kwargs): 6799 """ 6800 Gets a page image from an envelope for display. 6801 Retrieves a page image for display from the specified envelope. 6802 This method makes a synchronous HTTP request by default. To make an 6803 asynchronous HTTP request, please define a `callback` function 6804 to be invoked when receiving the response. 6805 >>> def callback_function(response): 6806 >>> pprint(response) 6807 >>> 6808 >>> thread = api.get_document_page_image_with_http_info(account_id, document_id, envelope_id, page_number, callback=callback_function) 6809 6810 :param callback function: The callback function 6811 for asynchronous request. (optional) 6812 :param str account_id: The external account number (int) or account ID Guid. (required) 6813 :param str document_id: The ID of the document being accessed. (required) 6814 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6815 :param str page_number: The page number being accessed. (required) 6816 :param str dpi: Sets the dpi for the image. 6817 :param str max_height: Sets the maximum height for the page image in pixels. The dpi is recalculated based on this setting. 6818 :param str max_width: Sets the maximum width for the page image in pixels. The dpi is recalculated based on this setting. 6819 :param str show_changes: 6820 :return: file 6821 If the method is called asynchronously, 6822 returns the request thread. 6823 """ 6824 6825 all_params = ['account_id', 'document_id', 'envelope_id', 'page_number', 'dpi', 'max_height', 'max_width', 'show_changes'] 6826 all_params.append('callback') 6827 all_params.append('_return_http_data_only') 6828 all_params.append('_preload_content') 6829 all_params.append('_request_timeout') 6830 6831 params = locals() 6832 for key, val in iteritems(params['kwargs']): 6833 if key not in all_params: 6834 raise TypeError( 6835 "Got an unexpected keyword argument '%s'" 6836 " to method get_document_page_image" % key 6837 ) 6838 params[key] = val 6839 del params['kwargs'] 6840 # verify the required parameter 'account_id' is set 6841 if ('account_id' not in params) or (params['account_id'] is None): 6842 raise ValueError("Missing the required parameter `account_id` when calling `get_document_page_image`") 6843 # verify the required parameter 'document_id' is set 6844 if ('document_id' not in params) or (params['document_id'] is None): 6845 raise ValueError("Missing the required parameter `document_id` when calling `get_document_page_image`") 6846 # verify the required parameter 'envelope_id' is set 6847 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6848 raise ValueError("Missing the required parameter `envelope_id` when calling `get_document_page_image`") 6849 # verify the required parameter 'page_number' is set 6850 if ('page_number' not in params) or (params['page_number'] is None): 6851 raise ValueError("Missing the required parameter `page_number` when calling `get_document_page_image`") 6852 6853 6854 collection_formats = {} 6855 6856 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/pages/{pageNumber}/page_image'.replace('{format}', 'json') 6857 path_params = {} 6858 if 'account_id' in params: 6859 path_params['accountId'] = params['account_id'] 6860 if 'document_id' in params: 6861 path_params['documentId'] = params['document_id'] 6862 if 'envelope_id' in params: 6863 path_params['envelopeId'] = params['envelope_id'] 6864 if 'page_number' in params: 6865 path_params['pageNumber'] = params['page_number'] 6866 6867 query_params = {} 6868 if 'dpi' in params: 6869 query_params['dpi'] = params['dpi'] 6870 if 'max_height' in params: 6871 query_params['max_height'] = params['max_height'] 6872 if 'max_width' in params: 6873 query_params['max_width'] = params['max_width'] 6874 if 'show_changes' in params: 6875 query_params['show_changes'] = params['show_changes'] 6876 6877 header_params = {} 6878 6879 form_params = [] 6880 local_var_files = {} 6881 6882 body_params = None 6883 # HTTP header `Accept` 6884 header_params['Accept'] = self.api_client.\ 6885 select_header_accept(['image/png']) 6886 6887 # Authentication setting 6888 auth_settings = [] 6889 6890 return self.api_client.call_api(resource_path, 'GET', 6891 path_params, 6892 query_params, 6893 header_params, 6894 body=body_params, 6895 post_params=form_params, 6896 files=local_var_files, 6897 response_type='file', 6898 auth_settings=auth_settings, 6899 callback=params.get('callback'), 6900 _return_http_data_only=params.get('_return_http_data_only'), 6901 _preload_content=params.get('_preload_content', True), 6902 _request_timeout=params.get('_request_timeout'), 6903 collection_formats=collection_formats) 6904 6905 def get_document_tabs(self, account_id, document_id, envelope_id, **kwargs): 6906 """ 6907 Returns tabs on the document. 6908 Returns the tabs on the document specified by `documentId` in the envelope specified by `envelopeId`. 6909 This method makes a synchronous HTTP request by default. To make an 6910 asynchronous HTTP request, please define a `callback` function 6911 to be invoked when receiving the response. 6912 >>> def callback_function(response): 6913 >>> pprint(response) 6914 >>> 6915 >>> thread = api.get_document_tabs(account_id, document_id, envelope_id, callback=callback_function) 6916 6917 :param callback function: The callback function 6918 for asynchronous request. (optional) 6919 :param str account_id: The external account number (int) or account ID Guid. (required) 6920 :param str document_id: The ID of the document being accessed. (required) 6921 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6922 :param str include_metadata: 6923 :param str page_numbers: 6924 :return: Tabs 6925 If the method is called asynchronously, 6926 returns the request thread. 6927 """ 6928 kwargs['_return_http_data_only'] = True 6929 if kwargs.get('callback'): 6930 return self.get_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 6931 else: 6932 (data) = self.get_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 6933 return data 6934 6935 def get_document_tabs_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 6936 """ 6937 Returns tabs on the document. 6938 Returns the tabs on the document specified by `documentId` in the envelope specified by `envelopeId`. 6939 This method makes a synchronous HTTP request by default. To make an 6940 asynchronous HTTP request, please define a `callback` function 6941 to be invoked when receiving the response. 6942 >>> def callback_function(response): 6943 >>> pprint(response) 6944 >>> 6945 >>> thread = api.get_document_tabs_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 6946 6947 :param callback function: The callback function 6948 for asynchronous request. (optional) 6949 :param str account_id: The external account number (int) or account ID Guid. (required) 6950 :param str document_id: The ID of the document being accessed. (required) 6951 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6952 :param str include_metadata: 6953 :param str page_numbers: 6954 :return: Tabs 6955 If the method is called asynchronously, 6956 returns the request thread. 6957 """ 6958 6959 all_params = ['account_id', 'document_id', 'envelope_id', 'include_metadata', 'page_numbers'] 6960 all_params.append('callback') 6961 all_params.append('_return_http_data_only') 6962 all_params.append('_preload_content') 6963 all_params.append('_request_timeout') 6964 6965 params = locals() 6966 for key, val in iteritems(params['kwargs']): 6967 if key not in all_params: 6968 raise TypeError( 6969 "Got an unexpected keyword argument '%s'" 6970 " to method get_document_tabs" % key 6971 ) 6972 params[key] = val 6973 del params['kwargs'] 6974 # verify the required parameter 'account_id' is set 6975 if ('account_id' not in params) or (params['account_id'] is None): 6976 raise ValueError("Missing the required parameter `account_id` when calling `get_document_tabs`") 6977 # verify the required parameter 'document_id' is set 6978 if ('document_id' not in params) or (params['document_id'] is None): 6979 raise ValueError("Missing the required parameter `document_id` when calling `get_document_tabs`") 6980 # verify the required parameter 'envelope_id' is set 6981 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6982 raise ValueError("Missing the required parameter `envelope_id` when calling `get_document_tabs`") 6983 6984 6985 collection_formats = {} 6986 6987 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/tabs'.replace('{format}', 'json') 6988 path_params = {} 6989 if 'account_id' in params: 6990 path_params['accountId'] = params['account_id'] 6991 if 'document_id' in params: 6992 path_params['documentId'] = params['document_id'] 6993 if 'envelope_id' in params: 6994 path_params['envelopeId'] = params['envelope_id'] 6995 6996 query_params = {} 6997 if 'include_metadata' in params: 6998 query_params['include_metadata'] = params['include_metadata'] 6999 if 'page_numbers' in params: 7000 query_params['page_numbers'] = params['page_numbers'] 7001 7002 header_params = {} 7003 7004 form_params = [] 7005 local_var_files = {} 7006 7007 body_params = None 7008 # HTTP header `Accept` 7009 header_params['Accept'] = self.api_client.\ 7010 select_header_accept(['application/json']) 7011 7012 # Authentication setting 7013 auth_settings = [] 7014 7015 return self.api_client.call_api(resource_path, 'GET', 7016 path_params, 7017 query_params, 7018 header_params, 7019 body=body_params, 7020 post_params=form_params, 7021 files=local_var_files, 7022 response_type='Tabs', 7023 auth_settings=auth_settings, 7024 callback=params.get('callback'), 7025 _return_http_data_only=params.get('_return_http_data_only'), 7026 _preload_content=params.get('_preload_content', True), 7027 _request_timeout=params.get('_request_timeout'), 7028 collection_formats=collection_formats) 7029 7030 def get_email_settings(self, account_id, envelope_id, **kwargs): 7031 """ 7032 Gets the email setting overrides for an envelope. 7033 Retrieves the email override settings for the specified envelope. 7034 This method makes a synchronous HTTP request by default. To make an 7035 asynchronous HTTP request, please define a `callback` function 7036 to be invoked when receiving the response. 7037 >>> def callback_function(response): 7038 >>> pprint(response) 7039 >>> 7040 >>> thread = api.get_email_settings(account_id, envelope_id, callback=callback_function) 7041 7042 :param callback function: The callback function 7043 for asynchronous request. (optional) 7044 :param str account_id: The external account number (int) or account ID Guid. (required) 7045 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7046 :return: EmailSettings 7047 If the method is called asynchronously, 7048 returns the request thread. 7049 """ 7050 kwargs['_return_http_data_only'] = True 7051 if kwargs.get('callback'): 7052 return self.get_email_settings_with_http_info(account_id, envelope_id, **kwargs) 7053 else: 7054 (data) = self.get_email_settings_with_http_info(account_id, envelope_id, **kwargs) 7055 return data 7056 7057 def get_email_settings_with_http_info(self, account_id, envelope_id, **kwargs): 7058 """ 7059 Gets the email setting overrides for an envelope. 7060 Retrieves the email override settings for the specified envelope. 7061 This method makes a synchronous HTTP request by default. To make an 7062 asynchronous HTTP request, please define a `callback` function 7063 to be invoked when receiving the response. 7064 >>> def callback_function(response): 7065 >>> pprint(response) 7066 >>> 7067 >>> thread = api.get_email_settings_with_http_info(account_id, envelope_id, callback=callback_function) 7068 7069 :param callback function: The callback function 7070 for asynchronous request. (optional) 7071 :param str account_id: The external account number (int) or account ID Guid. (required) 7072 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7073 :return: EmailSettings 7074 If the method is called asynchronously, 7075 returns the request thread. 7076 """ 7077 7078 all_params = ['account_id', 'envelope_id'] 7079 all_params.append('callback') 7080 all_params.append('_return_http_data_only') 7081 all_params.append('_preload_content') 7082 all_params.append('_request_timeout') 7083 7084 params = locals() 7085 for key, val in iteritems(params['kwargs']): 7086 if key not in all_params: 7087 raise TypeError( 7088 "Got an unexpected keyword argument '%s'" 7089 " to method get_email_settings" % key 7090 ) 7091 params[key] = val 7092 del params['kwargs'] 7093 # verify the required parameter 'account_id' is set 7094 if ('account_id' not in params) or (params['account_id'] is None): 7095 raise ValueError("Missing the required parameter `account_id` when calling `get_email_settings`") 7096 # verify the required parameter 'envelope_id' is set 7097 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7098 raise ValueError("Missing the required parameter `envelope_id` when calling `get_email_settings`") 7099 7100 7101 collection_formats = {} 7102 7103 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/email_settings'.replace('{format}', 'json') 7104 path_params = {} 7105 if 'account_id' in params: 7106 path_params['accountId'] = params['account_id'] 7107 if 'envelope_id' in params: 7108 path_params['envelopeId'] = params['envelope_id'] 7109 7110 query_params = {} 7111 7112 header_params = {} 7113 7114 form_params = [] 7115 local_var_files = {} 7116 7117 body_params = None 7118 # HTTP header `Accept` 7119 header_params['Accept'] = self.api_client.\ 7120 select_header_accept(['application/json']) 7121 7122 # Authentication setting 7123 auth_settings = [] 7124 7125 return self.api_client.call_api(resource_path, 'GET', 7126 path_params, 7127 query_params, 7128 header_params, 7129 body=body_params, 7130 post_params=form_params, 7131 files=local_var_files, 7132 response_type='EmailSettings', 7133 auth_settings=auth_settings, 7134 callback=params.get('callback'), 7135 _return_http_data_only=params.get('_return_http_data_only'), 7136 _preload_content=params.get('_preload_content', True), 7137 _request_timeout=params.get('_request_timeout'), 7138 collection_formats=collection_formats) 7139 7140 def get_envelope(self, account_id, envelope_id, **kwargs): 7141 """ 7142 Gets the status of a envelope. 7143 Retrieves the overall status for the specified envelope. 7144 This method makes a synchronous HTTP request by default. To make an 7145 asynchronous HTTP request, please define a `callback` function 7146 to be invoked when receiving the response. 7147 >>> def callback_function(response): 7148 >>> pprint(response) 7149 >>> 7150 >>> thread = api.get_envelope(account_id, envelope_id, callback=callback_function) 7151 7152 :param callback function: The callback function 7153 for asynchronous request. (optional) 7154 :param str account_id: The external account number (int) or account ID Guid. (required) 7155 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7156 :param str advanced_update: When true, envelope information can be added or modified. 7157 :param str include: 7158 :param str include_anchor_tab_locations: 7159 :return: Envelope 7160 If the method is called asynchronously, 7161 returns the request thread. 7162 """ 7163 kwargs['_return_http_data_only'] = True 7164 if kwargs.get('callback'): 7165 return self.get_envelope_with_http_info(account_id, envelope_id, **kwargs) 7166 else: 7167 (data) = self.get_envelope_with_http_info(account_id, envelope_id, **kwargs) 7168 return data 7169 7170 def get_envelope_with_http_info(self, account_id, envelope_id, **kwargs): 7171 """ 7172 Gets the status of a envelope. 7173 Retrieves the overall status for the specified envelope. 7174 This method makes a synchronous HTTP request by default. To make an 7175 asynchronous HTTP request, please define a `callback` function 7176 to be invoked when receiving the response. 7177 >>> def callback_function(response): 7178 >>> pprint(response) 7179 >>> 7180 >>> thread = api.get_envelope_with_http_info(account_id, envelope_id, callback=callback_function) 7181 7182 :param callback function: The callback function 7183 for asynchronous request. (optional) 7184 :param str account_id: The external account number (int) or account ID Guid. (required) 7185 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7186 :param str advanced_update: When true, envelope information can be added or modified. 7187 :param str include: 7188 :param str include_anchor_tab_locations: 7189 :return: Envelope 7190 If the method is called asynchronously, 7191 returns the request thread. 7192 """ 7193 7194 all_params = ['account_id', 'envelope_id', 'advanced_update', 'include', 'include_anchor_tab_locations'] 7195 all_params.append('callback') 7196 all_params.append('_return_http_data_only') 7197 all_params.append('_preload_content') 7198 all_params.append('_request_timeout') 7199 7200 params = locals() 7201 for key, val in iteritems(params['kwargs']): 7202 if key not in all_params: 7203 raise TypeError( 7204 "Got an unexpected keyword argument '%s'" 7205 " to method get_envelope" % key 7206 ) 7207 params[key] = val 7208 del params['kwargs'] 7209 # verify the required parameter 'account_id' is set 7210 if ('account_id' not in params) or (params['account_id'] is None): 7211 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope`") 7212 # verify the required parameter 'envelope_id' is set 7213 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7214 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope`") 7215 7216 7217 collection_formats = {} 7218 7219 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}'.replace('{format}', 'json') 7220 path_params = {} 7221 if 'account_id' in params: 7222 path_params['accountId'] = params['account_id'] 7223 if 'envelope_id' in params: 7224 path_params['envelopeId'] = params['envelope_id'] 7225 7226 query_params = {} 7227 if 'advanced_update' in params: 7228 query_params['advanced_update'] = params['advanced_update'] 7229 if 'include' in params: 7230 query_params['include'] = params['include'] 7231 if 'include_anchor_tab_locations' in params: 7232 query_params['include_anchor_tab_locations'] = params['include_anchor_tab_locations'] 7233 7234 header_params = {} 7235 7236 form_params = [] 7237 local_var_files = {} 7238 7239 body_params = None 7240 # HTTP header `Accept` 7241 header_params['Accept'] = self.api_client.\ 7242 select_header_accept(['application/json']) 7243 7244 # Authentication setting 7245 auth_settings = [] 7246 7247 return self.api_client.call_api(resource_path, 'GET', 7248 path_params, 7249 query_params, 7250 header_params, 7251 body=body_params, 7252 post_params=form_params, 7253 files=local_var_files, 7254 response_type='Envelope', 7255 auth_settings=auth_settings, 7256 callback=params.get('callback'), 7257 _return_http_data_only=params.get('_return_http_data_only'), 7258 _preload_content=params.get('_preload_content', True), 7259 _request_timeout=params.get('_request_timeout'), 7260 collection_formats=collection_formats) 7261 7262 def get_envelope_delayed_routing_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 7263 """ 7264 Returns the delayed routing rules for an envelope's workflow step definition. 7265 This method makes a synchronous HTTP request by default. To make an 7266 asynchronous HTTP request, please define a `callback` function 7267 to be invoked when receiving the response. 7268 >>> def callback_function(response): 7269 >>> pprint(response) 7270 >>> 7271 >>> thread = api.get_envelope_delayed_routing_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 7272 7273 :param callback function: The callback function 7274 for asynchronous request. (optional) 7275 :param str account_id: The external account number (int) or account ID Guid. (required) 7276 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7277 :param str workflow_step_id: (required) 7278 :return: DelayedRouting 7279 If the method is called asynchronously, 7280 returns the request thread. 7281 """ 7282 kwargs['_return_http_data_only'] = True 7283 if kwargs.get('callback'): 7284 return self.get_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 7285 else: 7286 (data) = self.get_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 7287 return data 7288 7289 def get_envelope_delayed_routing_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 7290 """ 7291 Returns the delayed routing rules for an envelope's workflow step definition. 7292 This method makes a synchronous HTTP request by default. To make an 7293 asynchronous HTTP request, please define a `callback` function 7294 to be invoked when receiving the response. 7295 >>> def callback_function(response): 7296 >>> pprint(response) 7297 >>> 7298 >>> thread = api.get_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 7299 7300 :param callback function: The callback function 7301 for asynchronous request. (optional) 7302 :param str account_id: The external account number (int) or account ID Guid. (required) 7303 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7304 :param str workflow_step_id: (required) 7305 :return: DelayedRouting 7306 If the method is called asynchronously, 7307 returns the request thread. 7308 """ 7309 7310 all_params = ['account_id', 'envelope_id', 'workflow_step_id'] 7311 all_params.append('callback') 7312 all_params.append('_return_http_data_only') 7313 all_params.append('_preload_content') 7314 all_params.append('_request_timeout') 7315 7316 params = locals() 7317 for key, val in iteritems(params['kwargs']): 7318 if key not in all_params: 7319 raise TypeError( 7320 "Got an unexpected keyword argument '%s'" 7321 " to method get_envelope_delayed_routing_definition" % key 7322 ) 7323 params[key] = val 7324 del params['kwargs'] 7325 # verify the required parameter 'account_id' is set 7326 if ('account_id' not in params) or (params['account_id'] is None): 7327 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_delayed_routing_definition`") 7328 # verify the required parameter 'envelope_id' is set 7329 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7330 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_delayed_routing_definition`") 7331 # verify the required parameter 'workflow_step_id' is set 7332 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 7333 raise ValueError("Missing the required parameter `workflow_step_id` when calling `get_envelope_delayed_routing_definition`") 7334 7335 7336 collection_formats = {} 7337 7338 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 7339 path_params = {} 7340 if 'account_id' in params: 7341 path_params['accountId'] = params['account_id'] 7342 if 'envelope_id' in params: 7343 path_params['envelopeId'] = params['envelope_id'] 7344 if 'workflow_step_id' in params: 7345 path_params['workflowStepId'] = params['workflow_step_id'] 7346 7347 query_params = {} 7348 7349 header_params = {} 7350 7351 form_params = [] 7352 local_var_files = {} 7353 7354 body_params = None 7355 # HTTP header `Accept` 7356 header_params['Accept'] = self.api_client.\ 7357 select_header_accept(['application/json']) 7358 7359 # Authentication setting 7360 auth_settings = [] 7361 7362 return self.api_client.call_api(resource_path, 'GET', 7363 path_params, 7364 query_params, 7365 header_params, 7366 body=body_params, 7367 post_params=form_params, 7368 files=local_var_files, 7369 response_type='DelayedRouting', 7370 auth_settings=auth_settings, 7371 callback=params.get('callback'), 7372 _return_http_data_only=params.get('_return_http_data_only'), 7373 _preload_content=params.get('_preload_content', True), 7374 _request_timeout=params.get('_request_timeout'), 7375 collection_formats=collection_formats) 7376 7377 def get_envelope_doc_gen_form_fields(self, account_id, envelope_id, **kwargs): 7378 """ 7379 Returns formfields for an envelope 7380 This method makes a synchronous HTTP request by default. To make an 7381 asynchronous HTTP request, please define a `callback` function 7382 to be invoked when receiving the response. 7383 >>> def callback_function(response): 7384 >>> pprint(response) 7385 >>> 7386 >>> thread = api.get_envelope_doc_gen_form_fields(account_id, envelope_id, callback=callback_function) 7387 7388 :param callback function: The callback function 7389 for asynchronous request. (optional) 7390 :param str account_id: The external account number (int) or account ID Guid. (required) 7391 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7392 :return: DocGenFormFieldResponse 7393 If the method is called asynchronously, 7394 returns the request thread. 7395 """ 7396 kwargs['_return_http_data_only'] = True 7397 if kwargs.get('callback'): 7398 return self.get_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, **kwargs) 7399 else: 7400 (data) = self.get_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, **kwargs) 7401 return data 7402 7403 def get_envelope_doc_gen_form_fields_with_http_info(self, account_id, envelope_id, **kwargs): 7404 """ 7405 Returns formfields for an envelope 7406 This method makes a synchronous HTTP request by default. To make an 7407 asynchronous HTTP request, please define a `callback` function 7408 to be invoked when receiving the response. 7409 >>> def callback_function(response): 7410 >>> pprint(response) 7411 >>> 7412 >>> thread = api.get_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, callback=callback_function) 7413 7414 :param callback function: The callback function 7415 for asynchronous request. (optional) 7416 :param str account_id: The external account number (int) or account ID Guid. (required) 7417 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7418 :return: DocGenFormFieldResponse 7419 If the method is called asynchronously, 7420 returns the request thread. 7421 """ 7422 7423 all_params = ['account_id', 'envelope_id'] 7424 all_params.append('callback') 7425 all_params.append('_return_http_data_only') 7426 all_params.append('_preload_content') 7427 all_params.append('_request_timeout') 7428 7429 params = locals() 7430 for key, val in iteritems(params['kwargs']): 7431 if key not in all_params: 7432 raise TypeError( 7433 "Got an unexpected keyword argument '%s'" 7434 " to method get_envelope_doc_gen_form_fields" % key 7435 ) 7436 params[key] = val 7437 del params['kwargs'] 7438 # verify the required parameter 'account_id' is set 7439 if ('account_id' not in params) or (params['account_id'] is None): 7440 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_doc_gen_form_fields`") 7441 # verify the required parameter 'envelope_id' is set 7442 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7443 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_doc_gen_form_fields`") 7444 7445 7446 collection_formats = {} 7447 7448 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/docGenFormFields'.replace('{format}', 'json') 7449 path_params = {} 7450 if 'account_id' in params: 7451 path_params['accountId'] = params['account_id'] 7452 if 'envelope_id' in params: 7453 path_params['envelopeId'] = params['envelope_id'] 7454 7455 query_params = {} 7456 7457 header_params = {} 7458 7459 form_params = [] 7460 local_var_files = {} 7461 7462 body_params = None 7463 # HTTP header `Accept` 7464 header_params['Accept'] = self.api_client.\ 7465 select_header_accept(['application/json']) 7466 7467 # Authentication setting 7468 auth_settings = [] 7469 7470 return self.api_client.call_api(resource_path, 'GET', 7471 path_params, 7472 query_params, 7473 header_params, 7474 body=body_params, 7475 post_params=form_params, 7476 files=local_var_files, 7477 response_type='DocGenFormFieldResponse', 7478 auth_settings=auth_settings, 7479 callback=params.get('callback'), 7480 _return_http_data_only=params.get('_return_http_data_only'), 7481 _preload_content=params.get('_preload_content', True), 7482 _request_timeout=params.get('_request_timeout'), 7483 collection_formats=collection_formats) 7484 7485 def get_envelope_document_html_definitions(self, account_id, document_id, envelope_id, **kwargs): 7486 """ 7487 Get the Original HTML Definition used to generate the Responsive HTML for a given document. 7488 7489 This method makes a synchronous HTTP request by default. To make an 7490 asynchronous HTTP request, please define a `callback` function 7491 to be invoked when receiving the response. 7492 >>> def callback_function(response): 7493 >>> pprint(response) 7494 >>> 7495 >>> thread = api.get_envelope_document_html_definitions(account_id, document_id, envelope_id, callback=callback_function) 7496 7497 :param callback function: The callback function 7498 for asynchronous request. (optional) 7499 :param str account_id: The external account number (int) or account ID Guid. (required) 7500 :param str document_id: The ID of the document being accessed. (required) 7501 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7502 :return: DocumentHtmlDefinitionOriginals 7503 If the method is called asynchronously, 7504 returns the request thread. 7505 """ 7506 kwargs['_return_http_data_only'] = True 7507 if kwargs.get('callback'): 7508 return self.get_envelope_document_html_definitions_with_http_info(account_id, document_id, envelope_id, **kwargs) 7509 else: 7510 (data) = self.get_envelope_document_html_definitions_with_http_info(account_id, document_id, envelope_id, **kwargs) 7511 return data 7512 7513 def get_envelope_document_html_definitions_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 7514 """ 7515 Get the Original HTML Definition used to generate the Responsive HTML for a given document. 7516 7517 This method makes a synchronous HTTP request by default. To make an 7518 asynchronous HTTP request, please define a `callback` function 7519 to be invoked when receiving the response. 7520 >>> def callback_function(response): 7521 >>> pprint(response) 7522 >>> 7523 >>> thread = api.get_envelope_document_html_definitions_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 7524 7525 :param callback function: The callback function 7526 for asynchronous request. (optional) 7527 :param str account_id: The external account number (int) or account ID Guid. (required) 7528 :param str document_id: The ID of the document being accessed. (required) 7529 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7530 :return: DocumentHtmlDefinitionOriginals 7531 If the method is called asynchronously, 7532 returns the request thread. 7533 """ 7534 7535 all_params = ['account_id', 'document_id', 'envelope_id'] 7536 all_params.append('callback') 7537 all_params.append('_return_http_data_only') 7538 all_params.append('_preload_content') 7539 all_params.append('_request_timeout') 7540 7541 params = locals() 7542 for key, val in iteritems(params['kwargs']): 7543 if key not in all_params: 7544 raise TypeError( 7545 "Got an unexpected keyword argument '%s'" 7546 " to method get_envelope_document_html_definitions" % key 7547 ) 7548 params[key] = val 7549 del params['kwargs'] 7550 # verify the required parameter 'account_id' is set 7551 if ('account_id' not in params) or (params['account_id'] is None): 7552 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_document_html_definitions`") 7553 # verify the required parameter 'document_id' is set 7554 if ('document_id' not in params) or (params['document_id'] is None): 7555 raise ValueError("Missing the required parameter `document_id` when calling `get_envelope_document_html_definitions`") 7556 # verify the required parameter 'envelope_id' is set 7557 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7558 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_document_html_definitions`") 7559 7560 7561 collection_formats = {} 7562 7563 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/html_definitions'.replace('{format}', 'json') 7564 path_params = {} 7565 if 'account_id' in params: 7566 path_params['accountId'] = params['account_id'] 7567 if 'document_id' in params: 7568 path_params['documentId'] = params['document_id'] 7569 if 'envelope_id' in params: 7570 path_params['envelopeId'] = params['envelope_id'] 7571 7572 query_params = {} 7573 7574 header_params = {} 7575 7576 form_params = [] 7577 local_var_files = {} 7578 7579 body_params = None 7580 # HTTP header `Accept` 7581 header_params['Accept'] = self.api_client.\ 7582 select_header_accept(['application/json']) 7583 7584 # Authentication setting 7585 auth_settings = [] 7586 7587 return self.api_client.call_api(resource_path, 'GET', 7588 path_params, 7589 query_params, 7590 header_params, 7591 body=body_params, 7592 post_params=form_params, 7593 files=local_var_files, 7594 response_type='DocumentHtmlDefinitionOriginals', 7595 auth_settings=auth_settings, 7596 callback=params.get('callback'), 7597 _return_http_data_only=params.get('_return_http_data_only'), 7598 _preload_content=params.get('_preload_content', True), 7599 _request_timeout=params.get('_request_timeout'), 7600 collection_formats=collection_formats) 7601 7602 def get_envelope_html_definitions(self, account_id, envelope_id, **kwargs): 7603 """ 7604 Get the Original HTML Definition used to generate the Responsive HTML for the envelope. 7605 7606 This method makes a synchronous HTTP request by default. To make an 7607 asynchronous HTTP request, please define a `callback` function 7608 to be invoked when receiving the response. 7609 >>> def callback_function(response): 7610 >>> pprint(response) 7611 >>> 7612 >>> thread = api.get_envelope_html_definitions(account_id, envelope_id, callback=callback_function) 7613 7614 :param callback function: The callback function 7615 for asynchronous request. (optional) 7616 :param str account_id: The external account number (int) or account ID Guid. (required) 7617 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7618 :return: DocumentHtmlDefinitionOriginals 7619 If the method is called asynchronously, 7620 returns the request thread. 7621 """ 7622 kwargs['_return_http_data_only'] = True 7623 if kwargs.get('callback'): 7624 return self.get_envelope_html_definitions_with_http_info(account_id, envelope_id, **kwargs) 7625 else: 7626 (data) = self.get_envelope_html_definitions_with_http_info(account_id, envelope_id, **kwargs) 7627 return data 7628 7629 def get_envelope_html_definitions_with_http_info(self, account_id, envelope_id, **kwargs): 7630 """ 7631 Get the Original HTML Definition used to generate the Responsive HTML for the envelope. 7632 7633 This method makes a synchronous HTTP request by default. To make an 7634 asynchronous HTTP request, please define a `callback` function 7635 to be invoked when receiving the response. 7636 >>> def callback_function(response): 7637 >>> pprint(response) 7638 >>> 7639 >>> thread = api.get_envelope_html_definitions_with_http_info(account_id, envelope_id, callback=callback_function) 7640 7641 :param callback function: The callback function 7642 for asynchronous request. (optional) 7643 :param str account_id: The external account number (int) or account ID Guid. (required) 7644 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7645 :return: DocumentHtmlDefinitionOriginals 7646 If the method is called asynchronously, 7647 returns the request thread. 7648 """ 7649 7650 all_params = ['account_id', 'envelope_id'] 7651 all_params.append('callback') 7652 all_params.append('_return_http_data_only') 7653 all_params.append('_preload_content') 7654 all_params.append('_request_timeout') 7655 7656 params = locals() 7657 for key, val in iteritems(params['kwargs']): 7658 if key not in all_params: 7659 raise TypeError( 7660 "Got an unexpected keyword argument '%s'" 7661 " to method get_envelope_html_definitions" % key 7662 ) 7663 params[key] = val 7664 del params['kwargs'] 7665 # verify the required parameter 'account_id' is set 7666 if ('account_id' not in params) or (params['account_id'] is None): 7667 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_html_definitions`") 7668 # verify the required parameter 'envelope_id' is set 7669 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7670 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_html_definitions`") 7671 7672 7673 collection_formats = {} 7674 7675 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/html_definitions'.replace('{format}', 'json') 7676 path_params = {} 7677 if 'account_id' in params: 7678 path_params['accountId'] = params['account_id'] 7679 if 'envelope_id' in params: 7680 path_params['envelopeId'] = params['envelope_id'] 7681 7682 query_params = {} 7683 7684 header_params = {} 7685 7686 form_params = [] 7687 local_var_files = {} 7688 7689 body_params = None 7690 # HTTP header `Accept` 7691 header_params['Accept'] = self.api_client.\ 7692 select_header_accept(['application/json']) 7693 7694 # Authentication setting 7695 auth_settings = [] 7696 7697 return self.api_client.call_api(resource_path, 'GET', 7698 path_params, 7699 query_params, 7700 header_params, 7701 body=body_params, 7702 post_params=form_params, 7703 files=local_var_files, 7704 response_type='DocumentHtmlDefinitionOriginals', 7705 auth_settings=auth_settings, 7706 callback=params.get('callback'), 7707 _return_http_data_only=params.get('_return_http_data_only'), 7708 _preload_content=params.get('_preload_content', True), 7709 _request_timeout=params.get('_request_timeout'), 7710 collection_formats=collection_formats) 7711 7712 def get_envelope_scheduled_sending_definition(self, account_id, envelope_id, **kwargs): 7713 """ 7714 Returns the scheduled sending rules for an envelope's workflow definition. 7715 This method makes a synchronous HTTP request by default. To make an 7716 asynchronous HTTP request, please define a `callback` function 7717 to be invoked when receiving the response. 7718 >>> def callback_function(response): 7719 >>> pprint(response) 7720 >>> 7721 >>> thread = api.get_envelope_scheduled_sending_definition(account_id, envelope_id, callback=callback_function) 7722 7723 :param callback function: The callback function 7724 for asynchronous request. (optional) 7725 :param str account_id: The external account number (int) or account ID Guid. (required) 7726 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7727 :return: ScheduledSending 7728 If the method is called asynchronously, 7729 returns the request thread. 7730 """ 7731 kwargs['_return_http_data_only'] = True 7732 if kwargs.get('callback'): 7733 return self.get_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 7734 else: 7735 (data) = self.get_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 7736 return data 7737 7738 def get_envelope_scheduled_sending_definition_with_http_info(self, account_id, envelope_id, **kwargs): 7739 """ 7740 Returns the scheduled sending rules for an envelope's workflow definition. 7741 This method makes a synchronous HTTP request by default. To make an 7742 asynchronous HTTP request, please define a `callback` function 7743 to be invoked when receiving the response. 7744 >>> def callback_function(response): 7745 >>> pprint(response) 7746 >>> 7747 >>> thread = api.get_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, callback=callback_function) 7748 7749 :param callback function: The callback function 7750 for asynchronous request. (optional) 7751 :param str account_id: The external account number (int) or account ID Guid. (required) 7752 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7753 :return: ScheduledSending 7754 If the method is called asynchronously, 7755 returns the request thread. 7756 """ 7757 7758 all_params = ['account_id', 'envelope_id'] 7759 all_params.append('callback') 7760 all_params.append('_return_http_data_only') 7761 all_params.append('_preload_content') 7762 all_params.append('_request_timeout') 7763 7764 params = locals() 7765 for key, val in iteritems(params['kwargs']): 7766 if key not in all_params: 7767 raise TypeError( 7768 "Got an unexpected keyword argument '%s'" 7769 " to method get_envelope_scheduled_sending_definition" % key 7770 ) 7771 params[key] = val 7772 del params['kwargs'] 7773 # verify the required parameter 'account_id' is set 7774 if ('account_id' not in params) or (params['account_id'] is None): 7775 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_scheduled_sending_definition`") 7776 # verify the required parameter 'envelope_id' is set 7777 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7778 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_scheduled_sending_definition`") 7779 7780 7781 collection_formats = {} 7782 7783 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/scheduledSending'.replace('{format}', 'json') 7784 path_params = {} 7785 if 'account_id' in params: 7786 path_params['accountId'] = params['account_id'] 7787 if 'envelope_id' in params: 7788 path_params['envelopeId'] = params['envelope_id'] 7789 7790 query_params = {} 7791 7792 header_params = {} 7793 7794 form_params = [] 7795 local_var_files = {} 7796 7797 body_params = None 7798 # HTTP header `Accept` 7799 header_params['Accept'] = self.api_client.\ 7800 select_header_accept(['application/json']) 7801 7802 # Authentication setting 7803 auth_settings = [] 7804 7805 return self.api_client.call_api(resource_path, 'GET', 7806 path_params, 7807 query_params, 7808 header_params, 7809 body=body_params, 7810 post_params=form_params, 7811 files=local_var_files, 7812 response_type='ScheduledSending', 7813 auth_settings=auth_settings, 7814 callback=params.get('callback'), 7815 _return_http_data_only=params.get('_return_http_data_only'), 7816 _preload_content=params.get('_preload_content', True), 7817 _request_timeout=params.get('_request_timeout'), 7818 collection_formats=collection_formats) 7819 7820 def get_envelope_transfer_rules(self, account_id, **kwargs): 7821 """ 7822 Returns a list of envelope transfer rules in the specified account. 7823 This method retrieves a list of envelope transfer rules associated with an account. **Note:** Only Administrators can create and use envelope transfer rules. In addition, to use envelope transfer rules, the **Transfer Custody** feature must be enabled for your account. 7824 This method makes a synchronous HTTP request by default. To make an 7825 asynchronous HTTP request, please define a `callback` function 7826 to be invoked when receiving the response. 7827 >>> def callback_function(response): 7828 >>> pprint(response) 7829 >>> 7830 >>> thread = api.get_envelope_transfer_rules(account_id, callback=callback_function) 7831 7832 :param callback function: The callback function 7833 for asynchronous request. (optional) 7834 :param str account_id: The external account number (int) or account ID Guid. (required) 7835 :param str count: 7836 :param str start_position: 7837 :return: EnvelopeTransferRuleInformation 7838 If the method is called asynchronously, 7839 returns the request thread. 7840 """ 7841 kwargs['_return_http_data_only'] = True 7842 if kwargs.get('callback'): 7843 return self.get_envelope_transfer_rules_with_http_info(account_id, **kwargs) 7844 else: 7845 (data) = self.get_envelope_transfer_rules_with_http_info(account_id, **kwargs) 7846 return data 7847 7848 def get_envelope_transfer_rules_with_http_info(self, account_id, **kwargs): 7849 """ 7850 Returns a list of envelope transfer rules in the specified account. 7851 This method retrieves a list of envelope transfer rules associated with an account. **Note:** Only Administrators can create and use envelope transfer rules. In addition, to use envelope transfer rules, the **Transfer Custody** feature must be enabled for your account. 7852 This method makes a synchronous HTTP request by default. To make an 7853 asynchronous HTTP request, please define a `callback` function 7854 to be invoked when receiving the response. 7855 >>> def callback_function(response): 7856 >>> pprint(response) 7857 >>> 7858 >>> thread = api.get_envelope_transfer_rules_with_http_info(account_id, callback=callback_function) 7859 7860 :param callback function: The callback function 7861 for asynchronous request. (optional) 7862 :param str account_id: The external account number (int) or account ID Guid. (required) 7863 :param str count: 7864 :param str start_position: 7865 :return: EnvelopeTransferRuleInformation 7866 If the method is called asynchronously, 7867 returns the request thread. 7868 """ 7869 7870 all_params = ['account_id', 'count', 'start_position'] 7871 all_params.append('callback') 7872 all_params.append('_return_http_data_only') 7873 all_params.append('_preload_content') 7874 all_params.append('_request_timeout') 7875 7876 params = locals() 7877 for key, val in iteritems(params['kwargs']): 7878 if key not in all_params: 7879 raise TypeError( 7880 "Got an unexpected keyword argument '%s'" 7881 " to method get_envelope_transfer_rules" % key 7882 ) 7883 params[key] = val 7884 del params['kwargs'] 7885 # verify the required parameter 'account_id' is set 7886 if ('account_id' not in params) or (params['account_id'] is None): 7887 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_transfer_rules`") 7888 7889 7890 collection_formats = {} 7891 7892 resource_path = '/v2.1/accounts/{accountId}/envelopes/transfer_rules'.replace('{format}', 'json') 7893 path_params = {} 7894 if 'account_id' in params: 7895 path_params['accountId'] = params['account_id'] 7896 7897 query_params = {} 7898 if 'count' in params: 7899 query_params['count'] = params['count'] 7900 if 'start_position' in params: 7901 query_params['start_position'] = params['start_position'] 7902 7903 header_params = {} 7904 7905 form_params = [] 7906 local_var_files = {} 7907 7908 body_params = None 7909 # HTTP header `Accept` 7910 header_params['Accept'] = self.api_client.\ 7911 select_header_accept(['application/json']) 7912 7913 # Authentication setting 7914 auth_settings = [] 7915 7916 return self.api_client.call_api(resource_path, 'GET', 7917 path_params, 7918 query_params, 7919 header_params, 7920 body=body_params, 7921 post_params=form_params, 7922 files=local_var_files, 7923 response_type='EnvelopeTransferRuleInformation', 7924 auth_settings=auth_settings, 7925 callback=params.get('callback'), 7926 _return_http_data_only=params.get('_return_http_data_only'), 7927 _preload_content=params.get('_preload_content', True), 7928 _request_timeout=params.get('_request_timeout'), 7929 collection_formats=collection_formats) 7930 7931 def get_envelope_workflow_definition(self, account_id, envelope_id, **kwargs): 7932 """ 7933 Returns the workflow definition for an envelope. 7934 Returns an envelope's workflow definition if the envelope specified by `envelopeId` has one. 7935 This method makes a synchronous HTTP request by default. To make an 7936 asynchronous HTTP request, please define a `callback` function 7937 to be invoked when receiving the response. 7938 >>> def callback_function(response): 7939 >>> pprint(response) 7940 >>> 7941 >>> thread = api.get_envelope_workflow_definition(account_id, envelope_id, callback=callback_function) 7942 7943 :param callback function: The callback function 7944 for asynchronous request. (optional) 7945 :param str account_id: The external account number (int) or account ID Guid. (required) 7946 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7947 :return: Workflow 7948 If the method is called asynchronously, 7949 returns the request thread. 7950 """ 7951 kwargs['_return_http_data_only'] = True 7952 if kwargs.get('callback'): 7953 return self.get_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 7954 else: 7955 (data) = self.get_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 7956 return data 7957 7958 def get_envelope_workflow_definition_with_http_info(self, account_id, envelope_id, **kwargs): 7959 """ 7960 Returns the workflow definition for an envelope. 7961 Returns an envelope's workflow definition if the envelope specified by `envelopeId` has one. 7962 This method makes a synchronous HTTP request by default. To make an 7963 asynchronous HTTP request, please define a `callback` function 7964 to be invoked when receiving the response. 7965 >>> def callback_function(response): 7966 >>> pprint(response) 7967 >>> 7968 >>> thread = api.get_envelope_workflow_definition_with_http_info(account_id, envelope_id, callback=callback_function) 7969 7970 :param callback function: The callback function 7971 for asynchronous request. (optional) 7972 :param str account_id: The external account number (int) or account ID Guid. (required) 7973 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7974 :return: Workflow 7975 If the method is called asynchronously, 7976 returns the request thread. 7977 """ 7978 7979 all_params = ['account_id', 'envelope_id'] 7980 all_params.append('callback') 7981 all_params.append('_return_http_data_only') 7982 all_params.append('_preload_content') 7983 all_params.append('_request_timeout') 7984 7985 params = locals() 7986 for key, val in iteritems(params['kwargs']): 7987 if key not in all_params: 7988 raise TypeError( 7989 "Got an unexpected keyword argument '%s'" 7990 " to method get_envelope_workflow_definition" % key 7991 ) 7992 params[key] = val 7993 del params['kwargs'] 7994 # verify the required parameter 'account_id' is set 7995 if ('account_id' not in params) or (params['account_id'] is None): 7996 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_workflow_definition`") 7997 # verify the required parameter 'envelope_id' is set 7998 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7999 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_workflow_definition`") 8000 8001 8002 collection_formats = {} 8003 8004 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow'.replace('{format}', 'json') 8005 path_params = {} 8006 if 'account_id' in params: 8007 path_params['accountId'] = params['account_id'] 8008 if 'envelope_id' in params: 8009 path_params['envelopeId'] = params['envelope_id'] 8010 8011 query_params = {} 8012 8013 header_params = {} 8014 8015 form_params = [] 8016 local_var_files = {} 8017 8018 body_params = None 8019 # HTTP header `Accept` 8020 header_params['Accept'] = self.api_client.\ 8021 select_header_accept(['application/json']) 8022 8023 # Authentication setting 8024 auth_settings = [] 8025 8026 return self.api_client.call_api(resource_path, 'GET', 8027 path_params, 8028 query_params, 8029 header_params, 8030 body=body_params, 8031 post_params=form_params, 8032 files=local_var_files, 8033 response_type='Workflow', 8034 auth_settings=auth_settings, 8035 callback=params.get('callback'), 8036 _return_http_data_only=params.get('_return_http_data_only'), 8037 _preload_content=params.get('_preload_content', True), 8038 _request_timeout=params.get('_request_timeout'), 8039 collection_formats=collection_formats) 8040 8041 def get_envelope_workflow_step_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 8042 """ 8043 Returns the workflow step definition for an envelope by step id. 8044 This method makes a synchronous HTTP request by default. To make an 8045 asynchronous HTTP request, please define a `callback` function 8046 to be invoked when receiving the response. 8047 >>> def callback_function(response): 8048 >>> pprint(response) 8049 >>> 8050 >>> thread = api.get_envelope_workflow_step_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 8051 8052 :param callback function: The callback function 8053 for asynchronous request. (optional) 8054 :param str account_id: The external account number (int) or account ID Guid. (required) 8055 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8056 :param str workflow_step_id: (required) 8057 :return: WorkflowStep 8058 If the method is called asynchronously, 8059 returns the request thread. 8060 """ 8061 kwargs['_return_http_data_only'] = True 8062 if kwargs.get('callback'): 8063 return self.get_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 8064 else: 8065 (data) = self.get_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 8066 return data 8067 8068 def get_envelope_workflow_step_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 8069 """ 8070 Returns the workflow step definition for an envelope by step id. 8071 This method makes a synchronous HTTP request by default. To make an 8072 asynchronous HTTP request, please define a `callback` function 8073 to be invoked when receiving the response. 8074 >>> def callback_function(response): 8075 >>> pprint(response) 8076 >>> 8077 >>> thread = api.get_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 8078 8079 :param callback function: The callback function 8080 for asynchronous request. (optional) 8081 :param str account_id: The external account number (int) or account ID Guid. (required) 8082 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8083 :param str workflow_step_id: (required) 8084 :return: WorkflowStep 8085 If the method is called asynchronously, 8086 returns the request thread. 8087 """ 8088 8089 all_params = ['account_id', 'envelope_id', 'workflow_step_id'] 8090 all_params.append('callback') 8091 all_params.append('_return_http_data_only') 8092 all_params.append('_preload_content') 8093 all_params.append('_request_timeout') 8094 8095 params = locals() 8096 for key, val in iteritems(params['kwargs']): 8097 if key not in all_params: 8098 raise TypeError( 8099 "Got an unexpected keyword argument '%s'" 8100 " to method get_envelope_workflow_step_definition" % key 8101 ) 8102 params[key] = val 8103 del params['kwargs'] 8104 # verify the required parameter 'account_id' is set 8105 if ('account_id' not in params) or (params['account_id'] is None): 8106 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_workflow_step_definition`") 8107 # verify the required parameter 'envelope_id' is set 8108 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8109 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_workflow_step_definition`") 8110 # verify the required parameter 'workflow_step_id' is set 8111 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 8112 raise ValueError("Missing the required parameter `workflow_step_id` when calling `get_envelope_workflow_step_definition`") 8113 8114 8115 collection_formats = {} 8116 8117 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 8118 path_params = {} 8119 if 'account_id' in params: 8120 path_params['accountId'] = params['account_id'] 8121 if 'envelope_id' in params: 8122 path_params['envelopeId'] = params['envelope_id'] 8123 if 'workflow_step_id' in params: 8124 path_params['workflowStepId'] = params['workflow_step_id'] 8125 8126 query_params = {} 8127 8128 header_params = {} 8129 8130 form_params = [] 8131 local_var_files = {} 8132 8133 body_params = None 8134 # HTTP header `Accept` 8135 header_params['Accept'] = self.api_client.\ 8136 select_header_accept(['application/json']) 8137 8138 # Authentication setting 8139 auth_settings = [] 8140 8141 return self.api_client.call_api(resource_path, 'GET', 8142 path_params, 8143 query_params, 8144 header_params, 8145 body=body_params, 8146 post_params=form_params, 8147 files=local_var_files, 8148 response_type='WorkflowStep', 8149 auth_settings=auth_settings, 8150 callback=params.get('callback'), 8151 _return_http_data_only=params.get('_return_http_data_only'), 8152 _preload_content=params.get('_preload_content', True), 8153 _request_timeout=params.get('_request_timeout'), 8154 collection_formats=collection_formats) 8155 8156 def get_form_data(self, account_id, envelope_id, **kwargs): 8157 """ 8158 Returns envelope form data for an existing envelope. 8159 This method downloads the envelope and tab data (also called form data) from any in-process, completed, or canceled envelope that you sent or that is shared with you. Recipients who are also full administrators on an account can view form data for any envelopes that another user on the account has sent to them. **Note:** To use this feature, the Sending Setting \"Allow sender to download form data\" must be enabled for the account. ### Related topics - [How to get envelope tab values](/docs/esign-rest-api/how-to/get-envelope-tab-values/) 8160 This method makes a synchronous HTTP request by default. To make an 8161 asynchronous HTTP request, please define a `callback` function 8162 to be invoked when receiving the response. 8163 >>> def callback_function(response): 8164 >>> pprint(response) 8165 >>> 8166 >>> thread = api.get_form_data(account_id, envelope_id, callback=callback_function) 8167 8168 :param callback function: The callback function 8169 for asynchronous request. (optional) 8170 :param str account_id: The external account number (int) or account ID Guid. (required) 8171 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8172 :return: EnvelopeFormData 8173 If the method is called asynchronously, 8174 returns the request thread. 8175 """ 8176 kwargs['_return_http_data_only'] = True 8177 if kwargs.get('callback'): 8178 return self.get_form_data_with_http_info(account_id, envelope_id, **kwargs) 8179 else: 8180 (data) = self.get_form_data_with_http_info(account_id, envelope_id, **kwargs) 8181 return data 8182 8183 def get_form_data_with_http_info(self, account_id, envelope_id, **kwargs): 8184 """ 8185 Returns envelope form data for an existing envelope. 8186 This method downloads the envelope and tab data (also called form data) from any in-process, completed, or canceled envelope that you sent or that is shared with you. Recipients who are also full administrators on an account can view form data for any envelopes that another user on the account has sent to them. **Note:** To use this feature, the Sending Setting \"Allow sender to download form data\" must be enabled for the account. ### Related topics - [How to get envelope tab values](/docs/esign-rest-api/how-to/get-envelope-tab-values/) 8187 This method makes a synchronous HTTP request by default. To make an 8188 asynchronous HTTP request, please define a `callback` function 8189 to be invoked when receiving the response. 8190 >>> def callback_function(response): 8191 >>> pprint(response) 8192 >>> 8193 >>> thread = api.get_form_data_with_http_info(account_id, envelope_id, callback=callback_function) 8194 8195 :param callback function: The callback function 8196 for asynchronous request. (optional) 8197 :param str account_id: The external account number (int) or account ID Guid. (required) 8198 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8199 :return: EnvelopeFormData 8200 If the method is called asynchronously, 8201 returns the request thread. 8202 """ 8203 8204 all_params = ['account_id', 'envelope_id'] 8205 all_params.append('callback') 8206 all_params.append('_return_http_data_only') 8207 all_params.append('_preload_content') 8208 all_params.append('_request_timeout') 8209 8210 params = locals() 8211 for key, val in iteritems(params['kwargs']): 8212 if key not in all_params: 8213 raise TypeError( 8214 "Got an unexpected keyword argument '%s'" 8215 " to method get_form_data" % key 8216 ) 8217 params[key] = val 8218 del params['kwargs'] 8219 # verify the required parameter 'account_id' is set 8220 if ('account_id' not in params) or (params['account_id'] is None): 8221 raise ValueError("Missing the required parameter `account_id` when calling `get_form_data`") 8222 # verify the required parameter 'envelope_id' is set 8223 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8224 raise ValueError("Missing the required parameter `envelope_id` when calling `get_form_data`") 8225 8226 8227 collection_formats = {} 8228 8229 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/form_data'.replace('{format}', 'json') 8230 path_params = {} 8231 if 'account_id' in params: 8232 path_params['accountId'] = params['account_id'] 8233 if 'envelope_id' in params: 8234 path_params['envelopeId'] = params['envelope_id'] 8235 8236 query_params = {} 8237 8238 header_params = {} 8239 8240 form_params = [] 8241 local_var_files = {} 8242 8243 body_params = None 8244 # HTTP header `Accept` 8245 header_params['Accept'] = self.api_client.\ 8246 select_header_accept(['application/json']) 8247 8248 # Authentication setting 8249 auth_settings = [] 8250 8251 return self.api_client.call_api(resource_path, 'GET', 8252 path_params, 8253 query_params, 8254 header_params, 8255 body=body_params, 8256 post_params=form_params, 8257 files=local_var_files, 8258 response_type='EnvelopeFormData', 8259 auth_settings=auth_settings, 8260 callback=params.get('callback'), 8261 _return_http_data_only=params.get('_return_http_data_only'), 8262 _preload_content=params.get('_preload_content', True), 8263 _request_timeout=params.get('_request_timeout'), 8264 collection_formats=collection_formats) 8265 8266 def get_lock(self, account_id, envelope_id, **kwargs): 8267 """ 8268 Gets envelope lock information. 8269 Retrieves general information about the envelope lock. If the call is made by the locked by user and the request has the same integrator key as original, then the `X-DocuSign-Edit` header and additional lock information is included in the response. This allows users to recover a lost editing session token and the `X-DocuSign-Edit` header. 8270 This method makes a synchronous HTTP request by default. To make an 8271 asynchronous HTTP request, please define a `callback` function 8272 to be invoked when receiving the response. 8273 >>> def callback_function(response): 8274 >>> pprint(response) 8275 >>> 8276 >>> thread = api.get_lock(account_id, envelope_id, callback=callback_function) 8277 8278 :param callback function: The callback function 8279 for asynchronous request. (optional) 8280 :param str account_id: The external account number (int) or account ID Guid. (required) 8281 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8282 :return: LockInformation 8283 If the method is called asynchronously, 8284 returns the request thread. 8285 """ 8286 kwargs['_return_http_data_only'] = True 8287 if kwargs.get('callback'): 8288 return self.get_lock_with_http_info(account_id, envelope_id, **kwargs) 8289 else: 8290 (data) = self.get_lock_with_http_info(account_id, envelope_id, **kwargs) 8291 return data 8292 8293 def get_lock_with_http_info(self, account_id, envelope_id, **kwargs): 8294 """ 8295 Gets envelope lock information. 8296 Retrieves general information about the envelope lock. If the call is made by the locked by user and the request has the same integrator key as original, then the `X-DocuSign-Edit` header and additional lock information is included in the response. This allows users to recover a lost editing session token and the `X-DocuSign-Edit` header. 8297 This method makes a synchronous HTTP request by default. To make an 8298 asynchronous HTTP request, please define a `callback` function 8299 to be invoked when receiving the response. 8300 >>> def callback_function(response): 8301 >>> pprint(response) 8302 >>> 8303 >>> thread = api.get_lock_with_http_info(account_id, envelope_id, callback=callback_function) 8304 8305 :param callback function: The callback function 8306 for asynchronous request. (optional) 8307 :param str account_id: The external account number (int) or account ID Guid. (required) 8308 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8309 :return: LockInformation 8310 If the method is called asynchronously, 8311 returns the request thread. 8312 """ 8313 8314 all_params = ['account_id', 'envelope_id'] 8315 all_params.append('callback') 8316 all_params.append('_return_http_data_only') 8317 all_params.append('_preload_content') 8318 all_params.append('_request_timeout') 8319 8320 params = locals() 8321 for key, val in iteritems(params['kwargs']): 8322 if key not in all_params: 8323 raise TypeError( 8324 "Got an unexpected keyword argument '%s'" 8325 " to method get_lock" % key 8326 ) 8327 params[key] = val 8328 del params['kwargs'] 8329 # verify the required parameter 'account_id' is set 8330 if ('account_id' not in params) or (params['account_id'] is None): 8331 raise ValueError("Missing the required parameter `account_id` when calling `get_lock`") 8332 # verify the required parameter 'envelope_id' is set 8333 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8334 raise ValueError("Missing the required parameter `envelope_id` when calling `get_lock`") 8335 8336 8337 collection_formats = {} 8338 8339 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/lock'.replace('{format}', 'json') 8340 path_params = {} 8341 if 'account_id' in params: 8342 path_params['accountId'] = params['account_id'] 8343 if 'envelope_id' in params: 8344 path_params['envelopeId'] = params['envelope_id'] 8345 8346 query_params = {} 8347 8348 header_params = {} 8349 8350 form_params = [] 8351 local_var_files = {} 8352 8353 body_params = None 8354 # HTTP header `Accept` 8355 header_params['Accept'] = self.api_client.\ 8356 select_header_accept(['application/json']) 8357 8358 # Authentication setting 8359 auth_settings = [] 8360 8361 return self.api_client.call_api(resource_path, 'GET', 8362 path_params, 8363 query_params, 8364 header_params, 8365 body=body_params, 8366 post_params=form_params, 8367 files=local_var_files, 8368 response_type='LockInformation', 8369 auth_settings=auth_settings, 8370 callback=params.get('callback'), 8371 _return_http_data_only=params.get('_return_http_data_only'), 8372 _preload_content=params.get('_preload_content', True), 8373 _request_timeout=params.get('_request_timeout'), 8374 collection_formats=collection_formats) 8375 8376 def get_notification_settings(self, account_id, envelope_id, **kwargs): 8377 """ 8378 Gets envelope notification information. 8379 Retrieves the envelope notification, reminders and expirations, information for an existing envelope. 8380 This method makes a synchronous HTTP request by default. To make an 8381 asynchronous HTTP request, please define a `callback` function 8382 to be invoked when receiving the response. 8383 >>> def callback_function(response): 8384 >>> pprint(response) 8385 >>> 8386 >>> thread = api.get_notification_settings(account_id, envelope_id, callback=callback_function) 8387 8388 :param callback function: The callback function 8389 for asynchronous request. (optional) 8390 :param str account_id: The external account number (int) or account ID Guid. (required) 8391 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8392 :return: Notification 8393 If the method is called asynchronously, 8394 returns the request thread. 8395 """ 8396 kwargs['_return_http_data_only'] = True 8397 if kwargs.get('callback'): 8398 return self.get_notification_settings_with_http_info(account_id, envelope_id, **kwargs) 8399 else: 8400 (data) = self.get_notification_settings_with_http_info(account_id, envelope_id, **kwargs) 8401 return data 8402 8403 def get_notification_settings_with_http_info(self, account_id, envelope_id, **kwargs): 8404 """ 8405 Gets envelope notification information. 8406 Retrieves the envelope notification, reminders and expirations, information for an existing envelope. 8407 This method makes a synchronous HTTP request by default. To make an 8408 asynchronous HTTP request, please define a `callback` function 8409 to be invoked when receiving the response. 8410 >>> def callback_function(response): 8411 >>> pprint(response) 8412 >>> 8413 >>> thread = api.get_notification_settings_with_http_info(account_id, envelope_id, callback=callback_function) 8414 8415 :param callback function: The callback function 8416 for asynchronous request. (optional) 8417 :param str account_id: The external account number (int) or account ID Guid. (required) 8418 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8419 :return: Notification 8420 If the method is called asynchronously, 8421 returns the request thread. 8422 """ 8423 8424 all_params = ['account_id', 'envelope_id'] 8425 all_params.append('callback') 8426 all_params.append('_return_http_data_only') 8427 all_params.append('_preload_content') 8428 all_params.append('_request_timeout') 8429 8430 params = locals() 8431 for key, val in iteritems(params['kwargs']): 8432 if key not in all_params: 8433 raise TypeError( 8434 "Got an unexpected keyword argument '%s'" 8435 " to method get_notification_settings" % key 8436 ) 8437 params[key] = val 8438 del params['kwargs'] 8439 # verify the required parameter 'account_id' is set 8440 if ('account_id' not in params) or (params['account_id'] is None): 8441 raise ValueError("Missing the required parameter `account_id` when calling `get_notification_settings`") 8442 # verify the required parameter 'envelope_id' is set 8443 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8444 raise ValueError("Missing the required parameter `envelope_id` when calling `get_notification_settings`") 8445 8446 8447 collection_formats = {} 8448 8449 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/notification'.replace('{format}', 'json') 8450 path_params = {} 8451 if 'account_id' in params: 8452 path_params['accountId'] = params['account_id'] 8453 if 'envelope_id' in params: 8454 path_params['envelopeId'] = params['envelope_id'] 8455 8456 query_params = {} 8457 8458 header_params = {} 8459 8460 form_params = [] 8461 local_var_files = {} 8462 8463 body_params = None 8464 # HTTP header `Accept` 8465 header_params['Accept'] = self.api_client.\ 8466 select_header_accept(['application/json']) 8467 8468 # Authentication setting 8469 auth_settings = [] 8470 8471 return self.api_client.call_api(resource_path, 'GET', 8472 path_params, 8473 query_params, 8474 header_params, 8475 body=body_params, 8476 post_params=form_params, 8477 files=local_var_files, 8478 response_type='Notification', 8479 auth_settings=auth_settings, 8480 callback=params.get('callback'), 8481 _return_http_data_only=params.get('_return_http_data_only'), 8482 _preload_content=params.get('_preload_content', True), 8483 _request_timeout=params.get('_request_timeout'), 8484 collection_formats=collection_formats) 8485 8486 def get_page_tabs(self, account_id, document_id, envelope_id, page_number, **kwargs): 8487 """ 8488 Returns tabs on the specified page. 8489 Returns the tabs from the page specified by `pageNumber` of the document specified by `documentId` in the envelope specified by `envelopeId`. 8490 This method makes a synchronous HTTP request by default. To make an 8491 asynchronous HTTP request, please define a `callback` function 8492 to be invoked when receiving the response. 8493 >>> def callback_function(response): 8494 >>> pprint(response) 8495 >>> 8496 >>> thread = api.get_page_tabs(account_id, document_id, envelope_id, page_number, callback=callback_function) 8497 8498 :param callback function: The callback function 8499 for asynchronous request. (optional) 8500 :param str account_id: The external account number (int) or account ID Guid. (required) 8501 :param str document_id: The ID of the document being accessed. (required) 8502 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8503 :param str page_number: The page number being accessed. (required) 8504 :return: Tabs 8505 If the method is called asynchronously, 8506 returns the request thread. 8507 """ 8508 kwargs['_return_http_data_only'] = True 8509 if kwargs.get('callback'): 8510 return self.get_page_tabs_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 8511 else: 8512 (data) = self.get_page_tabs_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 8513 return data 8514 8515 def get_page_tabs_with_http_info(self, account_id, document_id, envelope_id, page_number, **kwargs): 8516 """ 8517 Returns tabs on the specified page. 8518 Returns the tabs from the page specified by `pageNumber` of the document specified by `documentId` in the envelope specified by `envelopeId`. 8519 This method makes a synchronous HTTP request by default. To make an 8520 asynchronous HTTP request, please define a `callback` function 8521 to be invoked when receiving the response. 8522 >>> def callback_function(response): 8523 >>> pprint(response) 8524 >>> 8525 >>> thread = api.get_page_tabs_with_http_info(account_id, document_id, envelope_id, page_number, callback=callback_function) 8526 8527 :param callback function: The callback function 8528 for asynchronous request. (optional) 8529 :param str account_id: The external account number (int) or account ID Guid. (required) 8530 :param str document_id: The ID of the document being accessed. (required) 8531 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8532 :param str page_number: The page number being accessed. (required) 8533 :return: Tabs 8534 If the method is called asynchronously, 8535 returns the request thread. 8536 """ 8537 8538 all_params = ['account_id', 'document_id', 'envelope_id', 'page_number'] 8539 all_params.append('callback') 8540 all_params.append('_return_http_data_only') 8541 all_params.append('_preload_content') 8542 all_params.append('_request_timeout') 8543 8544 params = locals() 8545 for key, val in iteritems(params['kwargs']): 8546 if key not in all_params: 8547 raise TypeError( 8548 "Got an unexpected keyword argument '%s'" 8549 " to method get_page_tabs" % key 8550 ) 8551 params[key] = val 8552 del params['kwargs'] 8553 # verify the required parameter 'account_id' is set 8554 if ('account_id' not in params) or (params['account_id'] is None): 8555 raise ValueError("Missing the required parameter `account_id` when calling `get_page_tabs`") 8556 # verify the required parameter 'document_id' is set 8557 if ('document_id' not in params) or (params['document_id'] is None): 8558 raise ValueError("Missing the required parameter `document_id` when calling `get_page_tabs`") 8559 # verify the required parameter 'envelope_id' is set 8560 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8561 raise ValueError("Missing the required parameter `envelope_id` when calling `get_page_tabs`") 8562 # verify the required parameter 'page_number' is set 8563 if ('page_number' not in params) or (params['page_number'] is None): 8564 raise ValueError("Missing the required parameter `page_number` when calling `get_page_tabs`") 8565 8566 8567 collection_formats = {} 8568 8569 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/pages/{pageNumber}/tabs'.replace('{format}', 'json') 8570 path_params = {} 8571 if 'account_id' in params: 8572 path_params['accountId'] = params['account_id'] 8573 if 'document_id' in params: 8574 path_params['documentId'] = params['document_id'] 8575 if 'envelope_id' in params: 8576 path_params['envelopeId'] = params['envelope_id'] 8577 if 'page_number' in params: 8578 path_params['pageNumber'] = params['page_number'] 8579 8580 query_params = {} 8581 8582 header_params = {} 8583 8584 form_params = [] 8585 local_var_files = {} 8586 8587 body_params = None 8588 # HTTP header `Accept` 8589 header_params['Accept'] = self.api_client.\ 8590 select_header_accept(['application/json']) 8591 8592 # Authentication setting 8593 auth_settings = [] 8594 8595 return self.api_client.call_api(resource_path, 'GET', 8596 path_params, 8597 query_params, 8598 header_params, 8599 body=body_params, 8600 post_params=form_params, 8601 files=local_var_files, 8602 response_type='Tabs', 8603 auth_settings=auth_settings, 8604 callback=params.get('callback'), 8605 _return_http_data_only=params.get('_return_http_data_only'), 8606 _preload_content=params.get('_preload_content', True), 8607 _request_timeout=params.get('_request_timeout'), 8608 collection_formats=collection_formats) 8609 8610 def get_pages(self, account_id, document_id, envelope_id, **kwargs): 8611 """ 8612 Returns document page image(s) based on input. 8613 Returns images of the pages in a document for display based on the parameters that you specify. 8614 This method makes a synchronous HTTP request by default. To make an 8615 asynchronous HTTP request, please define a `callback` function 8616 to be invoked when receiving the response. 8617 >>> def callback_function(response): 8618 >>> pprint(response) 8619 >>> 8620 >>> thread = api.get_pages(account_id, document_id, envelope_id, callback=callback_function) 8621 8622 :param callback function: The callback function 8623 for asynchronous request. (optional) 8624 :param str account_id: The external account number (int) or account ID Guid. (required) 8625 :param str document_id: The ID of the document being accessed. (required) 8626 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8627 :param str count: 8628 :param str dpi: 8629 :param str max_height: 8630 :param str max_width: 8631 :param str nocache: 8632 :param str show_changes: 8633 :param str start_position: 8634 :return: PageImages 8635 If the method is called asynchronously, 8636 returns the request thread. 8637 """ 8638 kwargs['_return_http_data_only'] = True 8639 if kwargs.get('callback'): 8640 return self.get_pages_with_http_info(account_id, document_id, envelope_id, **kwargs) 8641 else: 8642 (data) = self.get_pages_with_http_info(account_id, document_id, envelope_id, **kwargs) 8643 return data 8644 8645 def get_pages_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 8646 """ 8647 Returns document page image(s) based on input. 8648 Returns images of the pages in a document for display based on the parameters that you specify. 8649 This method makes a synchronous HTTP request by default. To make an 8650 asynchronous HTTP request, please define a `callback` function 8651 to be invoked when receiving the response. 8652 >>> def callback_function(response): 8653 >>> pprint(response) 8654 >>> 8655 >>> thread = api.get_pages_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 8656 8657 :param callback function: The callback function 8658 for asynchronous request. (optional) 8659 :param str account_id: The external account number (int) or account ID Guid. (required) 8660 :param str document_id: The ID of the document being accessed. (required) 8661 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8662 :param str count: 8663 :param str dpi: 8664 :param str max_height: 8665 :param str max_width: 8666 :param str nocache: 8667 :param str show_changes: 8668 :param str start_position: 8669 :return: PageImages 8670 If the method is called asynchronously, 8671 returns the request thread. 8672 """ 8673 8674 all_params = ['account_id', 'document_id', 'envelope_id', 'count', 'dpi', 'max_height', 'max_width', 'nocache', 'show_changes', 'start_position'] 8675 all_params.append('callback') 8676 all_params.append('_return_http_data_only') 8677 all_params.append('_preload_content') 8678 all_params.append('_request_timeout') 8679 8680 params = locals() 8681 for key, val in iteritems(params['kwargs']): 8682 if key not in all_params: 8683 raise TypeError( 8684 "Got an unexpected keyword argument '%s'" 8685 " to method get_pages" % key 8686 ) 8687 params[key] = val 8688 del params['kwargs'] 8689 # verify the required parameter 'account_id' is set 8690 if ('account_id' not in params) or (params['account_id'] is None): 8691 raise ValueError("Missing the required parameter `account_id` when calling `get_pages`") 8692 # verify the required parameter 'document_id' is set 8693 if ('document_id' not in params) or (params['document_id'] is None): 8694 raise ValueError("Missing the required parameter `document_id` when calling `get_pages`") 8695 # verify the required parameter 'envelope_id' is set 8696 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8697 raise ValueError("Missing the required parameter `envelope_id` when calling `get_pages`") 8698 8699 8700 collection_formats = {} 8701 8702 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/pages'.replace('{format}', 'json') 8703 path_params = {} 8704 if 'account_id' in params: 8705 path_params['accountId'] = params['account_id'] 8706 if 'document_id' in params: 8707 path_params['documentId'] = params['document_id'] 8708 if 'envelope_id' in params: 8709 path_params['envelopeId'] = params['envelope_id'] 8710 8711 query_params = {} 8712 if 'count' in params: 8713 query_params['count'] = params['count'] 8714 if 'dpi' in params: 8715 query_params['dpi'] = params['dpi'] 8716 if 'max_height' in params: 8717 query_params['max_height'] = params['max_height'] 8718 if 'max_width' in params: 8719 query_params['max_width'] = params['max_width'] 8720 if 'nocache' in params: 8721 query_params['nocache'] = params['nocache'] 8722 if 'show_changes' in params: 8723 query_params['show_changes'] = params['show_changes'] 8724 if 'start_position' in params: 8725 query_params['start_position'] = params['start_position'] 8726 8727 header_params = {} 8728 8729 form_params = [] 8730 local_var_files = {} 8731 8732 body_params = None 8733 # HTTP header `Accept` 8734 header_params['Accept'] = self.api_client.\ 8735 select_header_accept(['application/json']) 8736 8737 # Authentication setting 8738 auth_settings = [] 8739 8740 return self.api_client.call_api(resource_path, 'GET', 8741 path_params, 8742 query_params, 8743 header_params, 8744 body=body_params, 8745 post_params=form_params, 8746 files=local_var_files, 8747 response_type='PageImages', 8748 auth_settings=auth_settings, 8749 callback=params.get('callback'), 8750 _return_http_data_only=params.get('_return_http_data_only'), 8751 _preload_content=params.get('_preload_content', True), 8752 _request_timeout=params.get('_request_timeout'), 8753 collection_formats=collection_formats) 8754 8755 def get_recipient_document_visibility(self, account_id, envelope_id, recipient_id, **kwargs): 8756 """ 8757 Returns document visibility for the recipients 8758 This method returns information about document visibility for a recipient. 8759 This method makes a synchronous HTTP request by default. To make an 8760 asynchronous HTTP request, please define a `callback` function 8761 to be invoked when receiving the response. 8762 >>> def callback_function(response): 8763 >>> pprint(response) 8764 >>> 8765 >>> thread = api.get_recipient_document_visibility(account_id, envelope_id, recipient_id, callback=callback_function) 8766 8767 :param callback function: The callback function 8768 for asynchronous request. (optional) 8769 :param str account_id: The external account number (int) or account ID Guid. (required) 8770 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8771 :param str recipient_id: The ID of the recipient being accessed. (required) 8772 :return: DocumentVisibilityList 8773 If the method is called asynchronously, 8774 returns the request thread. 8775 """ 8776 kwargs['_return_http_data_only'] = True 8777 if kwargs.get('callback'): 8778 return self.get_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 8779 else: 8780 (data) = self.get_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 8781 return data 8782 8783 def get_recipient_document_visibility_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 8784 """ 8785 Returns document visibility for the recipients 8786 This method returns information about document visibility for a recipient. 8787 This method makes a synchronous HTTP request by default. To make an 8788 asynchronous HTTP request, please define a `callback` function 8789 to be invoked when receiving the response. 8790 >>> def callback_function(response): 8791 >>> pprint(response) 8792 >>> 8793 >>> thread = api.get_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 8794 8795 :param callback function: The callback function 8796 for asynchronous request. (optional) 8797 :param str account_id: The external account number (int) or account ID Guid. (required) 8798 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8799 :param str recipient_id: The ID of the recipient being accessed. (required) 8800 :return: DocumentVisibilityList 8801 If the method is called asynchronously, 8802 returns the request thread. 8803 """ 8804 8805 all_params = ['account_id', 'envelope_id', 'recipient_id'] 8806 all_params.append('callback') 8807 all_params.append('_return_http_data_only') 8808 all_params.append('_preload_content') 8809 all_params.append('_request_timeout') 8810 8811 params = locals() 8812 for key, val in iteritems(params['kwargs']): 8813 if key not in all_params: 8814 raise TypeError( 8815 "Got an unexpected keyword argument '%s'" 8816 " to method get_recipient_document_visibility" % key 8817 ) 8818 params[key] = val 8819 del params['kwargs'] 8820 # verify the required parameter 'account_id' is set 8821 if ('account_id' not in params) or (params['account_id'] is None): 8822 raise ValueError("Missing the required parameter `account_id` when calling `get_recipient_document_visibility`") 8823 # verify the required parameter 'envelope_id' is set 8824 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8825 raise ValueError("Missing the required parameter `envelope_id` when calling `get_recipient_document_visibility`") 8826 # verify the required parameter 'recipient_id' is set 8827 if ('recipient_id' not in params) or (params['recipient_id'] is None): 8828 raise ValueError("Missing the required parameter `recipient_id` when calling `get_recipient_document_visibility`") 8829 8830 8831 collection_formats = {} 8832 8833 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/document_visibility'.replace('{format}', 'json') 8834 path_params = {} 8835 if 'account_id' in params: 8836 path_params['accountId'] = params['account_id'] 8837 if 'envelope_id' in params: 8838 path_params['envelopeId'] = params['envelope_id'] 8839 if 'recipient_id' in params: 8840 path_params['recipientId'] = params['recipient_id'] 8841 8842 query_params = {} 8843 8844 header_params = {} 8845 8846 form_params = [] 8847 local_var_files = {} 8848 8849 body_params = None 8850 # HTTP header `Accept` 8851 header_params['Accept'] = self.api_client.\ 8852 select_header_accept(['application/json']) 8853 8854 # Authentication setting 8855 auth_settings = [] 8856 8857 return self.api_client.call_api(resource_path, 'GET', 8858 path_params, 8859 query_params, 8860 header_params, 8861 body=body_params, 8862 post_params=form_params, 8863 files=local_var_files, 8864 response_type='DocumentVisibilityList', 8865 auth_settings=auth_settings, 8866 callback=params.get('callback'), 8867 _return_http_data_only=params.get('_return_http_data_only'), 8868 _preload_content=params.get('_preload_content', True), 8869 _request_timeout=params.get('_request_timeout'), 8870 collection_formats=collection_formats) 8871 8872 def get_recipient_initials_image(self, account_id, envelope_id, recipient_id, **kwargs): 8873 """ 8874 Gets the initials image for a user. 8875 Retrieves the initials image for the specified user. The image is returned in the same format as it was uploaded. In the request you can specify if the chrome (the added line and identifier around the initial image) is returned with the image. The userId specified in the endpoint must match the authenticated user's user id and the user must be a member of the account. The `signatureIdOrName` paramter accepts signature ID or signature name. DocuSign recommends you use signature ID (`signatureId`), since some names contain characters that do not properly URL encode. If you use the user name, it is likely that the name includes spaces and you might need to URL encode the name before using it in the endpoint. For example: \"Bob Smith\" to \"Bob%20Smith\" Older envelopes might only contain chromed images. If getting the non-chromed image fails, try getting the chromed image. 8876 This method makes a synchronous HTTP request by default. To make an 8877 asynchronous HTTP request, please define a `callback` function 8878 to be invoked when receiving the response. 8879 >>> def callback_function(response): 8880 >>> pprint(response) 8881 >>> 8882 >>> thread = api.get_recipient_initials_image(account_id, envelope_id, recipient_id, callback=callback_function) 8883 8884 :param callback function: The callback function 8885 for asynchronous request. (optional) 8886 :param str account_id: The external account number (int) or account ID Guid. (required) 8887 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8888 :param str recipient_id: The ID of the recipient being accessed. (required) 8889 :param str include_chrome: The added line and identifier around the initial image. Note: Older envelopes might only have chromed images. If getting the non-chromed image fails, try getting the chromed image. 8890 :return: file 8891 If the method is called asynchronously, 8892 returns the request thread. 8893 """ 8894 kwargs['_return_http_data_only'] = True 8895 if kwargs.get('callback'): 8896 return self.get_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 8897 else: 8898 (data) = self.get_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 8899 return data 8900 8901 def get_recipient_initials_image_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 8902 """ 8903 Gets the initials image for a user. 8904 Retrieves the initials image for the specified user. The image is returned in the same format as it was uploaded. In the request you can specify if the chrome (the added line and identifier around the initial image) is returned with the image. The userId specified in the endpoint must match the authenticated user's user id and the user must be a member of the account. The `signatureIdOrName` paramter accepts signature ID or signature name. DocuSign recommends you use signature ID (`signatureId`), since some names contain characters that do not properly URL encode. If you use the user name, it is likely that the name includes spaces and you might need to URL encode the name before using it in the endpoint. For example: \"Bob Smith\" to \"Bob%20Smith\" Older envelopes might only contain chromed images. If getting the non-chromed image fails, try getting the chromed image. 8905 This method makes a synchronous HTTP request by default. To make an 8906 asynchronous HTTP request, please define a `callback` function 8907 to be invoked when receiving the response. 8908 >>> def callback_function(response): 8909 >>> pprint(response) 8910 >>> 8911 >>> thread = api.get_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 8912 8913 :param callback function: The callback function 8914 for asynchronous request. (optional) 8915 :param str account_id: The external account number (int) or account ID Guid. (required) 8916 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8917 :param str recipient_id: The ID of the recipient being accessed. (required) 8918 :param str include_chrome: The added line and identifier around the initial image. Note: Older envelopes might only have chromed images. If getting the non-chromed image fails, try getting the chromed image. 8919 :return: file 8920 If the method is called asynchronously, 8921 returns the request thread. 8922 """ 8923 8924 all_params = ['account_id', 'envelope_id', 'recipient_id', 'include_chrome'] 8925 all_params.append('callback') 8926 all_params.append('_return_http_data_only') 8927 all_params.append('_preload_content') 8928 all_params.append('_request_timeout') 8929 8930 params = locals() 8931 for key, val in iteritems(params['kwargs']): 8932 if key not in all_params: 8933 raise TypeError( 8934 "Got an unexpected keyword argument '%s'" 8935 " to method get_recipient_initials_image" % key 8936 ) 8937 params[key] = val 8938 del params['kwargs'] 8939 # verify the required parameter 'account_id' is set 8940 if ('account_id' not in params) or (params['account_id'] is None): 8941 raise ValueError("Missing the required parameter `account_id` when calling `get_recipient_initials_image`") 8942 # verify the required parameter 'envelope_id' is set 8943 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8944 raise ValueError("Missing the required parameter `envelope_id` when calling `get_recipient_initials_image`") 8945 # verify the required parameter 'recipient_id' is set 8946 if ('recipient_id' not in params) or (params['recipient_id'] is None): 8947 raise ValueError("Missing the required parameter `recipient_id` when calling `get_recipient_initials_image`") 8948 8949 8950 collection_formats = {} 8951 8952 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/initials_image'.replace('{format}', 'json') 8953 path_params = {} 8954 if 'account_id' in params: 8955 path_params['accountId'] = params['account_id'] 8956 if 'envelope_id' in params: 8957 path_params['envelopeId'] = params['envelope_id'] 8958 if 'recipient_id' in params: 8959 path_params['recipientId'] = params['recipient_id'] 8960 8961 query_params = {} 8962 if 'include_chrome' in params: 8963 query_params['include_chrome'] = params['include_chrome'] 8964 8965 header_params = {} 8966 8967 form_params = [] 8968 local_var_files = {} 8969 8970 body_params = None 8971 # HTTP header `Accept` 8972 header_params['Accept'] = self.api_client.\ 8973 select_header_accept(['image/gif']) 8974 8975 # Authentication setting 8976 auth_settings = [] 8977 8978 return self.api_client.call_api(resource_path, 'GET', 8979 path_params, 8980 query_params, 8981 header_params, 8982 body=body_params, 8983 post_params=form_params, 8984 files=local_var_files, 8985 response_type='file', 8986 auth_settings=auth_settings, 8987 callback=params.get('callback'), 8988 _return_http_data_only=params.get('_return_http_data_only'), 8989 _preload_content=params.get('_preload_content', True), 8990 _request_timeout=params.get('_request_timeout'), 8991 collection_formats=collection_formats) 8992 8993 def get_recipient_signature(self, account_id, envelope_id, recipient_id, **kwargs): 8994 """ 8995 Gets signature information for a signer or sign-in-person recipient. 8996 Retrieves signature information for a signer or sign-in-person recipient. 8997 This method makes a synchronous HTTP request by default. To make an 8998 asynchronous HTTP request, please define a `callback` function 8999 to be invoked when receiving the response. 9000 >>> def callback_function(response): 9001 >>> pprint(response) 9002 >>> 9003 >>> thread = api.get_recipient_signature(account_id, envelope_id, recipient_id, callback=callback_function) 9004 9005 :param callback function: The callback function 9006 for asynchronous request. (optional) 9007 :param str account_id: The external account number (int) or account ID Guid. (required) 9008 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9009 :param str recipient_id: The ID of the recipient being accessed. (required) 9010 :return: UserSignature 9011 If the method is called asynchronously, 9012 returns the request thread. 9013 """ 9014 kwargs['_return_http_data_only'] = True 9015 if kwargs.get('callback'): 9016 return self.get_recipient_signature_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 9017 else: 9018 (data) = self.get_recipient_signature_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 9019 return data 9020 9021 def get_recipient_signature_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 9022 """ 9023 Gets signature information for a signer or sign-in-person recipient. 9024 Retrieves signature information for a signer or sign-in-person recipient. 9025 This method makes a synchronous HTTP request by default. To make an 9026 asynchronous HTTP request, please define a `callback` function 9027 to be invoked when receiving the response. 9028 >>> def callback_function(response): 9029 >>> pprint(response) 9030 >>> 9031 >>> thread = api.get_recipient_signature_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 9032 9033 :param callback function: The callback function 9034 for asynchronous request. (optional) 9035 :param str account_id: The external account number (int) or account ID Guid. (required) 9036 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9037 :param str recipient_id: The ID of the recipient being accessed. (required) 9038 :return: UserSignature 9039 If the method is called asynchronously, 9040 returns the request thread. 9041 """ 9042 9043 all_params = ['account_id', 'envelope_id', 'recipient_id'] 9044 all_params.append('callback') 9045 all_params.append('_return_http_data_only') 9046 all_params.append('_preload_content') 9047 all_params.append('_request_timeout') 9048 9049 params = locals() 9050 for key, val in iteritems(params['kwargs']): 9051 if key not in all_params: 9052 raise TypeError( 9053 "Got an unexpected keyword argument '%s'" 9054 " to method get_recipient_signature" % key 9055 ) 9056 params[key] = val 9057 del params['kwargs'] 9058 # verify the required parameter 'account_id' is set 9059 if ('account_id' not in params) or (params['account_id'] is None): 9060 raise ValueError("Missing the required parameter `account_id` when calling `get_recipient_signature`") 9061 # verify the required parameter 'envelope_id' is set 9062 if ('envelope_id' not in params) or (params['envelope_id'] is None): 9063 raise ValueError("Missing the required parameter `envelope_id` when calling `get_recipient_signature`") 9064 # verify the required parameter 'recipient_id' is set 9065 if ('recipient_id' not in params) or (params['recipient_id'] is None): 9066 raise ValueError("Missing the required parameter `recipient_id` when calling `get_recipient_signature`") 9067 9068 9069 collection_formats = {} 9070 9071 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/signature'.replace('{format}', 'json') 9072 path_params = {} 9073 if 'account_id' in params: 9074 path_params['accountId'] = params['account_id'] 9075 if 'envelope_id' in params: 9076 path_params['envelopeId'] = params['envelope_id'] 9077 if 'recipient_id' in params: 9078 path_params['recipientId'] = params['recipient_id'] 9079 9080 query_params = {} 9081 9082 header_params = {} 9083 9084 form_params = [] 9085 local_var_files = {} 9086 9087 body_params = None 9088 # HTTP header `Accept` 9089 header_params['Accept'] = self.api_client.\ 9090 select_header_accept(['application/json']) 9091 9092 # Authentication setting 9093 auth_settings = [] 9094 9095 return self.api_client.call_api(resource_path, 'GET', 9096 path_params, 9097 query_params, 9098 header_params, 9099 body=body_params, 9100 post_params=form_params, 9101 files=local_var_files, 9102 response_type='UserSignature', 9103 auth_settings=auth_settings, 9104 callback=params.get('callback'), 9105 _return_http_data_only=params.get('_return_http_data_only'), 9106 _preload_content=params.get('_preload_content', True), 9107 _request_timeout=params.get('_request_timeout'), 9108 collection_formats=collection_formats) 9109 9110 def get_recipient_signature_image(self, account_id, envelope_id, recipient_id, **kwargs): 9111 """ 9112 Retrieve signature image information for a signer/sign-in-person recipient. 9113 Retrieves the specified user signature image. The image is returned in the same format as uploaded. In the request you can specify if the chrome (the added line and identifier around the initial image) is returned with the image. The userId specified in the endpoint must match the authenticated user's user ID and the user must be a member of the account. The `signatureIdOrName` parameter accepts signature ID or signature name. DocuSign recommends you use signature ID (`signatureId`), since some names contain characters that don't properly URL encode. If you use the user name, it is likely that the name includes spaces and you might need to URL encode the name before using it in the endpoint. For example: \"Bob Smith\" to \"Bob%20Smith\" Older envelopes might only have chromed images. If getting the non-chromed image fails, try getting the chromed image. 9114 This method makes a synchronous HTTP request by default. To make an 9115 asynchronous HTTP request, please define a `callback` function 9116 to be invoked when receiving the response. 9117 >>> def callback_function(response): 9118 >>> pprint(response) 9119 >>> 9120 >>> thread = api.get_recipient_signature_image(account_id, envelope_id, recipient_id, callback=callback_function) 9121 9122 :param callback function: The callback function 9123 for asynchronous request. (optional) 9124 :param str account_id: The external account number (int) or account ID Guid. (required) 9125 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9126 :param str recipient_id: The ID of the recipient being accessed. (required) 9127 :param str include_chrome: When set to **true**, indicates the chromed version of the signature image should be retrieved. 9128 :return: file 9129 If the method is called asynchronously, 9130 returns the request thread. 9131 """ 9132 kwargs['_return_http_data_only'] = True 9133 if kwargs.get('callback'): 9134 return self.get_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 9135 else: 9136 (data) = self.get_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 9137 return data 9138 9139 def get_recipient_signature_image_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 9140 """ 9141 Retrieve signature image information for a signer/sign-in-person recipient. 9142 Retrieves the specified user signature image. The image is returned in the same format as uploaded. In the request you can specify if the chrome (the added line and identifier around the initial image) is returned with the image. The userId specified in the endpoint must match the authenticated user's user ID and the user must be a member of the account. The `signatureIdOrName` parameter accepts signature ID or signature name. DocuSign recommends you use signature ID (`signatureId`), since some names contain characters that don't properly URL encode. If you use the user name, it is likely that the name includes spaces and you might need to URL encode the name before using it in the endpoint. For example: \"Bob Smith\" to \"Bob%20Smith\" Older envelopes might only have chromed images. If getting the non-chromed image fails, try getting the chromed image. 9143 This method makes a synchronous HTTP request by default. To make an 9144 asynchronous HTTP request, please define a `callback` function 9145 to be invoked when receiving the response. 9146 >>> def callback_function(response): 9147 >>> pprint(response) 9148 >>> 9149 >>> thread = api.get_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 9150 9151 :param callback function: The callback function 9152 for asynchronous request. (optional) 9153 :param str account_id: The external account number (int) or account ID Guid. (required) 9154 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9155 :param str recipient_id: The ID of the recipient being accessed. (required) 9156 :param str include_chrome: When set to **true**, indicates the chromed version of the signature image should be retrieved. 9157 :return: file 9158 If the method is called asynchronously, 9159 returns the request thread. 9160 """ 9161 9162 all_params = ['account_id', 'envelope_id', 'recipient_id', 'include_chrome'] 9163 all_params.append('callback') 9164 all_params.append('_return_http_data_only') 9165 all_params.append('_preload_content') 9166 all_params.append('_request_timeout') 9167 9168 params = locals() 9169 for key, val in iteritems(params['kwargs']): 9170 if key not in all_params: 9171 raise TypeError( 9172 "Got an unexpected keyword argument '%s'" 9173 " to method get_recipient_signature_image" % key 9174 ) 9175 params[key] = val 9176 del params['kwargs'] 9177 # verify the required parameter 'account_id' is set 9178 if ('account_id' not in params) or (params['account_id'] is None): 9179 raise ValueError("Missing the required parameter `account_id` when calling `get_recipient_signature_image`") 9180 # verify the required parameter 'envelope_id' is set 9181 if ('envelope_id' not in params) or (params['envelope_id'] is None): 9182 raise ValueError("Missing the required parameter `envelope_id` when calling `get_recipient_signature_image`") 9183 # verify the required parameter 'recipient_id' is set 9184 if ('recipient_id' not in params) or (params['recipient_id'] is None): 9185 raise ValueError("Missing the required parameter `recipient_id` when calling `get_recipient_signature_image`") 9186 9187 9188 collection_formats = {} 9189 9190 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/signature_image'.replace('{format}', 'json') 9191 path_params = {} 9192 if 'account_id' in params: 9193 path_params['accountId'] = params['account_id'] 9194 if 'envelope_id' in params: 9195 path_params['envelopeId'] = params['envelope_id'] 9196 if 'recipient_id' in params: 9197 path_params['recipientId'] = params['recipient_id'] 9198 9199 query_params = {} 9200 if 'include_chrome' in params: 9201 query_params['include_chrome'] = params['include_chrome'] 9202 9203 header_params = {} 9204 9205 form_params = [] 9206 local_var_files = {} 9207 9208 body_params = None 9209 # HTTP header `Accept` 9210 header_params['Accept'] = self.api_client.\ 9211 select_header_accept(['image/gif']) 9212 9213 # Authentication setting 9214 auth_settings = [] 9215 9216 return self.api_client.call_api(resource_path, 'GET', 9217 path_params, 9218 query_params, 9219 header_params, 9220 body=body_params, 9221 post_params=form_params, 9222 files=local_var_files, 9223 response_type='file', 9224 auth_settings=auth_settings, 9225 callback=params.get('callback'), 9226 _return_http_data_only=params.get('_return_http_data_only'), 9227 _preload_content=params.get('_preload_content', True), 9228 _request_timeout=params.get('_request_timeout'), 9229 collection_formats=collection_formats) 9230 9231 def get_tabs_blob(self, account_id, envelope_id, **kwargs): 9232 """ 9233 Get encrypted tabs for envelope. 9234 9235 This method makes a synchronous HTTP request by default. To make an 9236 asynchronous HTTP request, please define a `callback` function 9237 to be invoked when receiving the response. 9238 >>> def callback_function(response): 9239 >>> pprint(response) 9240 >>> 9241 >>> thread = api.get_tabs_blob(account_id, envelope_id, callback=callback_function) 9242 9243 :param callback function: The callback function 9244 for asynchronous request. (optional) 9245 :param str account_id: The external account number (int) or account ID Guid. (required) 9246 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9247 :return: None 9248 If the method is called asynchronously, 9249 returns the request thread. 9250 """ 9251 kwargs['_return_http_data_only'] = True 9252 if kwargs.get('callback'): 9253 return self.get_tabs_blob_with_http_info(account_id, envelope_id, **kwargs) 9254 else: 9255 (data) = self.get_tabs_blob_with_http_info(account_id, envelope_id, **kwargs) 9256 return data 9257 9258 def get_tabs_blob_with_http_info(self, account_id, envelope_id, **kwargs): 9259 """ 9260 Get encrypted tabs for envelope. 9261 9262 This method makes a synchronous HTTP request by default. To make an 9263 asynchronous HTTP request, please define a `callback` function 9264 to be invoked when receiving the response. 9265 >>> def callback_function(response): 9266 >>> pprint(response) 9267 >>> 9268 >>> thread = api.get_tabs_blob_with_http_info(account_id, envelope_id, callback=callback_function) 9269 9270 :param callback function: The callback function 9271 for asynchronous request. (optional) 9272 :param str account_id: The external account number (int) or account ID Guid. (required) 9273 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9274 :return: None 9275 If the method is called asynchronously, 9276 returns the request thread. 9277 """ 9278 9279 all_params = ['account_id', 'envelope_id'] 9280 all_params.append('callback') 9281 all_params.append('_return_http_data_only') 9282 all_params.append('_preload_content') 9283 all_params.append('_request_timeout') 9284 9285 params = locals() 9286 for key, val in iteritems(params['kwargs']): 9287 if key not in all_params: 9288 raise TypeError( 9289 "Got an unexpected keyword argument '%s'" 9290 " to method get_tabs_blob" % key 9291 ) 9292 params[key] = val 9293 del params['kwargs'] 9294 # verify the required parameter 'account_id' is set 9295 if ('account_id' not in params) or (params['account_id'] is None): 9296 raise ValueError("Missing the required parameter `account_id` when calling `get_tabs_blob`") 9297 # verify the required parameter 'envelope_id' is set 9298 if ('envelope_id' not in params) or (params['envelope_id'] is None): 9299 raise ValueError("Missing the required parameter `envelope_id` when calling `get_tabs_blob`") 9300 9301 9302 collection_formats = {} 9303 9304 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/tabs_blob'.replace('{format}', 'json') 9305 path_params = {} 9306 if 'account_id' in params: 9307 path_params['accountId'] = params['account_id'] 9308 if 'envelope_id' in params: 9309 path_params['envelopeId'] = params['envelope_id'] 9310 9311 query_params = {} 9312 9313 header_params = {} 9314 9315 form_params = [] 9316 local_var_files = {} 9317 9318 body_params = None 9319 # HTTP header `Accept` 9320 header_params['Accept'] = self.api_client.\ 9321 select_header_accept(['application/json']) 9322 9323 # Authentication setting 9324 auth_settings = [] 9325 9326 return self.api_client.call_api(resource_path, 'GET', 9327 path_params, 9328 query_params, 9329 header_params, 9330 body=body_params, 9331 post_params=form_params, 9332 files=local_var_files, 9333 response_type=None, 9334 auth_settings=auth_settings, 9335 callback=params.get('callback'), 9336 _return_http_data_only=params.get('_return_http_data_only'), 9337 _preload_content=params.get('_preload_content', True), 9338 _request_timeout=params.get('_request_timeout'), 9339 collection_formats=collection_formats) 9340 9341 def get_template_delayed_routing_definition(self, account_id, template_id, workflow_step_id, **kwargs): 9342 """ 9343 Returns the delayed routing rules for a template's workflow step definition. 9344 This method makes a synchronous HTTP request by default. To make an 9345 asynchronous HTTP request, please define a `callback` function 9346 to be invoked when receiving the response. 9347 >>> def callback_function(response): 9348 >>> pprint(response) 9349 >>> 9350 >>> thread = api.get_template_delayed_routing_definition(account_id, template_id, workflow_step_id, callback=callback_function) 9351 9352 :param callback function: The callback function 9353 for asynchronous request. (optional) 9354 :param str account_id: The external account number (int) or account ID Guid. (required) 9355 :param str template_id: The ID of the template being accessed. (required) 9356 :param str workflow_step_id: (required) 9357 :return: DelayedRouting 9358 If the method is called asynchronously, 9359 returns the request thread. 9360 """ 9361 kwargs['_return_http_data_only'] = True 9362 if kwargs.get('callback'): 9363 return self.get_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 9364 else: 9365 (data) = self.get_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 9366 return data 9367 9368 def get_template_delayed_routing_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 9369 """ 9370 Returns the delayed routing rules for a template's workflow step definition. 9371 This method makes a synchronous HTTP request by default. To make an 9372 asynchronous HTTP request, please define a `callback` function 9373 to be invoked when receiving the response. 9374 >>> def callback_function(response): 9375 >>> pprint(response) 9376 >>> 9377 >>> thread = api.get_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 9378 9379 :param callback function: The callback function 9380 for asynchronous request. (optional) 9381 :param str account_id: The external account number (int) or account ID Guid. (required) 9382 :param str template_id: The ID of the template being accessed. (required) 9383 :param str workflow_step_id: (required) 9384 :return: DelayedRouting 9385 If the method is called asynchronously, 9386 returns the request thread. 9387 """ 9388 9389 all_params = ['account_id', 'template_id', 'workflow_step_id'] 9390 all_params.append('callback') 9391 all_params.append('_return_http_data_only') 9392 all_params.append('_preload_content') 9393 all_params.append('_request_timeout') 9394 9395 params = locals() 9396 for key, val in iteritems(params['kwargs']): 9397 if key not in all_params: 9398 raise TypeError( 9399 "Got an unexpected keyword argument '%s'" 9400 " to method get_template_delayed_routing_definition" % key 9401 ) 9402 params[key] = val 9403 del params['kwargs'] 9404 # verify the required parameter 'account_id' is set 9405 if ('account_id' not in params) or (params['account_id'] is None): 9406 raise ValueError("Missing the required parameter `account_id` when calling `get_template_delayed_routing_definition`") 9407 # verify the required parameter 'template_id' is set 9408 if ('template_id' not in params) or (params['template_id'] is None): 9409 raise ValueError("Missing the required parameter `template_id` when calling `get_template_delayed_routing_definition`") 9410 # verify the required parameter 'workflow_step_id' is set 9411 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 9412 raise ValueError("Missing the required parameter `workflow_step_id` when calling `get_template_delayed_routing_definition`") 9413 9414 9415 collection_formats = {} 9416 9417 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 9418 path_params = {} 9419 if 'account_id' in params: 9420 path_params['accountId'] = params['account_id'] 9421 if 'template_id' in params: 9422 path_params['templateId'] = params['template_id'] 9423 if 'workflow_step_id' in params: 9424 path_params['workflowStepId'] = params['workflow_step_id'] 9425 9426 query_params = {} 9427 9428 header_params = {} 9429 9430 form_params = [] 9431 local_var_files = {} 9432 9433 body_params = None 9434 # HTTP header `Accept` 9435 header_params['Accept'] = self.api_client.\ 9436 select_header_accept(['application/json']) 9437 9438 # Authentication setting 9439 auth_settings = [] 9440 9441 return self.api_client.call_api(resource_path, 'GET', 9442 path_params, 9443 query_params, 9444 header_params, 9445 body=body_params, 9446 post_params=form_params, 9447 files=local_var_files, 9448 response_type='DelayedRouting', 9449 auth_settings=auth_settings, 9450 callback=params.get('callback'), 9451 _return_http_data_only=params.get('_return_http_data_only'), 9452 _preload_content=params.get('_preload_content', True), 9453 _request_timeout=params.get('_request_timeout'), 9454 collection_formats=collection_formats) 9455 9456 def get_template_recipient_document_visibility(self, account_id, recipient_id, template_id, **kwargs): 9457 """ 9458 Returns document visibility for the recipients 9459 This method returns information about document visibility for a template recipient. 9460 This method makes a synchronous HTTP request by default. To make an 9461 asynchronous HTTP request, please define a `callback` function 9462 to be invoked when receiving the response. 9463 >>> def callback_function(response): 9464 >>> pprint(response) 9465 >>> 9466 >>> thread = api.get_template_recipient_document_visibility(account_id, recipient_id, template_id, callback=callback_function) 9467 9468 :param callback function: The callback function 9469 for asynchronous request. (optional) 9470 :param str account_id: The external account number (int) or account ID Guid. (required) 9471 :param str recipient_id: The ID of the recipient being accessed. (required) 9472 :param str template_id: The ID of the template being accessed. (required) 9473 :return: DocumentVisibilityList 9474 If the method is called asynchronously, 9475 returns the request thread. 9476 """ 9477 kwargs['_return_http_data_only'] = True 9478 if kwargs.get('callback'): 9479 return self.get_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, **kwargs) 9480 else: 9481 (data) = self.get_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, **kwargs) 9482 return data 9483 9484 def get_template_recipient_document_visibility_with_http_info(self, account_id, recipient_id, template_id, **kwargs): 9485 """ 9486 Returns document visibility for the recipients 9487 This method returns information about document visibility for a template recipient. 9488 This method makes a synchronous HTTP request by default. To make an 9489 asynchronous HTTP request, please define a `callback` function 9490 to be invoked when receiving the response. 9491 >>> def callback_function(response): 9492 >>> pprint(response) 9493 >>> 9494 >>> thread = api.get_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, callback=callback_function) 9495 9496 :param callback function: The callback function 9497 for asynchronous request. (optional) 9498 :param str account_id: The external account number (int) or account ID Guid. (required) 9499 :param str recipient_id: The ID of the recipient being accessed. (required) 9500 :param str template_id: The ID of the template being accessed. (required) 9501 :return: DocumentVisibilityList 9502 If the method is called asynchronously, 9503 returns the request thread. 9504 """ 9505 9506 all_params = ['account_id', 'recipient_id', 'template_id'] 9507 all_params.append('callback') 9508 all_params.append('_return_http_data_only') 9509 all_params.append('_preload_content') 9510 all_params.append('_request_timeout') 9511 9512 params = locals() 9513 for key, val in iteritems(params['kwargs']): 9514 if key not in all_params: 9515 raise TypeError( 9516 "Got an unexpected keyword argument '%s'" 9517 " to method get_template_recipient_document_visibility" % key 9518 ) 9519 params[key] = val 9520 del params['kwargs'] 9521 # verify the required parameter 'account_id' is set 9522 if ('account_id' not in params) or (params['account_id'] is None): 9523 raise ValueError("Missing the required parameter `account_id` when calling `get_template_recipient_document_visibility`") 9524 # verify the required parameter 'recipient_id' is set 9525 if ('recipient_id' not in params) or (params['recipient_id'] is None): 9526 raise ValueError("Missing the required parameter `recipient_id` when calling `get_template_recipient_document_visibility`") 9527 # verify the required parameter 'template_id' is set 9528 if ('template_id' not in params) or (params['template_id'] is None): 9529 raise ValueError("Missing the required parameter `template_id` when calling `get_template_recipient_document_visibility`") 9530 9531 9532 collection_formats = {} 9533 9534 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/recipients/{recipientId}/document_visibility'.replace('{format}', 'json') 9535 path_params = {} 9536 if 'account_id' in params: 9537 path_params['accountId'] = params['account_id'] 9538 if 'recipient_id' in params: 9539 path_params['recipientId'] = params['recipient_id'] 9540 if 'template_id' in params: 9541 path_params['templateId'] = params['template_id'] 9542 9543 query_params = {} 9544 9545 header_params = {} 9546 9547 form_params = [] 9548 local_var_files = {} 9549 9550 body_params = None 9551 # HTTP header `Accept` 9552 header_params['Accept'] = self.api_client.\ 9553 select_header_accept(['application/json']) 9554 9555 # Authentication setting 9556 auth_settings = [] 9557 9558 return self.api_client.call_api(resource_path, 'GET', 9559 path_params, 9560 query_params, 9561 header_params, 9562 body=body_params, 9563 post_params=form_params, 9564 files=local_var_files, 9565 response_type='DocumentVisibilityList', 9566 auth_settings=auth_settings, 9567 callback=params.get('callback'), 9568 _return_http_data_only=params.get('_return_http_data_only'), 9569 _preload_content=params.get('_preload_content', True), 9570 _request_timeout=params.get('_request_timeout'), 9571 collection_formats=collection_formats) 9572 9573 def get_template_scheduled_sending_definition(self, account_id, template_id, **kwargs): 9574 """ 9575 Returns the scheduled sending rules for a template's workflow definition. 9576 This method makes a synchronous HTTP request by default. To make an 9577 asynchronous HTTP request, please define a `callback` function 9578 to be invoked when receiving the response. 9579 >>> def callback_function(response): 9580 >>> pprint(response) 9581 >>> 9582 >>> thread = api.get_template_scheduled_sending_definition(account_id, template_id, callback=callback_function) 9583 9584 :param callback function: The callback function 9585 for asynchronous request. (optional) 9586 :param str account_id: The external account number (int) or account ID Guid. (required) 9587 :param str template_id: The ID of the template being accessed. (required) 9588 :return: ScheduledSending 9589 If the method is called asynchronously, 9590 returns the request thread. 9591 """ 9592 kwargs['_return_http_data_only'] = True 9593 if kwargs.get('callback'): 9594 return self.get_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 9595 else: 9596 (data) = self.get_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 9597 return data 9598 9599 def get_template_scheduled_sending_definition_with_http_info(self, account_id, template_id, **kwargs): 9600 """ 9601 Returns the scheduled sending rules for a template's workflow definition. 9602 This method makes a synchronous HTTP request by default. To make an 9603 asynchronous HTTP request, please define a `callback` function 9604 to be invoked when receiving the response. 9605 >>> def callback_function(response): 9606 >>> pprint(response) 9607 >>> 9608 >>> thread = api.get_template_scheduled_sending_definition_with_http_info(account_id, template_id, callback=callback_function) 9609 9610 :param callback function: The callback function 9611 for asynchronous request. (optional) 9612 :param str account_id: The external account number (int) or account ID Guid. (required) 9613 :param str template_id: The ID of the template being accessed. (required) 9614 :return: ScheduledSending 9615 If the method is called asynchronously, 9616 returns the request thread. 9617 """ 9618 9619 all_params = ['account_id', 'template_id'] 9620 all_params.append('callback') 9621 all_params.append('_return_http_data_only') 9622 all_params.append('_preload_content') 9623 all_params.append('_request_timeout') 9624 9625 params = locals() 9626 for key, val in iteritems(params['kwargs']): 9627 if key not in all_params: 9628 raise TypeError( 9629 "Got an unexpected keyword argument '%s'" 9630 " to method get_template_scheduled_sending_definition" % key 9631 ) 9632 params[key] = val 9633 del params['kwargs'] 9634 # verify the required parameter 'account_id' is set 9635 if ('account_id' not in params) or (params['account_id'] is None): 9636 raise ValueError("Missing the required parameter `account_id` when calling `get_template_scheduled_sending_definition`") 9637 # verify the required parameter 'template_id' is set 9638 if ('template_id' not in params) or (params['template_id'] is None): 9639 raise ValueError("Missing the required parameter `template_id` when calling `get_template_scheduled_sending_definition`") 9640 9641 9642 collection_formats = {} 9643 9644 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/scheduledSending'.replace('{format}', 'json') 9645 path_params = {} 9646 if 'account_id' in params: 9647 path_params['accountId'] = params['account_id'] 9648 if 'template_id' in params: 9649 path_params['templateId'] = params['template_id'] 9650 9651 query_params = {} 9652 9653 header_params = {} 9654 9655 form_params = [] 9656 local_var_files = {} 9657 9658 body_params = None 9659 # HTTP header `Accept` 9660 header_params['Accept'] = self.api_client.\ 9661 select_header_accept(['application/json']) 9662 9663 # Authentication setting 9664 auth_settings = [] 9665 9666 return self.api_client.call_api(resource_path, 'GET', 9667 path_params, 9668 query_params, 9669 header_params, 9670 body=body_params, 9671 post_params=form_params, 9672 files=local_var_files, 9673 response_type='ScheduledSending', 9674 auth_settings=auth_settings, 9675 callback=params.get('callback'), 9676 _return_http_data_only=params.get('_return_http_data_only'), 9677 _preload_content=params.get('_preload_content', True), 9678 _request_timeout=params.get('_request_timeout'), 9679 collection_formats=collection_formats) 9680 9681 def get_template_workflow_definition(self, account_id, template_id, **kwargs): 9682 """ 9683 Returns the workflow definition for a template. 9684 Returns template's workflow definition if the template specified by `templateId` has one. 9685 This method makes a synchronous HTTP request by default. To make an 9686 asynchronous HTTP request, please define a `callback` function 9687 to be invoked when receiving the response. 9688 >>> def callback_function(response): 9689 >>> pprint(response) 9690 >>> 9691 >>> thread = api.get_template_workflow_definition(account_id, template_id, callback=callback_function) 9692 9693 :param callback function: The callback function 9694 for asynchronous request. (optional) 9695 :param str account_id: The external account number (int) or account ID Guid. (required) 9696 :param str template_id: The ID of the template being accessed. (required) 9697 :return: Workflow 9698 If the method is called asynchronously, 9699 returns the request thread. 9700 """ 9701 kwargs['_return_http_data_only'] = True 9702 if kwargs.get('callback'): 9703 return self.get_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 9704 else: 9705 (data) = self.get_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 9706 return data 9707 9708 def get_template_workflow_definition_with_http_info(self, account_id, template_id, **kwargs): 9709 """ 9710 Returns the workflow definition for a template. 9711 Returns template's workflow definition if the template specified by `templateId` has one. 9712 This method makes a synchronous HTTP request by default. To make an 9713 asynchronous HTTP request, please define a `callback` function 9714 to be invoked when receiving the response. 9715 >>> def callback_function(response): 9716 >>> pprint(response) 9717 >>> 9718 >>> thread = api.get_template_workflow_definition_with_http_info(account_id, template_id, callback=callback_function) 9719 9720 :param callback function: The callback function 9721 for asynchronous request. (optional) 9722 :param str account_id: The external account number (int) or account ID Guid. (required) 9723 :param str template_id: The ID of the template being accessed. (required) 9724 :return: Workflow 9725 If the method is called asynchronously, 9726 returns the request thread. 9727 """ 9728 9729 all_params = ['account_id', 'template_id'] 9730 all_params.append('callback') 9731 all_params.append('_return_http_data_only') 9732 all_params.append('_preload_content') 9733 all_params.append('_request_timeout') 9734 9735 params = locals() 9736 for key, val in iteritems(params['kwargs']): 9737 if key not in all_params: 9738 raise TypeError( 9739 "Got an unexpected keyword argument '%s'" 9740 " to method get_template_workflow_definition" % key 9741 ) 9742 params[key] = val 9743 del params['kwargs'] 9744 # verify the required parameter 'account_id' is set 9745 if ('account_id' not in params) or (params['account_id'] is None): 9746 raise ValueError("Missing the required parameter `account_id` when calling `get_template_workflow_definition`") 9747 # verify the required parameter 'template_id' is set 9748 if ('template_id' not in params) or (params['template_id'] is None): 9749 raise ValueError("Missing the required parameter `template_id` when calling `get_template_workflow_definition`") 9750 9751 9752 collection_formats = {} 9753 9754 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow'.replace('{format}', 'json') 9755 path_params = {} 9756 if 'account_id' in params: 9757 path_params['accountId'] = params['account_id'] 9758 if 'template_id' in params: 9759 path_params['templateId'] = params['template_id'] 9760 9761 query_params = {} 9762 9763 header_params = {} 9764 9765 form_params = [] 9766 local_var_files = {} 9767 9768 body_params = None 9769 # HTTP header `Accept` 9770 header_params['Accept'] = self.api_client.\ 9771 select_header_accept(['application/json']) 9772 9773 # Authentication setting 9774 auth_settings = [] 9775 9776 return self.api_client.call_api(resource_path, 'GET', 9777 path_params, 9778 query_params, 9779 header_params, 9780 body=body_params, 9781 post_params=form_params, 9782 files=local_var_files, 9783 response_type='Workflow', 9784 auth_settings=auth_settings, 9785 callback=params.get('callback'), 9786 _return_http_data_only=params.get('_return_http_data_only'), 9787 _preload_content=params.get('_preload_content', True), 9788 _request_timeout=params.get('_request_timeout'), 9789 collection_formats=collection_formats) 9790 9791 def get_template_workflow_step_definition(self, account_id, template_id, workflow_step_id, **kwargs): 9792 """ 9793 Returns the workflow step definition for a template by step id. 9794 This method makes a synchronous HTTP request by default. To make an 9795 asynchronous HTTP request, please define a `callback` function 9796 to be invoked when receiving the response. 9797 >>> def callback_function(response): 9798 >>> pprint(response) 9799 >>> 9800 >>> thread = api.get_template_workflow_step_definition(account_id, template_id, workflow_step_id, callback=callback_function) 9801 9802 :param callback function: The callback function 9803 for asynchronous request. (optional) 9804 :param str account_id: The external account number (int) or account ID Guid. (required) 9805 :param str template_id: The ID of the template being accessed. (required) 9806 :param str workflow_step_id: (required) 9807 :return: WorkflowStep 9808 If the method is called asynchronously, 9809 returns the request thread. 9810 """ 9811 kwargs['_return_http_data_only'] = True 9812 if kwargs.get('callback'): 9813 return self.get_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 9814 else: 9815 (data) = self.get_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 9816 return data 9817 9818 def get_template_workflow_step_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 9819 """ 9820 Returns the workflow step definition for a template by step id. 9821 This method makes a synchronous HTTP request by default. To make an 9822 asynchronous HTTP request, please define a `callback` function 9823 to be invoked when receiving the response. 9824 >>> def callback_function(response): 9825 >>> pprint(response) 9826 >>> 9827 >>> thread = api.get_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 9828 9829 :param callback function: The callback function 9830 for asynchronous request. (optional) 9831 :param str account_id: The external account number (int) or account ID Guid. (required) 9832 :param str template_id: The ID of the template being accessed. (required) 9833 :param str workflow_step_id: (required) 9834 :return: WorkflowStep 9835 If the method is called asynchronously, 9836 returns the request thread. 9837 """ 9838 9839 all_params = ['account_id', 'template_id', 'workflow_step_id'] 9840 all_params.append('callback') 9841 all_params.append('_return_http_data_only') 9842 all_params.append('_preload_content') 9843 all_params.append('_request_timeout') 9844 9845 params = locals() 9846 for key, val in iteritems(params['kwargs']): 9847 if key not in all_params: 9848 raise TypeError( 9849 "Got an unexpected keyword argument '%s'" 9850 " to method get_template_workflow_step_definition" % key 9851 ) 9852 params[key] = val 9853 del params['kwargs'] 9854 # verify the required parameter 'account_id' is set 9855 if ('account_id' not in params) or (params['account_id'] is None): 9856 raise ValueError("Missing the required parameter `account_id` when calling `get_template_workflow_step_definition`") 9857 # verify the required parameter 'template_id' is set 9858 if ('template_id' not in params) or (params['template_id'] is None): 9859 raise ValueError("Missing the required parameter `template_id` when calling `get_template_workflow_step_definition`") 9860 # verify the required parameter 'workflow_step_id' is set 9861 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 9862 raise ValueError("Missing the required parameter `workflow_step_id` when calling `get_template_workflow_step_definition`") 9863 9864 9865 collection_formats = {} 9866 9867 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 9868 path_params = {} 9869 if 'account_id' in params: 9870 path_params['accountId'] = params['account_id'] 9871 if 'template_id' in params: 9872 path_params['templateId'] = params['template_id'] 9873 if 'workflow_step_id' in params: 9874 path_params['workflowStepId'] = params['workflow_step_id'] 9875 9876 query_params = {} 9877 9878 header_params = {} 9879 9880 form_params = [] 9881 local_var_files = {} 9882 9883 body_params = None 9884 # HTTP header `Accept` 9885 header_params['Accept'] = self.api_client.\ 9886 select_header_accept(['application/json']) 9887 9888 # Authentication setting 9889 auth_settings = [] 9890 9891 return self.api_client.call_api(resource_path, 'GET', 9892 path_params, 9893 query_params, 9894 header_params, 9895 body=body_params, 9896 post_params=form_params, 9897 files=local_var_files, 9898 response_type='WorkflowStep', 9899 auth_settings=auth_settings, 9900 callback=params.get('callback'), 9901 _return_http_data_only=params.get('_return_http_data_only'), 9902 _preload_content=params.get('_preload_content', True), 9903 _request_timeout=params.get('_request_timeout'), 9904 collection_formats=collection_formats) 9905 9906 def list_audit_events(self, account_id, envelope_id, **kwargs): 9907 """ 9908 Gets the envelope audit events for an envelope. 9909 Gets the envelope audit events for the specified envelope. 9910 This method makes a synchronous HTTP request by default. To make an 9911 asynchronous HTTP request, please define a `callback` function 9912 to be invoked when receiving the response. 9913 >>> def callback_function(response): 9914 >>> pprint(response) 9915 >>> 9916 >>> thread = api.list_audit_events(account_id, envelope_id, callback=callback_function) 9917 9918 :param callback function: The callback function 9919 for asynchronous request. (optional) 9920 :param str account_id: The external account number (int) or account ID Guid. (required) 9921 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9922 :return: EnvelopeAuditEventResponse 9923 If the method is called asynchronously, 9924 returns the request thread. 9925 """ 9926 kwargs['_return_http_data_only'] = True 9927 if kwargs.get('callback'): 9928 return self.list_audit_events_with_http_info(account_id, envelope_id, **kwargs) 9929 else: 9930 (data) = self.list_audit_events_with_http_info(account_id, envelope_id, **kwargs) 9931 return data 9932 9933 def list_audit_events_with_http_info(self, account_id, envelope_id, **kwargs): 9934 """ 9935 Gets the envelope audit events for an envelope. 9936 Gets the envelope audit events for the specified envelope. 9937 This method makes a synchronous HTTP request by default. To make an 9938 asynchronous HTTP request, please define a `callback` function 9939 to be invoked when receiving the response. 9940 >>> def callback_function(response): 9941 >>> pprint(response) 9942 >>> 9943 >>> thread = api.list_audit_events_with_http_info(account_id, envelope_id, callback=callback_function) 9944 9945 :param callback function: The callback function 9946 for asynchronous request. (optional) 9947 :param str account_id: The external account number (int) or account ID Guid. (required) 9948 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9949 :return: EnvelopeAuditEventResponse 9950 If the method is called asynchronously, 9951 returns the request thread. 9952 """ 9953 9954 all_params = ['account_id', 'envelope_id'] 9955 all_params.append('callback') 9956 all_params.append('_return_http_data_only') 9957 all_params.append('_preload_content') 9958 all_params.append('_request_timeout') 9959 9960 params = locals() 9961 for key, val in iteritems(params['kwargs']): 9962 if key not in all_params: 9963 raise TypeError( 9964 "Got an unexpected keyword argument '%s'" 9965 " to method list_audit_events" % key 9966 ) 9967 params[key] = val 9968 del params['kwargs'] 9969 # verify the required parameter 'account_id' is set 9970 if ('account_id' not in params) or (params['account_id'] is None): 9971 raise ValueError("Missing the required parameter `account_id` when calling `list_audit_events`") 9972 # verify the required parameter 'envelope_id' is set 9973 if ('envelope_id' not in params) or (params['envelope_id'] is None): 9974 raise ValueError("Missing the required parameter `envelope_id` when calling `list_audit_events`") 9975 9976 9977 collection_formats = {} 9978 9979 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/audit_events'.replace('{format}', 'json') 9980 path_params = {} 9981 if 'account_id' in params: 9982 path_params['accountId'] = params['account_id'] 9983 if 'envelope_id' in params: 9984 path_params['envelopeId'] = params['envelope_id'] 9985 9986 query_params = {} 9987 9988 header_params = {} 9989 9990 form_params = [] 9991 local_var_files = {} 9992 9993 body_params = None 9994 # HTTP header `Accept` 9995 header_params['Accept'] = self.api_client.\ 9996 select_header_accept(['application/json']) 9997 9998 # Authentication setting 9999 auth_settings = [] 10000 10001 return self.api_client.call_api(resource_path, 'GET', 10002 path_params, 10003 query_params, 10004 header_params, 10005 body=body_params, 10006 post_params=form_params, 10007 files=local_var_files, 10008 response_type='EnvelopeAuditEventResponse', 10009 auth_settings=auth_settings, 10010 callback=params.get('callback'), 10011 _return_http_data_only=params.get('_return_http_data_only'), 10012 _preload_content=params.get('_preload_content', True), 10013 _request_timeout=params.get('_request_timeout'), 10014 collection_formats=collection_formats) 10015 10016 def list_custom_fields(self, account_id, envelope_id, **kwargs): 10017 """ 10018 Gets the custom field information for the specified envelope. 10019 Retrieves the custom field information for the specified envelope. You can use these fields in the envelopes for your account to record information about the envelope, help search for envelopes, and track information. The envelope custom fields are shown in the Envelope Settings section when a user is creating an envelope in the DocuSign member console. The envelope custom fields are not seen by the envelope recipients. There are two types of envelope custom fields, text, and list. A text custom field lets the sender enter the value for the field. With a list custom field, the sender selects the value of the field from a pre-made list. 10020 This method makes a synchronous HTTP request by default. To make an 10021 asynchronous HTTP request, please define a `callback` function 10022 to be invoked when receiving the response. 10023 >>> def callback_function(response): 10024 >>> pprint(response) 10025 >>> 10026 >>> thread = api.list_custom_fields(account_id, envelope_id, callback=callback_function) 10027 10028 :param callback function: The callback function 10029 for asynchronous request. (optional) 10030 :param str account_id: The external account number (int) or account ID Guid. (required) 10031 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10032 :return: CustomFieldsEnvelope 10033 If the method is called asynchronously, 10034 returns the request thread. 10035 """ 10036 kwargs['_return_http_data_only'] = True 10037 if kwargs.get('callback'): 10038 return self.list_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 10039 else: 10040 (data) = self.list_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 10041 return data 10042 10043 def list_custom_fields_with_http_info(self, account_id, envelope_id, **kwargs): 10044 """ 10045 Gets the custom field information for the specified envelope. 10046 Retrieves the custom field information for the specified envelope. You can use these fields in the envelopes for your account to record information about the envelope, help search for envelopes, and track information. The envelope custom fields are shown in the Envelope Settings section when a user is creating an envelope in the DocuSign member console. The envelope custom fields are not seen by the envelope recipients. There are two types of envelope custom fields, text, and list. A text custom field lets the sender enter the value for the field. With a list custom field, the sender selects the value of the field from a pre-made list. 10047 This method makes a synchronous HTTP request by default. To make an 10048 asynchronous HTTP request, please define a `callback` function 10049 to be invoked when receiving the response. 10050 >>> def callback_function(response): 10051 >>> pprint(response) 10052 >>> 10053 >>> thread = api.list_custom_fields_with_http_info(account_id, envelope_id, callback=callback_function) 10054 10055 :param callback function: The callback function 10056 for asynchronous request. (optional) 10057 :param str account_id: The external account number (int) or account ID Guid. (required) 10058 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10059 :return: CustomFieldsEnvelope 10060 If the method is called asynchronously, 10061 returns the request thread. 10062 """ 10063 10064 all_params = ['account_id', 'envelope_id'] 10065 all_params.append('callback') 10066 all_params.append('_return_http_data_only') 10067 all_params.append('_preload_content') 10068 all_params.append('_request_timeout') 10069 10070 params = locals() 10071 for key, val in iteritems(params['kwargs']): 10072 if key not in all_params: 10073 raise TypeError( 10074 "Got an unexpected keyword argument '%s'" 10075 " to method list_custom_fields" % key 10076 ) 10077 params[key] = val 10078 del params['kwargs'] 10079 # verify the required parameter 'account_id' is set 10080 if ('account_id' not in params) or (params['account_id'] is None): 10081 raise ValueError("Missing the required parameter `account_id` when calling `list_custom_fields`") 10082 # verify the required parameter 'envelope_id' is set 10083 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10084 raise ValueError("Missing the required parameter `envelope_id` when calling `list_custom_fields`") 10085 10086 10087 collection_formats = {} 10088 10089 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/custom_fields'.replace('{format}', 'json') 10090 path_params = {} 10091 if 'account_id' in params: 10092 path_params['accountId'] = params['account_id'] 10093 if 'envelope_id' in params: 10094 path_params['envelopeId'] = params['envelope_id'] 10095 10096 query_params = {} 10097 10098 header_params = {} 10099 10100 form_params = [] 10101 local_var_files = {} 10102 10103 body_params = None 10104 # HTTP header `Accept` 10105 header_params['Accept'] = self.api_client.\ 10106 select_header_accept(['application/json']) 10107 10108 # Authentication setting 10109 auth_settings = [] 10110 10111 return self.api_client.call_api(resource_path, 'GET', 10112 path_params, 10113 query_params, 10114 header_params, 10115 body=body_params, 10116 post_params=form_params, 10117 files=local_var_files, 10118 response_type='CustomFieldsEnvelope', 10119 auth_settings=auth_settings, 10120 callback=params.get('callback'), 10121 _return_http_data_only=params.get('_return_http_data_only'), 10122 _preload_content=params.get('_preload_content', True), 10123 _request_timeout=params.get('_request_timeout'), 10124 collection_formats=collection_formats) 10125 10126 def list_document_fields(self, account_id, document_id, envelope_id, **kwargs): 10127 """ 10128 Gets the custom document fields from an existing envelope document. 10129 Retrieves the custom document field information from an existing envelope document. 10130 This method makes a synchronous HTTP request by default. To make an 10131 asynchronous HTTP request, please define a `callback` function 10132 to be invoked when receiving the response. 10133 >>> def callback_function(response): 10134 >>> pprint(response) 10135 >>> 10136 >>> thread = api.list_document_fields(account_id, document_id, envelope_id, callback=callback_function) 10137 10138 :param callback function: The callback function 10139 for asynchronous request. (optional) 10140 :param str account_id: The external account number (int) or account ID Guid. (required) 10141 :param str document_id: The ID of the document being accessed. (required) 10142 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10143 :return: DocumentFieldsInformation 10144 If the method is called asynchronously, 10145 returns the request thread. 10146 """ 10147 kwargs['_return_http_data_only'] = True 10148 if kwargs.get('callback'): 10149 return self.list_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 10150 else: 10151 (data) = self.list_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 10152 return data 10153 10154 def list_document_fields_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 10155 """ 10156 Gets the custom document fields from an existing envelope document. 10157 Retrieves the custom document field information from an existing envelope document. 10158 This method makes a synchronous HTTP request by default. To make an 10159 asynchronous HTTP request, please define a `callback` function 10160 to be invoked when receiving the response. 10161 >>> def callback_function(response): 10162 >>> pprint(response) 10163 >>> 10164 >>> thread = api.list_document_fields_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 10165 10166 :param callback function: The callback function 10167 for asynchronous request. (optional) 10168 :param str account_id: The external account number (int) or account ID Guid. (required) 10169 :param str document_id: The ID of the document being accessed. (required) 10170 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10171 :return: DocumentFieldsInformation 10172 If the method is called asynchronously, 10173 returns the request thread. 10174 """ 10175 10176 all_params = ['account_id', 'document_id', 'envelope_id'] 10177 all_params.append('callback') 10178 all_params.append('_return_http_data_only') 10179 all_params.append('_preload_content') 10180 all_params.append('_request_timeout') 10181 10182 params = locals() 10183 for key, val in iteritems(params['kwargs']): 10184 if key not in all_params: 10185 raise TypeError( 10186 "Got an unexpected keyword argument '%s'" 10187 " to method list_document_fields" % key 10188 ) 10189 params[key] = val 10190 del params['kwargs'] 10191 # verify the required parameter 'account_id' is set 10192 if ('account_id' not in params) or (params['account_id'] is None): 10193 raise ValueError("Missing the required parameter `account_id` when calling `list_document_fields`") 10194 # verify the required parameter 'document_id' is set 10195 if ('document_id' not in params) or (params['document_id'] is None): 10196 raise ValueError("Missing the required parameter `document_id` when calling `list_document_fields`") 10197 # verify the required parameter 'envelope_id' is set 10198 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10199 raise ValueError("Missing the required parameter `envelope_id` when calling `list_document_fields`") 10200 10201 10202 collection_formats = {} 10203 10204 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/fields'.replace('{format}', 'json') 10205 path_params = {} 10206 if 'account_id' in params: 10207 path_params['accountId'] = params['account_id'] 10208 if 'document_id' in params: 10209 path_params['documentId'] = params['document_id'] 10210 if 'envelope_id' in params: 10211 path_params['envelopeId'] = params['envelope_id'] 10212 10213 query_params = {} 10214 10215 header_params = {} 10216 10217 form_params = [] 10218 local_var_files = {} 10219 10220 body_params = None 10221 # HTTP header `Accept` 10222 header_params['Accept'] = self.api_client.\ 10223 select_header_accept(['application/json']) 10224 10225 # Authentication setting 10226 auth_settings = [] 10227 10228 return self.api_client.call_api(resource_path, 'GET', 10229 path_params, 10230 query_params, 10231 header_params, 10232 body=body_params, 10233 post_params=form_params, 10234 files=local_var_files, 10235 response_type='DocumentFieldsInformation', 10236 auth_settings=auth_settings, 10237 callback=params.get('callback'), 10238 _return_http_data_only=params.get('_return_http_data_only'), 10239 _preload_content=params.get('_preload_content', True), 10240 _request_timeout=params.get('_request_timeout'), 10241 collection_formats=collection_formats) 10242 10243 def list_documents(self, account_id, envelope_id, **kwargs): 10244 """ 10245 Gets a list of envelope documents. 10246 Retrieves a list of documents associated with the specified envelope. 10247 This method makes a synchronous HTTP request by default. To make an 10248 asynchronous HTTP request, please define a `callback` function 10249 to be invoked when receiving the response. 10250 >>> def callback_function(response): 10251 >>> pprint(response) 10252 >>> 10253 >>> thread = api.list_documents(account_id, envelope_id, callback=callback_function) 10254 10255 :param callback function: The callback function 10256 for asynchronous request. (optional) 10257 :param str account_id: The external account number (int) or account ID Guid. (required) 10258 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10259 :param str documents_by_userid: 10260 :param str include_docgen_formfields: 10261 :param str include_document_size: 10262 :param str include_metadata: 10263 :param str include_tabs: 10264 :param str recipient_id: 10265 :param str shared_user_id: 10266 :return: EnvelopeDocumentsResult 10267 If the method is called asynchronously, 10268 returns the request thread. 10269 """ 10270 kwargs['_return_http_data_only'] = True 10271 if kwargs.get('callback'): 10272 return self.list_documents_with_http_info(account_id, envelope_id, **kwargs) 10273 else: 10274 (data) = self.list_documents_with_http_info(account_id, envelope_id, **kwargs) 10275 return data 10276 10277 def list_documents_with_http_info(self, account_id, envelope_id, **kwargs): 10278 """ 10279 Gets a list of envelope documents. 10280 Retrieves a list of documents associated with the specified envelope. 10281 This method makes a synchronous HTTP request by default. To make an 10282 asynchronous HTTP request, please define a `callback` function 10283 to be invoked when receiving the response. 10284 >>> def callback_function(response): 10285 >>> pprint(response) 10286 >>> 10287 >>> thread = api.list_documents_with_http_info(account_id, envelope_id, callback=callback_function) 10288 10289 :param callback function: The callback function 10290 for asynchronous request. (optional) 10291 :param str account_id: The external account number (int) or account ID Guid. (required) 10292 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10293 :param str documents_by_userid: 10294 :param str include_docgen_formfields: 10295 :param str include_document_size: 10296 :param str include_metadata: 10297 :param str include_tabs: 10298 :param str recipient_id: 10299 :param str shared_user_id: 10300 :return: EnvelopeDocumentsResult 10301 If the method is called asynchronously, 10302 returns the request thread. 10303 """ 10304 10305 all_params = ['account_id', 'envelope_id', 'documents_by_userid', 'include_docgen_formfields', 'include_document_size', 'include_metadata', 'include_tabs', 'recipient_id', 'shared_user_id'] 10306 all_params.append('callback') 10307 all_params.append('_return_http_data_only') 10308 all_params.append('_preload_content') 10309 all_params.append('_request_timeout') 10310 10311 params = locals() 10312 for key, val in iteritems(params['kwargs']): 10313 if key not in all_params: 10314 raise TypeError( 10315 "Got an unexpected keyword argument '%s'" 10316 " to method list_documents" % key 10317 ) 10318 params[key] = val 10319 del params['kwargs'] 10320 # verify the required parameter 'account_id' is set 10321 if ('account_id' not in params) or (params['account_id'] is None): 10322 raise ValueError("Missing the required parameter `account_id` when calling `list_documents`") 10323 # verify the required parameter 'envelope_id' is set 10324 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10325 raise ValueError("Missing the required parameter `envelope_id` when calling `list_documents`") 10326 10327 10328 collection_formats = {} 10329 10330 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents'.replace('{format}', 'json') 10331 path_params = {} 10332 if 'account_id' in params: 10333 path_params['accountId'] = params['account_id'] 10334 if 'envelope_id' in params: 10335 path_params['envelopeId'] = params['envelope_id'] 10336 10337 query_params = {} 10338 if 'documents_by_userid' in params: 10339 query_params['documents_by_userid'] = params['documents_by_userid'] 10340 if 'include_docgen_formfields' in params: 10341 query_params['include_docgen_formfields'] = params['include_docgen_formfields'] 10342 if 'include_document_size' in params: 10343 query_params['include_document_size'] = params['include_document_size'] 10344 if 'include_metadata' in params: 10345 query_params['include_metadata'] = params['include_metadata'] 10346 if 'include_tabs' in params: 10347 query_params['include_tabs'] = params['include_tabs'] 10348 if 'recipient_id' in params: 10349 query_params['recipient_id'] = params['recipient_id'] 10350 if 'shared_user_id' in params: 10351 query_params['shared_user_id'] = params['shared_user_id'] 10352 10353 header_params = {} 10354 10355 form_params = [] 10356 local_var_files = {} 10357 10358 body_params = None 10359 # HTTP header `Accept` 10360 header_params['Accept'] = self.api_client.\ 10361 select_header_accept(['application/json']) 10362 10363 # Authentication setting 10364 auth_settings = [] 10365 10366 return self.api_client.call_api(resource_path, 'GET', 10367 path_params, 10368 query_params, 10369 header_params, 10370 body=body_params, 10371 post_params=form_params, 10372 files=local_var_files, 10373 response_type='EnvelopeDocumentsResult', 10374 auth_settings=auth_settings, 10375 callback=params.get('callback'), 10376 _return_http_data_only=params.get('_return_http_data_only'), 10377 _preload_content=params.get('_preload_content', True), 10378 _request_timeout=params.get('_request_timeout'), 10379 collection_formats=collection_formats) 10380 10381 def list_recipients(self, account_id, envelope_id, **kwargs): 10382 """ 10383 Gets the status of recipients for an envelope. 10384 Retrieves the status of all recipients in a single envelope and identifies the current recipient in the routing list. The `currentRoutingOrder` property of the response contains the `routingOrder` value of the current recipient indicating that the envelope has been sent to the recipient, but the recipient has not completed their actions. 10385 This method makes a synchronous HTTP request by default. To make an 10386 asynchronous HTTP request, please define a `callback` function 10387 to be invoked when receiving the response. 10388 >>> def callback_function(response): 10389 >>> pprint(response) 10390 >>> 10391 >>> thread = api.list_recipients(account_id, envelope_id, callback=callback_function) 10392 10393 :param callback function: The callback function 10394 for asynchronous request. (optional) 10395 :param str account_id: The external account number (int) or account ID Guid. (required) 10396 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10397 :param str include_anchor_tab_locations: When set to **true** and `include_tabs` is set to **true**, all tabs with anchor tab properties are included in the response. 10398 :param str include_extended: When set to **true**, the extended properties are included in the response. 10399 :param str include_metadata: 10400 :param str include_tabs: When set to **true**, the tab information associated with the recipient is included in the response. 10401 :return: Recipients 10402 If the method is called asynchronously, 10403 returns the request thread. 10404 """ 10405 kwargs['_return_http_data_only'] = True 10406 if kwargs.get('callback'): 10407 return self.list_recipients_with_http_info(account_id, envelope_id, **kwargs) 10408 else: 10409 (data) = self.list_recipients_with_http_info(account_id, envelope_id, **kwargs) 10410 return data 10411 10412 def list_recipients_with_http_info(self, account_id, envelope_id, **kwargs): 10413 """ 10414 Gets the status of recipients for an envelope. 10415 Retrieves the status of all recipients in a single envelope and identifies the current recipient in the routing list. The `currentRoutingOrder` property of the response contains the `routingOrder` value of the current recipient indicating that the envelope has been sent to the recipient, but the recipient has not completed their actions. 10416 This method makes a synchronous HTTP request by default. To make an 10417 asynchronous HTTP request, please define a `callback` function 10418 to be invoked when receiving the response. 10419 >>> def callback_function(response): 10420 >>> pprint(response) 10421 >>> 10422 >>> thread = api.list_recipients_with_http_info(account_id, envelope_id, callback=callback_function) 10423 10424 :param callback function: The callback function 10425 for asynchronous request. (optional) 10426 :param str account_id: The external account number (int) or account ID Guid. (required) 10427 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10428 :param str include_anchor_tab_locations: When set to **true** and `include_tabs` is set to **true**, all tabs with anchor tab properties are included in the response. 10429 :param str include_extended: When set to **true**, the extended properties are included in the response. 10430 :param str include_metadata: 10431 :param str include_tabs: When set to **true**, the tab information associated with the recipient is included in the response. 10432 :return: Recipients 10433 If the method is called asynchronously, 10434 returns the request thread. 10435 """ 10436 10437 all_params = ['account_id', 'envelope_id', 'include_anchor_tab_locations', 'include_extended', 'include_metadata', 'include_tabs'] 10438 all_params.append('callback') 10439 all_params.append('_return_http_data_only') 10440 all_params.append('_preload_content') 10441 all_params.append('_request_timeout') 10442 10443 params = locals() 10444 for key, val in iteritems(params['kwargs']): 10445 if key not in all_params: 10446 raise TypeError( 10447 "Got an unexpected keyword argument '%s'" 10448 " to method list_recipients" % key 10449 ) 10450 params[key] = val 10451 del params['kwargs'] 10452 # verify the required parameter 'account_id' is set 10453 if ('account_id' not in params) or (params['account_id'] is None): 10454 raise ValueError("Missing the required parameter `account_id` when calling `list_recipients`") 10455 # verify the required parameter 'envelope_id' is set 10456 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10457 raise ValueError("Missing the required parameter `envelope_id` when calling `list_recipients`") 10458 10459 10460 collection_formats = {} 10461 10462 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients'.replace('{format}', 'json') 10463 path_params = {} 10464 if 'account_id' in params: 10465 path_params['accountId'] = params['account_id'] 10466 if 'envelope_id' in params: 10467 path_params['envelopeId'] = params['envelope_id'] 10468 10469 query_params = {} 10470 if 'include_anchor_tab_locations' in params: 10471 query_params['include_anchor_tab_locations'] = params['include_anchor_tab_locations'] 10472 if 'include_extended' in params: 10473 query_params['include_extended'] = params['include_extended'] 10474 if 'include_metadata' in params: 10475 query_params['include_metadata'] = params['include_metadata'] 10476 if 'include_tabs' in params: 10477 query_params['include_tabs'] = params['include_tabs'] 10478 10479 header_params = {} 10480 10481 form_params = [] 10482 local_var_files = {} 10483 10484 body_params = None 10485 # HTTP header `Accept` 10486 header_params['Accept'] = self.api_client.\ 10487 select_header_accept(['application/json']) 10488 10489 # Authentication setting 10490 auth_settings = [] 10491 10492 return self.api_client.call_api(resource_path, 'GET', 10493 path_params, 10494 query_params, 10495 header_params, 10496 body=body_params, 10497 post_params=form_params, 10498 files=local_var_files, 10499 response_type='Recipients', 10500 auth_settings=auth_settings, 10501 callback=params.get('callback'), 10502 _return_http_data_only=params.get('_return_http_data_only'), 10503 _preload_content=params.get('_preload_content', True), 10504 _request_timeout=params.get('_request_timeout'), 10505 collection_formats=collection_formats) 10506 10507 def list_status(self, account_id, **kwargs): 10508 """ 10509 Gets the envelope status for the specified envelopes. 10510 Retrieves the envelope status for the specified envelopes. 10511 This method makes a synchronous HTTP request by default. To make an 10512 asynchronous HTTP request, please define a `callback` function 10513 to be invoked when receiving the response. 10514 >>> def callback_function(response): 10515 >>> pprint(response) 10516 >>> 10517 >>> thread = api.list_status(account_id, callback=callback_function) 10518 10519 :param callback function: The callback function 10520 for asynchronous request. (optional) 10521 :param str account_id: The external account number (int) or account ID Guid. (required) 10522 :param str ac_status: 10523 :param str block: 10524 :param str count: 10525 :param str email: 10526 :param str envelope_ids: 10527 :param str from_date: 10528 :param str from_to_status: 10529 :param str start_position: 10530 :param str status: 10531 :param str to_date: 10532 :param str transaction_ids: 10533 :param str user_name: 10534 :param EnvelopeIdsRequest envelope_ids_request: 10535 :return: EnvelopesInformation 10536 If the method is called asynchronously, 10537 returns the request thread. 10538 """ 10539 kwargs['_return_http_data_only'] = True 10540 if kwargs.get('callback'): 10541 return self.list_status_with_http_info(account_id, **kwargs) 10542 else: 10543 (data) = self.list_status_with_http_info(account_id, **kwargs) 10544 return data 10545 10546 def list_status_with_http_info(self, account_id, **kwargs): 10547 """ 10548 Gets the envelope status for the specified envelopes. 10549 Retrieves the envelope status for the specified envelopes. 10550 This method makes a synchronous HTTP request by default. To make an 10551 asynchronous HTTP request, please define a `callback` function 10552 to be invoked when receiving the response. 10553 >>> def callback_function(response): 10554 >>> pprint(response) 10555 >>> 10556 >>> thread = api.list_status_with_http_info(account_id, callback=callback_function) 10557 10558 :param callback function: The callback function 10559 for asynchronous request. (optional) 10560 :param str account_id: The external account number (int) or account ID Guid. (required) 10561 :param str ac_status: 10562 :param str block: 10563 :param str count: 10564 :param str email: 10565 :param str envelope_ids: 10566 :param str from_date: 10567 :param str from_to_status: 10568 :param str start_position: 10569 :param str status: 10570 :param str to_date: 10571 :param str transaction_ids: 10572 :param str user_name: 10573 :param EnvelopeIdsRequest envelope_ids_request: 10574 :return: EnvelopesInformation 10575 If the method is called asynchronously, 10576 returns the request thread. 10577 """ 10578 10579 all_params = ['account_id', 'ac_status', 'block', 'count', 'email', 'envelope_ids', 'from_date', 'from_to_status', 'start_position', 'status', 'to_date', 'transaction_ids', 'user_name', 'envelope_ids_request'] 10580 all_params.append('callback') 10581 all_params.append('_return_http_data_only') 10582 all_params.append('_preload_content') 10583 all_params.append('_request_timeout') 10584 10585 params = locals() 10586 for key, val in iteritems(params['kwargs']): 10587 if key not in all_params: 10588 raise TypeError( 10589 "Got an unexpected keyword argument '%s'" 10590 " to method list_status" % key 10591 ) 10592 params[key] = val 10593 del params['kwargs'] 10594 # verify the required parameter 'account_id' is set 10595 if ('account_id' not in params) or (params['account_id'] is None): 10596 raise ValueError("Missing the required parameter `account_id` when calling `list_status`") 10597 10598 10599 collection_formats = {} 10600 10601 resource_path = '/v2.1/accounts/{accountId}/envelopes/status'.replace('{format}', 'json') 10602 path_params = {} 10603 if 'account_id' in params: 10604 path_params['accountId'] = params['account_id'] 10605 10606 query_params = {} 10607 if 'ac_status' in params: 10608 query_params['ac_status'] = params['ac_status'] 10609 if 'block' in params: 10610 query_params['block'] = params['block'] 10611 if 'count' in params: 10612 query_params['count'] = params['count'] 10613 if 'email' in params: 10614 query_params['email'] = params['email'] 10615 if 'envelope_ids' in params: 10616 query_params['envelope_ids'] = params['envelope_ids'] 10617 if 'from_date' in params: 10618 query_params['from_date'] = params['from_date'] 10619 if 'from_to_status' in params: 10620 query_params['from_to_status'] = params['from_to_status'] 10621 if 'start_position' in params: 10622 query_params['start_position'] = params['start_position'] 10623 if 'status' in params: 10624 query_params['status'] = params['status'] 10625 if 'to_date' in params: 10626 query_params['to_date'] = params['to_date'] 10627 if 'transaction_ids' in params: 10628 query_params['transaction_ids'] = params['transaction_ids'] 10629 if 'user_name' in params: 10630 query_params['user_name'] = params['user_name'] 10631 10632 header_params = {} 10633 10634 form_params = [] 10635 local_var_files = {} 10636 10637 body_params = None 10638 if 'envelope_ids_request' in params: 10639 body_params = params['envelope_ids_request'] 10640 # HTTP header `Accept` 10641 header_params['Accept'] = self.api_client.\ 10642 select_header_accept(['application/json']) 10643 10644 # Authentication setting 10645 auth_settings = [] 10646 10647 return self.api_client.call_api(resource_path, 'PUT', 10648 path_params, 10649 query_params, 10650 header_params, 10651 body=body_params, 10652 post_params=form_params, 10653 files=local_var_files, 10654 response_type='EnvelopesInformation', 10655 auth_settings=auth_settings, 10656 callback=params.get('callback'), 10657 _return_http_data_only=params.get('_return_http_data_only'), 10658 _preload_content=params.get('_preload_content', True), 10659 _request_timeout=params.get('_request_timeout'), 10660 collection_formats=collection_formats) 10661 10662 def list_status_changes(self, account_id, **kwargs): 10663 """ 10664 Gets status changes for one or more envelopes. 10665 Retrieves envelope status changes for all envelopes. You can modify the information returned by adding query strings to limit the request to check between certain dates and times, or for certain envelopes, or for certain status codes. It is recommended that you use one or more of the query strings in order to limit the size of the response. ### Important: Unless you are requesting the status for specific envelopes (using the `envelopeIds` or `transactionIds` properties), you must add a set the `from_date` property in the request. Getting envelope status using `transactionIds` is useful for offline signing situations where it can be used determine if an envelope was created or not, for the cases where a network connection was lost, before the envelope status could be returned. ### Request Envelope Status Notes ### The REST API GET /envelopes call uses certain filters to find results. In some cases requests are check for \"any status change\" instead of the just the single status requested. In these cases, more envelopes might be returned by the request than otherwise would be. For example, for a request with the begin date is set to Jan 1st, an end date set to Jan 7th and the status qualifier (`from_to_status`) set to `Delivered` — the response set might contain envelopes that were created during that time period, but not delivered during the time period. To avoid unnecessary database queries, the DocuSign system checks requests to ensure that the added filters will not result in a zero-size response before acting on the request. The following table shows the valid envelope statuses (in the Valid Current Statuses column) for the status qualifiers in the request. If the status and status qualifiers in the API request do not contain any of the values shown in the valid current statuses column, then an empty list is returned. For example, a request with a status qualifier (from_to_status) of `Delivered` and a status of \"`Created`,`Sent`\", DocuSign will always return an empty list. This is because the request essentially translates to: find the envelopes that were delivered between the begin and end dates that have a current status of `Created` or `Sent`, and since an envelope that has been delivered can never have a status of `Created` or `Sent`, a zero-size response would be generated. In this case, DocuSign does not run the request, but just returns the empty list. Client applications should check that the statuses they are requesting make sense for a given status qualifier. 10666 This method makes a synchronous HTTP request by default. To make an 10667 asynchronous HTTP request, please define a `callback` function 10668 to be invoked when receiving the response. 10669 >>> def callback_function(response): 10670 >>> pprint(response) 10671 >>> 10672 >>> thread = api.list_status_changes(account_id, callback=callback_function) 10673 10674 :param callback function: The callback function 10675 for asynchronous request. (optional) 10676 :param str account_id: The external account number (int) or account ID Guid. (required) 10677 :param str ac_status: Specifies the Authoritative Copy Status for the envelopes. The possible values are: Unknown, Original, Transferred, AuthoritativeCopy, AuthoritativeCopyExportPending, AuthoritativeCopyExported, DepositPending, Deposited, DepositedEO, or DepositFailed. 10678 :param str block: 10679 :param str cdse_mode: 10680 :param str continuation_token: 10681 :param str count: 10682 :param str custom_field: This specifies the envelope custom field name and value searched for in the envelope information. The value portion of the query can use partial strings by adding '%' (percent sign) around the custom field query value. Example 1: If you have an envelope custom field called \"Region\" and you want to search for all envelopes where the value is \"West\" you would use the query: `?custom_field=Region=West`. Example 2: To search for envelopes where the `ApplicationID` custom field has the value or partial value of \"DocuSign\" in field, the query would be: `?custom_field=ApplicationId=%DocuSign%` This would find envelopes where the custom field value is \"DocuSign for Salesforce\" or \"DocuSign envelope.\" 10683 :param str email: 10684 :param str envelope_ids: 10685 :param str exclude: 10686 :param str folder_ids: 10687 :param str folder_types: 10688 :param str from_date: The date/time setting that specifies the date/time when the request begins checking for status changes for envelopes in the account. This is required unless 'envelopeId's are used. 10689 :param str from_to_status: This is the status type checked for in the `from_date`/`to_date` period. If `changed` is specified, then envelopes that changed status during the period are found. If for example, `created` is specified, then envelopes created during the period are found. Default is `changed`. Possible values are: Voided, Changed, Created, Deleted, Sent, Delivered, Signed, Completed, Declined, TimedOut and Processing. 10690 :param str include: 10691 :param str include_purge_information: 10692 :param str intersecting_folder_ids: 10693 :param str last_queried_date: 10694 :param str order: 10695 :param str order_by: 10696 :param str powerformids: 10697 :param str query_budget: 10698 :param str requester_date_format: 10699 :param str search_mode: 10700 :param str search_text: 10701 :param str start_position: 10702 :param str status: The list of current statuses to include in the response. By default, all envelopes found are returned. If values are specified, then of the envelopes found, only those with the current status specified are returned in the results. Possible values are: Voided, Created, Deleted, Sent, Delivered, Signed, Completed, Declined, TimedOut and Processing. 10703 :param str to_date: Optional date/time setting that specifies the date/time when the request stops for status changes for envelopes in the account. If no entry, the system uses the time of the call as the `to_date`. 10704 :param str transaction_ids: If included in the query string, this is a comma separated list of envelope `transactionId`s. If included in the `request_body`, this is a list of envelope `transactionId`s. ###### Note: `transactionId`s are only valid in the DocuSign system for seven days. 10705 :param str user_filter: 10706 :param str user_id: 10707 :param str user_name: 10708 :return: EnvelopesInformation 10709 If the method is called asynchronously, 10710 returns the request thread. 10711 """ 10712 kwargs['_return_http_data_only'] = True 10713 if kwargs.get('callback'): 10714 return self.list_status_changes_with_http_info(account_id, **kwargs) 10715 else: 10716 (data) = self.list_status_changes_with_http_info(account_id, **kwargs) 10717 return data 10718 10719 def list_status_changes_with_http_info(self, account_id, **kwargs): 10720 """ 10721 Gets status changes for one or more envelopes. 10722 Retrieves envelope status changes for all envelopes. You can modify the information returned by adding query strings to limit the request to check between certain dates and times, or for certain envelopes, or for certain status codes. It is recommended that you use one or more of the query strings in order to limit the size of the response. ### Important: Unless you are requesting the status for specific envelopes (using the `envelopeIds` or `transactionIds` properties), you must add a set the `from_date` property in the request. Getting envelope status using `transactionIds` is useful for offline signing situations where it can be used determine if an envelope was created or not, for the cases where a network connection was lost, before the envelope status could be returned. ### Request Envelope Status Notes ### The REST API GET /envelopes call uses certain filters to find results. In some cases requests are check for \"any status change\" instead of the just the single status requested. In these cases, more envelopes might be returned by the request than otherwise would be. For example, for a request with the begin date is set to Jan 1st, an end date set to Jan 7th and the status qualifier (`from_to_status`) set to `Delivered` — the response set might contain envelopes that were created during that time period, but not delivered during the time period. To avoid unnecessary database queries, the DocuSign system checks requests to ensure that the added filters will not result in a zero-size response before acting on the request. The following table shows the valid envelope statuses (in the Valid Current Statuses column) for the status qualifiers in the request. If the status and status qualifiers in the API request do not contain any of the values shown in the valid current statuses column, then an empty list is returned. For example, a request with a status qualifier (from_to_status) of `Delivered` and a status of \"`Created`,`Sent`\", DocuSign will always return an empty list. This is because the request essentially translates to: find the envelopes that were delivered between the begin and end dates that have a current status of `Created` or `Sent`, and since an envelope that has been delivered can never have a status of `Created` or `Sent`, a zero-size response would be generated. In this case, DocuSign does not run the request, but just returns the empty list. Client applications should check that the statuses they are requesting make sense for a given status qualifier. 10723 This method makes a synchronous HTTP request by default. To make an 10724 asynchronous HTTP request, please define a `callback` function 10725 to be invoked when receiving the response. 10726 >>> def callback_function(response): 10727 >>> pprint(response) 10728 >>> 10729 >>> thread = api.list_status_changes_with_http_info(account_id, callback=callback_function) 10730 10731 :param callback function: The callback function 10732 for asynchronous request. (optional) 10733 :param str account_id: The external account number (int) or account ID Guid. (required) 10734 :param str ac_status: Specifies the Authoritative Copy Status for the envelopes. The possible values are: Unknown, Original, Transferred, AuthoritativeCopy, AuthoritativeCopyExportPending, AuthoritativeCopyExported, DepositPending, Deposited, DepositedEO, or DepositFailed. 10735 :param str block: 10736 :param str cdse_mode: 10737 :param str continuation_token: 10738 :param str count: 10739 :param str custom_field: This specifies the envelope custom field name and value searched for in the envelope information. The value portion of the query can use partial strings by adding '%' (percent sign) around the custom field query value. Example 1: If you have an envelope custom field called \"Region\" and you want to search for all envelopes where the value is \"West\" you would use the query: `?custom_field=Region=West`. Example 2: To search for envelopes where the `ApplicationID` custom field has the value or partial value of \"DocuSign\" in field, the query would be: `?custom_field=ApplicationId=%DocuSign%` This would find envelopes where the custom field value is \"DocuSign for Salesforce\" or \"DocuSign envelope.\" 10740 :param str email: 10741 :param str envelope_ids: 10742 :param str exclude: 10743 :param str folder_ids: 10744 :param str folder_types: 10745 :param str from_date: The date/time setting that specifies the date/time when the request begins checking for status changes for envelopes in the account. This is required unless 'envelopeId's are used. 10746 :param str from_to_status: This is the status type checked for in the `from_date`/`to_date` period. If `changed` is specified, then envelopes that changed status during the period are found. If for example, `created` is specified, then envelopes created during the period are found. Default is `changed`. Possible values are: Voided, Changed, Created, Deleted, Sent, Delivered, Signed, Completed, Declined, TimedOut and Processing. 10747 :param str include: 10748 :param str include_purge_information: 10749 :param str intersecting_folder_ids: 10750 :param str last_queried_date: 10751 :param str order: 10752 :param str order_by: 10753 :param str powerformids: 10754 :param str query_budget: 10755 :param str requester_date_format: 10756 :param str search_mode: 10757 :param str search_text: 10758 :param str start_position: 10759 :param str status: The list of current statuses to include in the response. By default, all envelopes found are returned. If values are specified, then of the envelopes found, only those with the current status specified are returned in the results. Possible values are: Voided, Created, Deleted, Sent, Delivered, Signed, Completed, Declined, TimedOut and Processing. 10760 :param str to_date: Optional date/time setting that specifies the date/time when the request stops for status changes for envelopes in the account. If no entry, the system uses the time of the call as the `to_date`. 10761 :param str transaction_ids: If included in the query string, this is a comma separated list of envelope `transactionId`s. If included in the `request_body`, this is a list of envelope `transactionId`s. ###### Note: `transactionId`s are only valid in the DocuSign system for seven days. 10762 :param str user_filter: 10763 :param str user_id: 10764 :param str user_name: 10765 :return: EnvelopesInformation 10766 If the method is called asynchronously, 10767 returns the request thread. 10768 """ 10769 10770 all_params = ['account_id', 'ac_status', 'block', 'cdse_mode', 'continuation_token', 'count', 'custom_field', 'email', 'envelope_ids', 'exclude', 'folder_ids', 'folder_types', 'from_date', 'from_to_status', 'include', 'include_purge_information', 'intersecting_folder_ids', 'last_queried_date', 'order', 'order_by', 'powerformids', 'query_budget', 'requester_date_format', 'search_mode', 'search_text', 'start_position', 'status', 'to_date', 'transaction_ids', 'user_filter', 'user_id', 'user_name'] 10771 all_params.append('callback') 10772 all_params.append('_return_http_data_only') 10773 all_params.append('_preload_content') 10774 all_params.append('_request_timeout') 10775 10776 params = locals() 10777 for key, val in iteritems(params['kwargs']): 10778 if key not in all_params: 10779 raise TypeError( 10780 "Got an unexpected keyword argument '%s'" 10781 " to method list_status_changes" % key 10782 ) 10783 params[key] = val 10784 del params['kwargs'] 10785 # verify the required parameter 'account_id' is set 10786 if ('account_id' not in params) or (params['account_id'] is None): 10787 raise ValueError("Missing the required parameter `account_id` when calling `list_status_changes`") 10788 10789 10790 collection_formats = {} 10791 10792 resource_path = '/v2.1/accounts/{accountId}/envelopes'.replace('{format}', 'json') 10793 path_params = {} 10794 if 'account_id' in params: 10795 path_params['accountId'] = params['account_id'] 10796 10797 query_params = {} 10798 if 'ac_status' in params: 10799 query_params['ac_status'] = params['ac_status'] 10800 if 'block' in params: 10801 query_params['block'] = params['block'] 10802 if 'cdse_mode' in params: 10803 query_params['cdse_mode'] = params['cdse_mode'] 10804 if 'continuation_token' in params: 10805 query_params['continuation_token'] = params['continuation_token'] 10806 if 'count' in params: 10807 query_params['count'] = params['count'] 10808 if 'custom_field' in params: 10809 query_params['custom_field'] = params['custom_field'] 10810 if 'email' in params: 10811 query_params['email'] = params['email'] 10812 if 'envelope_ids' in params: 10813 query_params['envelope_ids'] = params['envelope_ids'] 10814 if 'exclude' in params: 10815 query_params['exclude'] = params['exclude'] 10816 if 'folder_ids' in params: 10817 query_params['folder_ids'] = params['folder_ids'] 10818 if 'folder_types' in params: 10819 query_params['folder_types'] = params['folder_types'] 10820 if 'from_date' in params: 10821 query_params['from_date'] = params['from_date'] 10822 if 'from_to_status' in params: 10823 query_params['from_to_status'] = params['from_to_status'] 10824 if 'include' in params: 10825 query_params['include'] = params['include'] 10826 if 'include_purge_information' in params: 10827 query_params['include_purge_information'] = params['include_purge_information'] 10828 if 'intersecting_folder_ids' in params: 10829 query_params['intersecting_folder_ids'] = params['intersecting_folder_ids'] 10830 if 'last_queried_date' in params: 10831 query_params['last_queried_date'] = params['last_queried_date'] 10832 if 'order' in params: 10833 query_params['order'] = params['order'] 10834 if 'order_by' in params: 10835 query_params['order_by'] = params['order_by'] 10836 if 'powerformids' in params: 10837 query_params['powerformids'] = params['powerformids'] 10838 if 'query_budget' in params: 10839 query_params['query_budget'] = params['query_budget'] 10840 if 'requester_date_format' in params: 10841 query_params['requester_date_format'] = params['requester_date_format'] 10842 if 'search_mode' in params: 10843 query_params['search_mode'] = params['search_mode'] 10844 if 'search_text' in params: 10845 query_params['search_text'] = params['search_text'] 10846 if 'start_position' in params: 10847 query_params['start_position'] = params['start_position'] 10848 if 'status' in params: 10849 query_params['status'] = params['status'] 10850 if 'to_date' in params: 10851 query_params['to_date'] = params['to_date'] 10852 if 'transaction_ids' in params: 10853 query_params['transaction_ids'] = params['transaction_ids'] 10854 if 'user_filter' in params: 10855 query_params['user_filter'] = params['user_filter'] 10856 if 'user_id' in params: 10857 query_params['user_id'] = params['user_id'] 10858 if 'user_name' in params: 10859 query_params['user_name'] = params['user_name'] 10860 10861 header_params = {} 10862 10863 form_params = [] 10864 local_var_files = {} 10865 10866 body_params = None 10867 # HTTP header `Accept` 10868 header_params['Accept'] = self.api_client.\ 10869 select_header_accept(['application/json']) 10870 10871 # Authentication setting 10872 auth_settings = [] 10873 10874 return self.api_client.call_api(resource_path, 'GET', 10875 path_params, 10876 query_params, 10877 header_params, 10878 body=body_params, 10879 post_params=form_params, 10880 files=local_var_files, 10881 response_type='EnvelopesInformation', 10882 auth_settings=auth_settings, 10883 callback=params.get('callback'), 10884 _return_http_data_only=params.get('_return_http_data_only'), 10885 _preload_content=params.get('_preload_content', True), 10886 _request_timeout=params.get('_request_timeout'), 10887 collection_formats=collection_formats) 10888 10889 def list_tabs(self, account_id, envelope_id, recipient_id, **kwargs): 10890 """ 10891 Gets the tabs information for a signer or sign-in-person recipient in an envelope. 10892 Retrieves information about the tabs associated with a recipient in a draft envelope. 10893 This method makes a synchronous HTTP request by default. To make an 10894 asynchronous HTTP request, please define a `callback` function 10895 to be invoked when receiving the response. 10896 >>> def callback_function(response): 10897 >>> pprint(response) 10898 >>> 10899 >>> thread = api.list_tabs(account_id, envelope_id, recipient_id, callback=callback_function) 10900 10901 :param callback function: The callback function 10902 for asynchronous request. (optional) 10903 :param str account_id: The external account number (int) or account ID Guid. (required) 10904 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10905 :param str recipient_id: The ID of the recipient being accessed. (required) 10906 :param str include_anchor_tab_locations: When set to **true**, all tabs with anchor tab properties are included in the response. 10907 :param str include_metadata: 10908 :return: Tabs 10909 If the method is called asynchronously, 10910 returns the request thread. 10911 """ 10912 kwargs['_return_http_data_only'] = True 10913 if kwargs.get('callback'): 10914 return self.list_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 10915 else: 10916 (data) = self.list_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 10917 return data 10918 10919 def list_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 10920 """ 10921 Gets the tabs information for a signer or sign-in-person recipient in an envelope. 10922 Retrieves information about the tabs associated with a recipient in a draft envelope. 10923 This method makes a synchronous HTTP request by default. To make an 10924 asynchronous HTTP request, please define a `callback` function 10925 to be invoked when receiving the response. 10926 >>> def callback_function(response): 10927 >>> pprint(response) 10928 >>> 10929 >>> thread = api.list_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 10930 10931 :param callback function: The callback function 10932 for asynchronous request. (optional) 10933 :param str account_id: The external account number (int) or account ID Guid. (required) 10934 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10935 :param str recipient_id: The ID of the recipient being accessed. (required) 10936 :param str include_anchor_tab_locations: When set to **true**, all tabs with anchor tab properties are included in the response. 10937 :param str include_metadata: 10938 :return: Tabs 10939 If the method is called asynchronously, 10940 returns the request thread. 10941 """ 10942 10943 all_params = ['account_id', 'envelope_id', 'recipient_id', 'include_anchor_tab_locations', 'include_metadata'] 10944 all_params.append('callback') 10945 all_params.append('_return_http_data_only') 10946 all_params.append('_preload_content') 10947 all_params.append('_request_timeout') 10948 10949 params = locals() 10950 for key, val in iteritems(params['kwargs']): 10951 if key not in all_params: 10952 raise TypeError( 10953 "Got an unexpected keyword argument '%s'" 10954 " to method list_tabs" % key 10955 ) 10956 params[key] = val 10957 del params['kwargs'] 10958 # verify the required parameter 'account_id' is set 10959 if ('account_id' not in params) or (params['account_id'] is None): 10960 raise ValueError("Missing the required parameter `account_id` when calling `list_tabs`") 10961 # verify the required parameter 'envelope_id' is set 10962 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10963 raise ValueError("Missing the required parameter `envelope_id` when calling `list_tabs`") 10964 # verify the required parameter 'recipient_id' is set 10965 if ('recipient_id' not in params) or (params['recipient_id'] is None): 10966 raise ValueError("Missing the required parameter `recipient_id` when calling `list_tabs`") 10967 10968 10969 collection_formats = {} 10970 10971 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/tabs'.replace('{format}', 'json') 10972 path_params = {} 10973 if 'account_id' in params: 10974 path_params['accountId'] = params['account_id'] 10975 if 'envelope_id' in params: 10976 path_params['envelopeId'] = params['envelope_id'] 10977 if 'recipient_id' in params: 10978 path_params['recipientId'] = params['recipient_id'] 10979 10980 query_params = {} 10981 if 'include_anchor_tab_locations' in params: 10982 query_params['include_anchor_tab_locations'] = params['include_anchor_tab_locations'] 10983 if 'include_metadata' in params: 10984 query_params['include_metadata'] = params['include_metadata'] 10985 10986 header_params = {} 10987 10988 form_params = [] 10989 local_var_files = {} 10990 10991 body_params = None 10992 # HTTP header `Accept` 10993 header_params['Accept'] = self.api_client.\ 10994 select_header_accept(['application/json']) 10995 10996 # Authentication setting 10997 auth_settings = [] 10998 10999 return self.api_client.call_api(resource_path, 'GET', 11000 path_params, 11001 query_params, 11002 header_params, 11003 body=body_params, 11004 post_params=form_params, 11005 files=local_var_files, 11006 response_type='Tabs', 11007 auth_settings=auth_settings, 11008 callback=params.get('callback'), 11009 _return_http_data_only=params.get('_return_http_data_only'), 11010 _preload_content=params.get('_preload_content', True), 11011 _request_timeout=params.get('_request_timeout'), 11012 collection_formats=collection_formats) 11013 11014 def list_templates(self, account_id, envelope_id, **kwargs): 11015 """ 11016 Get List of Templates used in an Envelope 11017 This returns a list of the server-side templates, their name and ID, used in an envelope. 11018 This method makes a synchronous HTTP request by default. To make an 11019 asynchronous HTTP request, please define a `callback` function 11020 to be invoked when receiving the response. 11021 >>> def callback_function(response): 11022 >>> pprint(response) 11023 >>> 11024 >>> thread = api.list_templates(account_id, envelope_id, callback=callback_function) 11025 11026 :param callback function: The callback function 11027 for asynchronous request. (optional) 11028 :param str account_id: The external account number (int) or account ID Guid. (required) 11029 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11030 :param str include: The possible values are: matching_applied - This returns template matching information for the template. 11031 :return: TemplateInformation 11032 If the method is called asynchronously, 11033 returns the request thread. 11034 """ 11035 kwargs['_return_http_data_only'] = True 11036 if kwargs.get('callback'): 11037 return self.list_templates_with_http_info(account_id, envelope_id, **kwargs) 11038 else: 11039 (data) = self.list_templates_with_http_info(account_id, envelope_id, **kwargs) 11040 return data 11041 11042 def list_templates_with_http_info(self, account_id, envelope_id, **kwargs): 11043 """ 11044 Get List of Templates used in an Envelope 11045 This returns a list of the server-side templates, their name and ID, used in an envelope. 11046 This method makes a synchronous HTTP request by default. To make an 11047 asynchronous HTTP request, please define a `callback` function 11048 to be invoked when receiving the response. 11049 >>> def callback_function(response): 11050 >>> pprint(response) 11051 >>> 11052 >>> thread = api.list_templates_with_http_info(account_id, envelope_id, callback=callback_function) 11053 11054 :param callback function: The callback function 11055 for asynchronous request. (optional) 11056 :param str account_id: The external account number (int) or account ID Guid. (required) 11057 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11058 :param str include: The possible values are: matching_applied - This returns template matching information for the template. 11059 :return: TemplateInformation 11060 If the method is called asynchronously, 11061 returns the request thread. 11062 """ 11063 11064 all_params = ['account_id', 'envelope_id', 'include'] 11065 all_params.append('callback') 11066 all_params.append('_return_http_data_only') 11067 all_params.append('_preload_content') 11068 all_params.append('_request_timeout') 11069 11070 params = locals() 11071 for key, val in iteritems(params['kwargs']): 11072 if key not in all_params: 11073 raise TypeError( 11074 "Got an unexpected keyword argument '%s'" 11075 " to method list_templates" % key 11076 ) 11077 params[key] = val 11078 del params['kwargs'] 11079 # verify the required parameter 'account_id' is set 11080 if ('account_id' not in params) or (params['account_id'] is None): 11081 raise ValueError("Missing the required parameter `account_id` when calling `list_templates`") 11082 # verify the required parameter 'envelope_id' is set 11083 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11084 raise ValueError("Missing the required parameter `envelope_id` when calling `list_templates`") 11085 11086 11087 collection_formats = {} 11088 11089 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/templates'.replace('{format}', 'json') 11090 path_params = {} 11091 if 'account_id' in params: 11092 path_params['accountId'] = params['account_id'] 11093 if 'envelope_id' in params: 11094 path_params['envelopeId'] = params['envelope_id'] 11095 11096 query_params = {} 11097 if 'include' in params: 11098 query_params['include'] = params['include'] 11099 11100 header_params = {} 11101 11102 form_params = [] 11103 local_var_files = {} 11104 11105 body_params = None 11106 # HTTP header `Accept` 11107 header_params['Accept'] = self.api_client.\ 11108 select_header_accept(['application/json']) 11109 11110 # Authentication setting 11111 auth_settings = [] 11112 11113 return self.api_client.call_api(resource_path, 'GET', 11114 path_params, 11115 query_params, 11116 header_params, 11117 body=body_params, 11118 post_params=form_params, 11119 files=local_var_files, 11120 response_type='TemplateInformation', 11121 auth_settings=auth_settings, 11122 callback=params.get('callback'), 11123 _return_http_data_only=params.get('_return_http_data_only'), 11124 _preload_content=params.get('_preload_content', True), 11125 _request_timeout=params.get('_request_timeout'), 11126 collection_formats=collection_formats) 11127 11128 def list_templates_for_document(self, account_id, document_id, envelope_id, **kwargs): 11129 """ 11130 Gets the templates associated with a document in an existing envelope. 11131 Retrieves the templates associated with a document in the specified envelope. 11132 This method makes a synchronous HTTP request by default. To make an 11133 asynchronous HTTP request, please define a `callback` function 11134 to be invoked when receiving the response. 11135 >>> def callback_function(response): 11136 >>> pprint(response) 11137 >>> 11138 >>> thread = api.list_templates_for_document(account_id, document_id, envelope_id, callback=callback_function) 11139 11140 :param callback function: The callback function 11141 for asynchronous request. (optional) 11142 :param str account_id: The external account number (int) or account ID Guid. (required) 11143 :param str document_id: The ID of the document being accessed. (required) 11144 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11145 :param str include: 11146 :return: TemplateInformation 11147 If the method is called asynchronously, 11148 returns the request thread. 11149 """ 11150 kwargs['_return_http_data_only'] = True 11151 if kwargs.get('callback'): 11152 return self.list_templates_for_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 11153 else: 11154 (data) = self.list_templates_for_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 11155 return data 11156 11157 def list_templates_for_document_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 11158 """ 11159 Gets the templates associated with a document in an existing envelope. 11160 Retrieves the templates associated with a document in the specified envelope. 11161 This method makes a synchronous HTTP request by default. To make an 11162 asynchronous HTTP request, please define a `callback` function 11163 to be invoked when receiving the response. 11164 >>> def callback_function(response): 11165 >>> pprint(response) 11166 >>> 11167 >>> thread = api.list_templates_for_document_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 11168 11169 :param callback function: The callback function 11170 for asynchronous request. (optional) 11171 :param str account_id: The external account number (int) or account ID Guid. (required) 11172 :param str document_id: The ID of the document being accessed. (required) 11173 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11174 :param str include: 11175 :return: TemplateInformation 11176 If the method is called asynchronously, 11177 returns the request thread. 11178 """ 11179 11180 all_params = ['account_id', 'document_id', 'envelope_id', 'include'] 11181 all_params.append('callback') 11182 all_params.append('_return_http_data_only') 11183 all_params.append('_preload_content') 11184 all_params.append('_request_timeout') 11185 11186 params = locals() 11187 for key, val in iteritems(params['kwargs']): 11188 if key not in all_params: 11189 raise TypeError( 11190 "Got an unexpected keyword argument '%s'" 11191 " to method list_templates_for_document" % key 11192 ) 11193 params[key] = val 11194 del params['kwargs'] 11195 # verify the required parameter 'account_id' is set 11196 if ('account_id' not in params) or (params['account_id'] is None): 11197 raise ValueError("Missing the required parameter `account_id` when calling `list_templates_for_document`") 11198 # verify the required parameter 'document_id' is set 11199 if ('document_id' not in params) or (params['document_id'] is None): 11200 raise ValueError("Missing the required parameter `document_id` when calling `list_templates_for_document`") 11201 # verify the required parameter 'envelope_id' is set 11202 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11203 raise ValueError("Missing the required parameter `envelope_id` when calling `list_templates_for_document`") 11204 11205 11206 collection_formats = {} 11207 11208 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/templates'.replace('{format}', 'json') 11209 path_params = {} 11210 if 'account_id' in params: 11211 path_params['accountId'] = params['account_id'] 11212 if 'document_id' in params: 11213 path_params['documentId'] = params['document_id'] 11214 if 'envelope_id' in params: 11215 path_params['envelopeId'] = params['envelope_id'] 11216 11217 query_params = {} 11218 if 'include' in params: 11219 query_params['include'] = params['include'] 11220 11221 header_params = {} 11222 11223 form_params = [] 11224 local_var_files = {} 11225 11226 body_params = None 11227 # HTTP header `Accept` 11228 header_params['Accept'] = self.api_client.\ 11229 select_header_accept(['application/json']) 11230 11231 # Authentication setting 11232 auth_settings = [] 11233 11234 return self.api_client.call_api(resource_path, 'GET', 11235 path_params, 11236 query_params, 11237 header_params, 11238 body=body_params, 11239 post_params=form_params, 11240 files=local_var_files, 11241 response_type='TemplateInformation', 11242 auth_settings=auth_settings, 11243 callback=params.get('callback'), 11244 _return_http_data_only=params.get('_return_http_data_only'), 11245 _preload_content=params.get('_preload_content', True), 11246 _request_timeout=params.get('_request_timeout'), 11247 collection_formats=collection_formats) 11248 11249 def put_attachment(self, account_id, attachment_id, envelope_id, **kwargs): 11250 """ 11251 Add an attachment to a DRAFT or IN-PROCESS envelope. 11252 Adds an attachment to a draft or in-process envelope. 11253 This method makes a synchronous HTTP request by default. To make an 11254 asynchronous HTTP request, please define a `callback` function 11255 to be invoked when receiving the response. 11256 >>> def callback_function(response): 11257 >>> pprint(response) 11258 >>> 11259 >>> thread = api.put_attachment(account_id, attachment_id, envelope_id, callback=callback_function) 11260 11261 :param callback function: The callback function 11262 for asynchronous request. (optional) 11263 :param str account_id: The external account number (int) or account ID Guid. (required) 11264 :param str attachment_id: (required) 11265 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11266 :param Attachment attachment: 11267 :return: EnvelopeAttachmentsResult 11268 If the method is called asynchronously, 11269 returns the request thread. 11270 """ 11271 kwargs['_return_http_data_only'] = True 11272 if kwargs.get('callback'): 11273 return self.put_attachment_with_http_info(account_id, attachment_id, envelope_id, **kwargs) 11274 else: 11275 (data) = self.put_attachment_with_http_info(account_id, attachment_id, envelope_id, **kwargs) 11276 return data 11277 11278 def put_attachment_with_http_info(self, account_id, attachment_id, envelope_id, **kwargs): 11279 """ 11280 Add an attachment to a DRAFT or IN-PROCESS envelope. 11281 Adds an attachment to a draft or in-process envelope. 11282 This method makes a synchronous HTTP request by default. To make an 11283 asynchronous HTTP request, please define a `callback` function 11284 to be invoked when receiving the response. 11285 >>> def callback_function(response): 11286 >>> pprint(response) 11287 >>> 11288 >>> thread = api.put_attachment_with_http_info(account_id, attachment_id, envelope_id, callback=callback_function) 11289 11290 :param callback function: The callback function 11291 for asynchronous request. (optional) 11292 :param str account_id: The external account number (int) or account ID Guid. (required) 11293 :param str attachment_id: (required) 11294 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11295 :param Attachment attachment: 11296 :return: EnvelopeAttachmentsResult 11297 If the method is called asynchronously, 11298 returns the request thread. 11299 """ 11300 11301 all_params = ['account_id', 'attachment_id', 'envelope_id', 'attachment'] 11302 all_params.append('callback') 11303 all_params.append('_return_http_data_only') 11304 all_params.append('_preload_content') 11305 all_params.append('_request_timeout') 11306 11307 params = locals() 11308 for key, val in iteritems(params['kwargs']): 11309 if key not in all_params: 11310 raise TypeError( 11311 "Got an unexpected keyword argument '%s'" 11312 " to method put_attachment" % key 11313 ) 11314 params[key] = val 11315 del params['kwargs'] 11316 # verify the required parameter 'account_id' is set 11317 if ('account_id' not in params) or (params['account_id'] is None): 11318 raise ValueError("Missing the required parameter `account_id` when calling `put_attachment`") 11319 # verify the required parameter 'attachment_id' is set 11320 if ('attachment_id' not in params) or (params['attachment_id'] is None): 11321 raise ValueError("Missing the required parameter `attachment_id` when calling `put_attachment`") 11322 # verify the required parameter 'envelope_id' is set 11323 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11324 raise ValueError("Missing the required parameter `envelope_id` when calling `put_attachment`") 11325 11326 11327 collection_formats = {} 11328 11329 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments/{attachmentId}'.replace('{format}', 'json') 11330 path_params = {} 11331 if 'account_id' in params: 11332 path_params['accountId'] = params['account_id'] 11333 if 'attachment_id' in params: 11334 path_params['attachmentId'] = params['attachment_id'] 11335 if 'envelope_id' in params: 11336 path_params['envelopeId'] = params['envelope_id'] 11337 11338 query_params = {} 11339 11340 header_params = {} 11341 11342 form_params = [] 11343 local_var_files = {} 11344 11345 body_params = None 11346 if 'attachment' in params: 11347 body_params = params['attachment'] 11348 # HTTP header `Accept` 11349 header_params['Accept'] = self.api_client.\ 11350 select_header_accept(['application/json']) 11351 11352 # Authentication setting 11353 auth_settings = [] 11354 11355 return self.api_client.call_api(resource_path, 'PUT', 11356 path_params, 11357 query_params, 11358 header_params, 11359 body=body_params, 11360 post_params=form_params, 11361 files=local_var_files, 11362 response_type='EnvelopeAttachmentsResult', 11363 auth_settings=auth_settings, 11364 callback=params.get('callback'), 11365 _return_http_data_only=params.get('_return_http_data_only'), 11366 _preload_content=params.get('_preload_content', True), 11367 _request_timeout=params.get('_request_timeout'), 11368 collection_formats=collection_formats) 11369 11370 def put_attachments(self, account_id, envelope_id, **kwargs): 11371 """ 11372 Add one or more attachments to a DRAFT or IN-PROCESS envelope. 11373 Adds one or more attachments to a draft or in-process envelope. Envelope attachments are files that an application can include in an envelope. They are not converted to PDF. Envelope attachments are available only through the API. There is no user interface in the DocuSign web application for them. For a list of supported file formats, see [Supported File Formats](https://support.docusign.com/guides/ndse-user-guide-supported-file-formats). 11374 This method makes a synchronous HTTP request by default. To make an 11375 asynchronous HTTP request, please define a `callback` function 11376 to be invoked when receiving the response. 11377 >>> def callback_function(response): 11378 >>> pprint(response) 11379 >>> 11380 >>> thread = api.put_attachments(account_id, envelope_id, callback=callback_function) 11381 11382 :param callback function: The callback function 11383 for asynchronous request. (optional) 11384 :param str account_id: The external account number (int) or account ID Guid. (required) 11385 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11386 :param EnvelopeAttachmentsRequest envelope_attachments_request: 11387 :return: EnvelopeAttachmentsResult 11388 If the method is called asynchronously, 11389 returns the request thread. 11390 """ 11391 kwargs['_return_http_data_only'] = True 11392 if kwargs.get('callback'): 11393 return self.put_attachments_with_http_info(account_id, envelope_id, **kwargs) 11394 else: 11395 (data) = self.put_attachments_with_http_info(account_id, envelope_id, **kwargs) 11396 return data 11397 11398 def put_attachments_with_http_info(self, account_id, envelope_id, **kwargs): 11399 """ 11400 Add one or more attachments to a DRAFT or IN-PROCESS envelope. 11401 Adds one or more attachments to a draft or in-process envelope. Envelope attachments are files that an application can include in an envelope. They are not converted to PDF. Envelope attachments are available only through the API. There is no user interface in the DocuSign web application for them. For a list of supported file formats, see [Supported File Formats](https://support.docusign.com/guides/ndse-user-guide-supported-file-formats). 11402 This method makes a synchronous HTTP request by default. To make an 11403 asynchronous HTTP request, please define a `callback` function 11404 to be invoked when receiving the response. 11405 >>> def callback_function(response): 11406 >>> pprint(response) 11407 >>> 11408 >>> thread = api.put_attachments_with_http_info(account_id, envelope_id, callback=callback_function) 11409 11410 :param callback function: The callback function 11411 for asynchronous request. (optional) 11412 :param str account_id: The external account number (int) or account ID Guid. (required) 11413 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11414 :param EnvelopeAttachmentsRequest envelope_attachments_request: 11415 :return: EnvelopeAttachmentsResult 11416 If the method is called asynchronously, 11417 returns the request thread. 11418 """ 11419 11420 all_params = ['account_id', 'envelope_id', 'envelope_attachments_request'] 11421 all_params.append('callback') 11422 all_params.append('_return_http_data_only') 11423 all_params.append('_preload_content') 11424 all_params.append('_request_timeout') 11425 11426 params = locals() 11427 for key, val in iteritems(params['kwargs']): 11428 if key not in all_params: 11429 raise TypeError( 11430 "Got an unexpected keyword argument '%s'" 11431 " to method put_attachments" % key 11432 ) 11433 params[key] = val 11434 del params['kwargs'] 11435 # verify the required parameter 'account_id' is set 11436 if ('account_id' not in params) or (params['account_id'] is None): 11437 raise ValueError("Missing the required parameter `account_id` when calling `put_attachments`") 11438 # verify the required parameter 'envelope_id' is set 11439 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11440 raise ValueError("Missing the required parameter `envelope_id` when calling `put_attachments`") 11441 11442 11443 collection_formats = {} 11444 11445 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments'.replace('{format}', 'json') 11446 path_params = {} 11447 if 'account_id' in params: 11448 path_params['accountId'] = params['account_id'] 11449 if 'envelope_id' in params: 11450 path_params['envelopeId'] = params['envelope_id'] 11451 11452 query_params = {} 11453 11454 header_params = {} 11455 11456 form_params = [] 11457 local_var_files = {} 11458 11459 body_params = None 11460 if 'envelope_attachments_request' in params: 11461 body_params = params['envelope_attachments_request'] 11462 # HTTP header `Accept` 11463 header_params['Accept'] = self.api_client.\ 11464 select_header_accept(['application/json']) 11465 11466 # Authentication setting 11467 auth_settings = [] 11468 11469 return self.api_client.call_api(resource_path, 'PUT', 11470 path_params, 11471 query_params, 11472 header_params, 11473 body=body_params, 11474 post_params=form_params, 11475 files=local_var_files, 11476 response_type='EnvelopeAttachmentsResult', 11477 auth_settings=auth_settings, 11478 callback=params.get('callback'), 11479 _return_http_data_only=params.get('_return_http_data_only'), 11480 _preload_content=params.get('_preload_content', True), 11481 _request_timeout=params.get('_request_timeout'), 11482 collection_formats=collection_formats) 11483 11484 def rotate_document_page(self, account_id, document_id, envelope_id, page_number, **kwargs): 11485 """ 11486 Rotates page image from an envelope for display. 11487 Rotates page image from an envelope for display. The page image can be rotated to the left or right. 11488 This method makes a synchronous HTTP request by default. To make an 11489 asynchronous HTTP request, please define a `callback` function 11490 to be invoked when receiving the response. 11491 >>> def callback_function(response): 11492 >>> pprint(response) 11493 >>> 11494 >>> thread = api.rotate_document_page(account_id, document_id, envelope_id, page_number, callback=callback_function) 11495 11496 :param callback function: The callback function 11497 for asynchronous request. (optional) 11498 :param str account_id: The external account number (int) or account ID Guid. (required) 11499 :param str document_id: The ID of the document being accessed. (required) 11500 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11501 :param str page_number: The page number being accessed. (required) 11502 :param PageRequest page_request: 11503 :return: None 11504 If the method is called asynchronously, 11505 returns the request thread. 11506 """ 11507 kwargs['_return_http_data_only'] = True 11508 if kwargs.get('callback'): 11509 return self.rotate_document_page_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 11510 else: 11511 (data) = self.rotate_document_page_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 11512 return data 11513 11514 def rotate_document_page_with_http_info(self, account_id, document_id, envelope_id, page_number, **kwargs): 11515 """ 11516 Rotates page image from an envelope for display. 11517 Rotates page image from an envelope for display. The page image can be rotated to the left or right. 11518 This method makes a synchronous HTTP request by default. To make an 11519 asynchronous HTTP request, please define a `callback` function 11520 to be invoked when receiving the response. 11521 >>> def callback_function(response): 11522 >>> pprint(response) 11523 >>> 11524 >>> thread = api.rotate_document_page_with_http_info(account_id, document_id, envelope_id, page_number, callback=callback_function) 11525 11526 :param callback function: The callback function 11527 for asynchronous request. (optional) 11528 :param str account_id: The external account number (int) or account ID Guid. (required) 11529 :param str document_id: The ID of the document being accessed. (required) 11530 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11531 :param str page_number: The page number being accessed. (required) 11532 :param PageRequest page_request: 11533 :return: None 11534 If the method is called asynchronously, 11535 returns the request thread. 11536 """ 11537 11538 all_params = ['account_id', 'document_id', 'envelope_id', 'page_number', 'page_request'] 11539 all_params.append('callback') 11540 all_params.append('_return_http_data_only') 11541 all_params.append('_preload_content') 11542 all_params.append('_request_timeout') 11543 11544 params = locals() 11545 for key, val in iteritems(params['kwargs']): 11546 if key not in all_params: 11547 raise TypeError( 11548 "Got an unexpected keyword argument '%s'" 11549 " to method rotate_document_page" % key 11550 ) 11551 params[key] = val 11552 del params['kwargs'] 11553 # verify the required parameter 'account_id' is set 11554 if ('account_id' not in params) or (params['account_id'] is None): 11555 raise ValueError("Missing the required parameter `account_id` when calling `rotate_document_page`") 11556 # verify the required parameter 'document_id' is set 11557 if ('document_id' not in params) or (params['document_id'] is None): 11558 raise ValueError("Missing the required parameter `document_id` when calling `rotate_document_page`") 11559 # verify the required parameter 'envelope_id' is set 11560 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11561 raise ValueError("Missing the required parameter `envelope_id` when calling `rotate_document_page`") 11562 # verify the required parameter 'page_number' is set 11563 if ('page_number' not in params) or (params['page_number'] is None): 11564 raise ValueError("Missing the required parameter `page_number` when calling `rotate_document_page`") 11565 11566 11567 collection_formats = {} 11568 11569 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/pages/{pageNumber}/page_image'.replace('{format}', 'json') 11570 path_params = {} 11571 if 'account_id' in params: 11572 path_params['accountId'] = params['account_id'] 11573 if 'document_id' in params: 11574 path_params['documentId'] = params['document_id'] 11575 if 'envelope_id' in params: 11576 path_params['envelopeId'] = params['envelope_id'] 11577 if 'page_number' in params: 11578 path_params['pageNumber'] = params['page_number'] 11579 11580 query_params = {} 11581 11582 header_params = {} 11583 11584 form_params = [] 11585 local_var_files = {} 11586 11587 body_params = None 11588 if 'page_request' in params: 11589 body_params = params['page_request'] 11590 # HTTP header `Accept` 11591 header_params['Accept'] = self.api_client.\ 11592 select_header_accept(['application/json']) 11593 11594 # Authentication setting 11595 auth_settings = [] 11596 11597 return self.api_client.call_api(resource_path, 'PUT', 11598 path_params, 11599 query_params, 11600 header_params, 11601 body=body_params, 11602 post_params=form_params, 11603 files=local_var_files, 11604 response_type=None, 11605 auth_settings=auth_settings, 11606 callback=params.get('callback'), 11607 _return_http_data_only=params.get('_return_http_data_only'), 11608 _preload_content=params.get('_preload_content', True), 11609 _request_timeout=params.get('_request_timeout'), 11610 collection_formats=collection_formats) 11611 11612 def update(self, account_id, envelope_id, **kwargs): 11613 """ 11614 Send Draft Envelope/Void Envelope/Move/Purge Envelope/Modify draft 11615 The Put Envelopes endpoint provides the following functionality: * Sends the specified single draft envelope. Add {\"status\":\"sent\"} to the request body to send the envelope. * Voids the specified in-process envelope. Add {\"status\":\"voided\", \"voidedReason\":\"The reason for voiding the envelope\"} to the request body to void the envelope. * Replaces the current email subject and message for a draft envelope. Add {\"emailSubject\":\"subject\", \"emailBlurb\":\"message\"} to the request body to modify the subject and message. * Place the envelope documents and envelope metadata in a purge queue so that this information is removed from the DocuSign system. Add {\"purgeState\":\"purge type\"} to the request body. *Additional information on purging documents* The purge request can only be used for completed envelopes that are not marked as the authoritative copy. The requesting user must have permission to purge documents and must be the sender (the requesting user can act as the sender using Send On Behalf Of). ###### Note: If you have set the Document Retention policy on your account, envelope documents are automatically placed in the purge queue and the warning emails are sent at the end of the retention period. ###### Note: You can set the Document Retention policy in the Classic DocuSign Experience by specifying the number of days to retain documents. ###### Note: Setting a Document Retention policy is the same as setting a schedule for purging documents. When the purge request is initiated the envelope documents, or documents and envelope metadata, are placed in a purge queue for deletion in 14 days. A warning email notification is sent to the sender and recipients associated with the envelope, notifying them that the envelope documents will be deleted in 14 days and providing a link to the documents. A second email is sent 7 days later with the same message. At the end of the 14-day period, the envelope documents are deleted from the system. If `purgeState=\"documents_queued\"` is used in the request, then only the documents are deleted and any corresponding attachments and tabs remain in the DocuSign system. If `purgeState= \"documents_and_metadata_queued\"` is used in the request, then the documents, attachments, and tabs are deleted. 11616 This method makes a synchronous HTTP request by default. To make an 11617 asynchronous HTTP request, please define a `callback` function 11618 to be invoked when receiving the response. 11619 >>> def callback_function(response): 11620 >>> pprint(response) 11621 >>> 11622 >>> thread = api.update(account_id, envelope_id, callback=callback_function) 11623 11624 :param callback function: The callback function 11625 for asynchronous request. (optional) 11626 :param str account_id: The external account number (int) or account ID Guid. (required) 11627 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11628 :param str advanced_update: When set to **true**, allows the caller to update recipients, tabs, custom fields, notification, email settings and other envelope attributes. 11629 :param str recycle_on_void: 11630 :param str resend_envelope: When set to **true**, sends the specified envelope again. 11631 :param Envelope envelope: 11632 :return: EnvelopeUpdateSummary 11633 If the method is called asynchronously, 11634 returns the request thread. 11635 """ 11636 kwargs['_return_http_data_only'] = True 11637 if kwargs.get('callback'): 11638 return self.update_with_http_info(account_id, envelope_id, **kwargs) 11639 else: 11640 (data) = self.update_with_http_info(account_id, envelope_id, **kwargs) 11641 return data 11642 11643 def update_with_http_info(self, account_id, envelope_id, **kwargs): 11644 """ 11645 Send Draft Envelope/Void Envelope/Move/Purge Envelope/Modify draft 11646 The Put Envelopes endpoint provides the following functionality: * Sends the specified single draft envelope. Add {\"status\":\"sent\"} to the request body to send the envelope. * Voids the specified in-process envelope. Add {\"status\":\"voided\", \"voidedReason\":\"The reason for voiding the envelope\"} to the request body to void the envelope. * Replaces the current email subject and message for a draft envelope. Add {\"emailSubject\":\"subject\", \"emailBlurb\":\"message\"} to the request body to modify the subject and message. * Place the envelope documents and envelope metadata in a purge queue so that this information is removed from the DocuSign system. Add {\"purgeState\":\"purge type\"} to the request body. *Additional information on purging documents* The purge request can only be used for completed envelopes that are not marked as the authoritative copy. The requesting user must have permission to purge documents and must be the sender (the requesting user can act as the sender using Send On Behalf Of). ###### Note: If you have set the Document Retention policy on your account, envelope documents are automatically placed in the purge queue and the warning emails are sent at the end of the retention period. ###### Note: You can set the Document Retention policy in the Classic DocuSign Experience by specifying the number of days to retain documents. ###### Note: Setting a Document Retention policy is the same as setting a schedule for purging documents. When the purge request is initiated the envelope documents, or documents and envelope metadata, are placed in a purge queue for deletion in 14 days. A warning email notification is sent to the sender and recipients associated with the envelope, notifying them that the envelope documents will be deleted in 14 days and providing a link to the documents. A second email is sent 7 days later with the same message. At the end of the 14-day period, the envelope documents are deleted from the system. If `purgeState=\"documents_queued\"` is used in the request, then only the documents are deleted and any corresponding attachments and tabs remain in the DocuSign system. If `purgeState= \"documents_and_metadata_queued\"` is used in the request, then the documents, attachments, and tabs are deleted. 11647 This method makes a synchronous HTTP request by default. To make an 11648 asynchronous HTTP request, please define a `callback` function 11649 to be invoked when receiving the response. 11650 >>> def callback_function(response): 11651 >>> pprint(response) 11652 >>> 11653 >>> thread = api.update_with_http_info(account_id, envelope_id, callback=callback_function) 11654 11655 :param callback function: The callback function 11656 for asynchronous request. (optional) 11657 :param str account_id: The external account number (int) or account ID Guid. (required) 11658 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11659 :param str advanced_update: When set to **true**, allows the caller to update recipients, tabs, custom fields, notification, email settings and other envelope attributes. 11660 :param str recycle_on_void: 11661 :param str resend_envelope: When set to **true**, sends the specified envelope again. 11662 :param Envelope envelope: 11663 :return: EnvelopeUpdateSummary 11664 If the method is called asynchronously, 11665 returns the request thread. 11666 """ 11667 11668 all_params = ['account_id', 'envelope_id', 'advanced_update', 'recycle_on_void', 'resend_envelope', 'envelope'] 11669 all_params.append('callback') 11670 all_params.append('_return_http_data_only') 11671 all_params.append('_preload_content') 11672 all_params.append('_request_timeout') 11673 11674 params = locals() 11675 for key, val in iteritems(params['kwargs']): 11676 if key not in all_params: 11677 raise TypeError( 11678 "Got an unexpected keyword argument '%s'" 11679 " to method update" % key 11680 ) 11681 params[key] = val 11682 del params['kwargs'] 11683 # verify the required parameter 'account_id' is set 11684 if ('account_id' not in params) or (params['account_id'] is None): 11685 raise ValueError("Missing the required parameter `account_id` when calling `update`") 11686 # verify the required parameter 'envelope_id' is set 11687 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11688 raise ValueError("Missing the required parameter `envelope_id` when calling `update`") 11689 11690 11691 collection_formats = {} 11692 11693 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}'.replace('{format}', 'json') 11694 path_params = {} 11695 if 'account_id' in params: 11696 path_params['accountId'] = params['account_id'] 11697 if 'envelope_id' in params: 11698 path_params['envelopeId'] = params['envelope_id'] 11699 11700 query_params = {} 11701 if 'advanced_update' in params: 11702 query_params['advanced_update'] = params['advanced_update'] 11703 if 'recycle_on_void' in params: 11704 query_params['recycle_on_void'] = params['recycle_on_void'] 11705 if 'resend_envelope' in params: 11706 query_params['resend_envelope'] = params['resend_envelope'] 11707 11708 header_params = {} 11709 11710 form_params = [] 11711 local_var_files = {} 11712 11713 body_params = None 11714 if 'envelope' in params: 11715 body_params = params['envelope'] 11716 # HTTP header `Accept` 11717 header_params['Accept'] = self.api_client.\ 11718 select_header_accept(['application/json']) 11719 11720 # Authentication setting 11721 auth_settings = [] 11722 11723 return self.api_client.call_api(resource_path, 'PUT', 11724 path_params, 11725 query_params, 11726 header_params, 11727 body=body_params, 11728 post_params=form_params, 11729 files=local_var_files, 11730 response_type='EnvelopeUpdateSummary', 11731 auth_settings=auth_settings, 11732 callback=params.get('callback'), 11733 _return_http_data_only=params.get('_return_http_data_only'), 11734 _preload_content=params.get('_preload_content', True), 11735 _request_timeout=params.get('_request_timeout'), 11736 collection_formats=collection_formats) 11737 11738 def update_chunked_upload(self, account_id, chunked_upload_id, **kwargs): 11739 """ 11740 Integrity-Check and Commit a ChunkedUpload, readying it for use elsewhere. 11741 This method checks the integrity of a chunked upload and then commits it. When this request is successful, the chunked upload is then ready to be referenced in other API calls. If the request is unsuccessful, ensure that you have uploaded all of the parts by using the Update method. **Note:** After you commit a chunked upload, it no longer accepts additional parts. 11742 This method makes a synchronous HTTP request by default. To make an 11743 asynchronous HTTP request, please define a `callback` function 11744 to be invoked when receiving the response. 11745 >>> def callback_function(response): 11746 >>> pprint(response) 11747 >>> 11748 >>> thread = api.update_chunked_upload(account_id, chunked_upload_id, callback=callback_function) 11749 11750 :param callback function: The callback function 11751 for asynchronous request. (optional) 11752 :param str account_id: The external account number (int) or account ID Guid. (required) 11753 :param str chunked_upload_id: (required) 11754 :param str action: 11755 :return: ChunkedUploadResponse 11756 If the method is called asynchronously, 11757 returns the request thread. 11758 """ 11759 kwargs['_return_http_data_only'] = True 11760 if kwargs.get('callback'): 11761 return self.update_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 11762 else: 11763 (data) = self.update_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 11764 return data 11765 11766 def update_chunked_upload_with_http_info(self, account_id, chunked_upload_id, **kwargs): 11767 """ 11768 Integrity-Check and Commit a ChunkedUpload, readying it for use elsewhere. 11769 This method checks the integrity of a chunked upload and then commits it. When this request is successful, the chunked upload is then ready to be referenced in other API calls. If the request is unsuccessful, ensure that you have uploaded all of the parts by using the Update method. **Note:** After you commit a chunked upload, it no longer accepts additional parts. 11770 This method makes a synchronous HTTP request by default. To make an 11771 asynchronous HTTP request, please define a `callback` function 11772 to be invoked when receiving the response. 11773 >>> def callback_function(response): 11774 >>> pprint(response) 11775 >>> 11776 >>> thread = api.update_chunked_upload_with_http_info(account_id, chunked_upload_id, callback=callback_function) 11777 11778 :param callback function: The callback function 11779 for asynchronous request. (optional) 11780 :param str account_id: The external account number (int) or account ID Guid. (required) 11781 :param str chunked_upload_id: (required) 11782 :param str action: 11783 :return: ChunkedUploadResponse 11784 If the method is called asynchronously, 11785 returns the request thread. 11786 """ 11787 11788 all_params = ['account_id', 'chunked_upload_id', 'action'] 11789 all_params.append('callback') 11790 all_params.append('_return_http_data_only') 11791 all_params.append('_preload_content') 11792 all_params.append('_request_timeout') 11793 11794 params = locals() 11795 for key, val in iteritems(params['kwargs']): 11796 if key not in all_params: 11797 raise TypeError( 11798 "Got an unexpected keyword argument '%s'" 11799 " to method update_chunked_upload" % key 11800 ) 11801 params[key] = val 11802 del params['kwargs'] 11803 # verify the required parameter 'account_id' is set 11804 if ('account_id' not in params) or (params['account_id'] is None): 11805 raise ValueError("Missing the required parameter `account_id` when calling `update_chunked_upload`") 11806 # verify the required parameter 'chunked_upload_id' is set 11807 if ('chunked_upload_id' not in params) or (params['chunked_upload_id'] is None): 11808 raise ValueError("Missing the required parameter `chunked_upload_id` when calling `update_chunked_upload`") 11809 11810 11811 collection_formats = {} 11812 11813 resource_path = '/v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}'.replace('{format}', 'json') 11814 path_params = {} 11815 if 'account_id' in params: 11816 path_params['accountId'] = params['account_id'] 11817 if 'chunked_upload_id' in params: 11818 path_params['chunkedUploadId'] = params['chunked_upload_id'] 11819 11820 query_params = {} 11821 if 'action' in params: 11822 query_params['action'] = params['action'] 11823 11824 header_params = {} 11825 11826 form_params = [] 11827 local_var_files = {} 11828 11829 body_params = None 11830 # HTTP header `Accept` 11831 header_params['Accept'] = self.api_client.\ 11832 select_header_accept(['application/json']) 11833 11834 # Authentication setting 11835 auth_settings = [] 11836 11837 return self.api_client.call_api(resource_path, 'PUT', 11838 path_params, 11839 query_params, 11840 header_params, 11841 body=body_params, 11842 post_params=form_params, 11843 files=local_var_files, 11844 response_type='ChunkedUploadResponse', 11845 auth_settings=auth_settings, 11846 callback=params.get('callback'), 11847 _return_http_data_only=params.get('_return_http_data_only'), 11848 _preload_content=params.get('_preload_content', True), 11849 _request_timeout=params.get('_request_timeout'), 11850 collection_formats=collection_formats) 11851 11852 def update_chunked_upload_part(self, account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs): 11853 """ 11854 Add a chunk, a chunk 'part', to an existing ChunkedUpload. 11855 Adds a chunk or part to an existing chunked upload. After you use the Create method to initiate a new chunked upload and upload the first part, use this method to upload subsequent parts. For simplicity, DocuSign recommends that you upload the parts in their sequential order ( 1,2, 3, 4, etc.). The Create method adds the first part and assigns it the `sequence` value `0`. As a result, DocuSign recommends that you start with a `sequence` value of `1` when you use this method, and continue uploading parts contiguously until you have uploaded the entirety of the original content to DocuSign. Example: ``` PUT /v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}/1 PUT /v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}/2 PUT /v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}/3 ``` **Note:** You cannot replace a part that DocuSign has already received, or add parts to a chunked upload that is already successfully committed. 11856 This method makes a synchronous HTTP request by default. To make an 11857 asynchronous HTTP request, please define a `callback` function 11858 to be invoked when receiving the response. 11859 >>> def callback_function(response): 11860 >>> pprint(response) 11861 >>> 11862 >>> thread = api.update_chunked_upload_part(account_id, chunked_upload_id, chunked_upload_part_seq, callback=callback_function) 11863 11864 :param callback function: The callback function 11865 for asynchronous request. (optional) 11866 :param str account_id: The external account number (int) or account ID Guid. (required) 11867 :param str chunked_upload_id: (required) 11868 :param str chunked_upload_part_seq: (required) 11869 :param ChunkedUploadRequest chunked_upload_request: 11870 :return: ChunkedUploadResponse 11871 If the method is called asynchronously, 11872 returns the request thread. 11873 """ 11874 kwargs['_return_http_data_only'] = True 11875 if kwargs.get('callback'): 11876 return self.update_chunked_upload_part_with_http_info(account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs) 11877 else: 11878 (data) = self.update_chunked_upload_part_with_http_info(account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs) 11879 return data 11880 11881 def update_chunked_upload_part_with_http_info(self, account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs): 11882 """ 11883 Add a chunk, a chunk 'part', to an existing ChunkedUpload. 11884 Adds a chunk or part to an existing chunked upload. After you use the Create method to initiate a new chunked upload and upload the first part, use this method to upload subsequent parts. For simplicity, DocuSign recommends that you upload the parts in their sequential order ( 1,2, 3, 4, etc.). The Create method adds the first part and assigns it the `sequence` value `0`. As a result, DocuSign recommends that you start with a `sequence` value of `1` when you use this method, and continue uploading parts contiguously until you have uploaded the entirety of the original content to DocuSign. Example: ``` PUT /v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}/1 PUT /v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}/2 PUT /v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}/3 ``` **Note:** You cannot replace a part that DocuSign has already received, or add parts to a chunked upload that is already successfully committed. 11885 This method makes a synchronous HTTP request by default. To make an 11886 asynchronous HTTP request, please define a `callback` function 11887 to be invoked when receiving the response. 11888 >>> def callback_function(response): 11889 >>> pprint(response) 11890 >>> 11891 >>> thread = api.update_chunked_upload_part_with_http_info(account_id, chunked_upload_id, chunked_upload_part_seq, callback=callback_function) 11892 11893 :param callback function: The callback function 11894 for asynchronous request. (optional) 11895 :param str account_id: The external account number (int) or account ID Guid. (required) 11896 :param str chunked_upload_id: (required) 11897 :param str chunked_upload_part_seq: (required) 11898 :param ChunkedUploadRequest chunked_upload_request: 11899 :return: ChunkedUploadResponse 11900 If the method is called asynchronously, 11901 returns the request thread. 11902 """ 11903 11904 all_params = ['account_id', 'chunked_upload_id', 'chunked_upload_part_seq', 'chunked_upload_request'] 11905 all_params.append('callback') 11906 all_params.append('_return_http_data_only') 11907 all_params.append('_preload_content') 11908 all_params.append('_request_timeout') 11909 11910 params = locals() 11911 for key, val in iteritems(params['kwargs']): 11912 if key not in all_params: 11913 raise TypeError( 11914 "Got an unexpected keyword argument '%s'" 11915 " to method update_chunked_upload_part" % key 11916 ) 11917 params[key] = val 11918 del params['kwargs'] 11919 # verify the required parameter 'account_id' is set 11920 if ('account_id' not in params) or (params['account_id'] is None): 11921 raise ValueError("Missing the required parameter `account_id` when calling `update_chunked_upload_part`") 11922 # verify the required parameter 'chunked_upload_id' is set 11923 if ('chunked_upload_id' not in params) or (params['chunked_upload_id'] is None): 11924 raise ValueError("Missing the required parameter `chunked_upload_id` when calling `update_chunked_upload_part`") 11925 # verify the required parameter 'chunked_upload_part_seq' is set 11926 if ('chunked_upload_part_seq' not in params) or (params['chunked_upload_part_seq'] is None): 11927 raise ValueError("Missing the required parameter `chunked_upload_part_seq` when calling `update_chunked_upload_part`") 11928 11929 11930 collection_formats = {} 11931 11932 resource_path = '/v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}/{chunkedUploadPartSeq}'.replace('{format}', 'json') 11933 path_params = {} 11934 if 'account_id' in params: 11935 path_params['accountId'] = params['account_id'] 11936 if 'chunked_upload_id' in params: 11937 path_params['chunkedUploadId'] = params['chunked_upload_id'] 11938 if 'chunked_upload_part_seq' in params: 11939 path_params['chunkedUploadPartSeq'] = params['chunked_upload_part_seq'] 11940 11941 query_params = {} 11942 11943 header_params = {} 11944 11945 form_params = [] 11946 local_var_files = {} 11947 11948 body_params = None 11949 if 'chunked_upload_request' in params: 11950 body_params = params['chunked_upload_request'] 11951 # HTTP header `Accept` 11952 header_params['Accept'] = self.api_client.\ 11953 select_header_accept(['application/json']) 11954 11955 # Authentication setting 11956 auth_settings = [] 11957 11958 return self.api_client.call_api(resource_path, 'PUT', 11959 path_params, 11960 query_params, 11961 header_params, 11962 body=body_params, 11963 post_params=form_params, 11964 files=local_var_files, 11965 response_type='ChunkedUploadResponse', 11966 auth_settings=auth_settings, 11967 callback=params.get('callback'), 11968 _return_http_data_only=params.get('_return_http_data_only'), 11969 _preload_content=params.get('_preload_content', True), 11970 _request_timeout=params.get('_request_timeout'), 11971 collection_formats=collection_formats) 11972 11973 def update_custom_fields(self, account_id, envelope_id, **kwargs): 11974 """ 11975 Updates envelope custom fields in an envelope. 11976 Updates the envelope custom fields in draft and in-process envelopes. Each custom field used in an envelope must have a unique name. 11977 This method makes a synchronous HTTP request by default. To make an 11978 asynchronous HTTP request, please define a `callback` function 11979 to be invoked when receiving the response. 11980 >>> def callback_function(response): 11981 >>> pprint(response) 11982 >>> 11983 >>> thread = api.update_custom_fields(account_id, envelope_id, callback=callback_function) 11984 11985 :param callback function: The callback function 11986 for asynchronous request. (optional) 11987 :param str account_id: The external account number (int) or account ID Guid. (required) 11988 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11989 :param CustomFields custom_fields: 11990 :return: CustomFields 11991 If the method is called asynchronously, 11992 returns the request thread. 11993 """ 11994 kwargs['_return_http_data_only'] = True 11995 if kwargs.get('callback'): 11996 return self.update_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 11997 else: 11998 (data) = self.update_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 11999 return data 12000 12001 def update_custom_fields_with_http_info(self, account_id, envelope_id, **kwargs): 12002 """ 12003 Updates envelope custom fields in an envelope. 12004 Updates the envelope custom fields in draft and in-process envelopes. Each custom field used in an envelope must have a unique name. 12005 This method makes a synchronous HTTP request by default. To make an 12006 asynchronous HTTP request, please define a `callback` function 12007 to be invoked when receiving the response. 12008 >>> def callback_function(response): 12009 >>> pprint(response) 12010 >>> 12011 >>> thread = api.update_custom_fields_with_http_info(account_id, envelope_id, callback=callback_function) 12012 12013 :param callback function: The callback function 12014 for asynchronous request. (optional) 12015 :param str account_id: The external account number (int) or account ID Guid. (required) 12016 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12017 :param CustomFields custom_fields: 12018 :return: CustomFields 12019 If the method is called asynchronously, 12020 returns the request thread. 12021 """ 12022 12023 all_params = ['account_id', 'envelope_id', 'custom_fields'] 12024 all_params.append('callback') 12025 all_params.append('_return_http_data_only') 12026 all_params.append('_preload_content') 12027 all_params.append('_request_timeout') 12028 12029 params = locals() 12030 for key, val in iteritems(params['kwargs']): 12031 if key not in all_params: 12032 raise TypeError( 12033 "Got an unexpected keyword argument '%s'" 12034 " to method update_custom_fields" % key 12035 ) 12036 params[key] = val 12037 del params['kwargs'] 12038 # verify the required parameter 'account_id' is set 12039 if ('account_id' not in params) or (params['account_id'] is None): 12040 raise ValueError("Missing the required parameter `account_id` when calling `update_custom_fields`") 12041 # verify the required parameter 'envelope_id' is set 12042 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12043 raise ValueError("Missing the required parameter `envelope_id` when calling `update_custom_fields`") 12044 12045 12046 collection_formats = {} 12047 12048 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/custom_fields'.replace('{format}', 'json') 12049 path_params = {} 12050 if 'account_id' in params: 12051 path_params['accountId'] = params['account_id'] 12052 if 'envelope_id' in params: 12053 path_params['envelopeId'] = params['envelope_id'] 12054 12055 query_params = {} 12056 12057 header_params = {} 12058 12059 form_params = [] 12060 local_var_files = {} 12061 12062 body_params = None 12063 if 'custom_fields' in params: 12064 body_params = params['custom_fields'] 12065 # HTTP header `Accept` 12066 header_params['Accept'] = self.api_client.\ 12067 select_header_accept(['application/json']) 12068 12069 # Authentication setting 12070 auth_settings = [] 12071 12072 return self.api_client.call_api(resource_path, 'PUT', 12073 path_params, 12074 query_params, 12075 header_params, 12076 body=body_params, 12077 post_params=form_params, 12078 files=local_var_files, 12079 response_type='CustomFields', 12080 auth_settings=auth_settings, 12081 callback=params.get('callback'), 12082 _return_http_data_only=params.get('_return_http_data_only'), 12083 _preload_content=params.get('_preload_content', True), 12084 _request_timeout=params.get('_request_timeout'), 12085 collection_formats=collection_formats) 12086 12087 def update_document(self, account_id, document_id, envelope_id, document_file_bytes, **kwargs): 12088 """ 12089 Adds a document to an existing draft envelope. 12090 Adds a document to an existing draft envelope. 12091 This method makes a synchronous HTTP request by default. To make an 12092 asynchronous HTTP request, please define a `callback` function 12093 to be invoked when receiving the response. 12094 >>> def callback_function(response): 12095 >>> pprint(response) 12096 >>> 12097 >>> thread = api.update_document(account_id, document_id, envelope_id, document_file_bytes, callback=callback_function) 12098 12099 :param callback function: The callback function 12100 for asynchronous request. (optional) 12101 :param str account_id: The external account number (int) or account ID Guid. (required) 12102 :param str document_id: The ID of the document being accessed. (required) 12103 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12104 :param str document_file_bytes: Updated document content. (required) 12105 :return: EnvelopeDocument 12106 If the method is called asynchronously, 12107 returns the request thread. 12108 """ 12109 kwargs['_return_http_data_only'] = True 12110 if kwargs.get('callback'): 12111 return self.update_document_with_http_info(account_id, document_id, envelope_id, document_file_bytes, **kwargs) 12112 else: 12113 (data) = self.update_document_with_http_info(account_id, document_id, envelope_id, document_file_bytes, **kwargs) 12114 return data 12115 12116 def update_document_with_http_info(self, account_id, document_id, envelope_id, document_file_bytes, **kwargs): 12117 """ 12118 Adds a document to an existing draft envelope. 12119 Adds a document to an existing draft envelope. 12120 This method makes a synchronous HTTP request by default. To make an 12121 asynchronous HTTP request, please define a `callback` function 12122 to be invoked when receiving the response. 12123 >>> def callback_function(response): 12124 >>> pprint(response) 12125 >>> 12126 >>> thread = api.update_document_with_http_info(account_id, document_id, envelope_id, document_file_bytes, callback=callback_function) 12127 12128 :param callback function: The callback function 12129 for asynchronous request. (optional) 12130 :param str account_id: The external account number (int) or account ID Guid. (required) 12131 :param str document_id: The ID of the document being accessed. (required) 12132 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12133 :param str document_file_bytes: Updated document content. (required) 12134 :return: EnvelopeDocument 12135 If the method is called asynchronously, 12136 returns the request thread. 12137 """ 12138 12139 all_params = ['account_id', 'document_id', 'envelope_id', 'document_file_bytes'] 12140 all_params.append('callback') 12141 all_params.append('_return_http_data_only') 12142 all_params.append('_preload_content') 12143 all_params.append('_request_timeout') 12144 12145 params = locals() 12146 for key, val in iteritems(params['kwargs']): 12147 if key not in all_params: 12148 raise TypeError( 12149 "Got an unexpected keyword argument '%s'" 12150 " to method update_document" % key 12151 ) 12152 params[key] = val 12153 del params['kwargs'] 12154 # verify the required parameter 'account_id' is set 12155 if ('account_id' not in params) or (params['account_id'] is None): 12156 raise ValueError("Missing the required parameter `account_id` when calling `update_document`") 12157 # verify the required parameter 'document_id' is set 12158 if ('document_id' not in params) or (params['document_id'] is None): 12159 raise ValueError("Missing the required parameter `document_id` when calling `update_document`") 12160 # verify the required parameter 'envelope_id' is set 12161 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12162 raise ValueError("Missing the required parameter `envelope_id` when calling `update_document`") 12163 # verify the required parameter 'document_file_bytes' is set 12164 if ('document_file_bytes' not in params) or (params['document_file_bytes'] is None): 12165 raise ValueError("Missing the required parameter `document_file_bytes` when calling `update_document`") 12166 12167 12168 collection_formats = {} 12169 12170 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}'.replace('{format}', 'json') 12171 path_params = {} 12172 if 'account_id' in params: 12173 path_params['accountId'] = params['account_id'] 12174 if 'document_id' in params: 12175 path_params['documentId'] = params['document_id'] 12176 if 'envelope_id' in params: 12177 path_params['envelopeId'] = params['envelope_id'] 12178 12179 query_params = {} 12180 12181 header_params = {} 12182 12183 form_params = [] 12184 local_var_files = {} 12185 12186 body_params = None 12187 if 'document_file_bytes' in params: 12188 body_params = params['document_file_bytes'] 12189 # HTTP header `Accept` 12190 header_params['Accept'] = self.api_client.\ 12191 select_header_accept(['application/json']) 12192 12193 # HTTP header `Content-Type` 12194 header_params['Content-Type'] = self.api_client.\ 12195 select_header_content_type(['application/pdf']) 12196 12197 # Authentication setting 12198 auth_settings = [] 12199 12200 return self.api_client.call_api(resource_path, 'PUT', 12201 path_params, 12202 query_params, 12203 header_params, 12204 body=body_params, 12205 post_params=form_params, 12206 files=local_var_files, 12207 response_type='EnvelopeDocument', 12208 auth_settings=auth_settings, 12209 callback=params.get('callback'), 12210 _return_http_data_only=params.get('_return_http_data_only'), 12211 _preload_content=params.get('_preload_content', True), 12212 _request_timeout=params.get('_request_timeout'), 12213 collection_formats=collection_formats) 12214 12215 def update_document_fields(self, account_id, document_id, envelope_id, **kwargs): 12216 """ 12217 Updates existing custom document fields in an existing envelope document. 12218 Updates existing custom document fields in an existing envelope document. 12219 This method makes a synchronous HTTP request by default. To make an 12220 asynchronous HTTP request, please define a `callback` function 12221 to be invoked when receiving the response. 12222 >>> def callback_function(response): 12223 >>> pprint(response) 12224 >>> 12225 >>> thread = api.update_document_fields(account_id, document_id, envelope_id, callback=callback_function) 12226 12227 :param callback function: The callback function 12228 for asynchronous request. (optional) 12229 :param str account_id: The external account number (int) or account ID Guid. (required) 12230 :param str document_id: The ID of the document being accessed. (required) 12231 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12232 :param DocumentFieldsInformation document_fields_information: 12233 :return: DocumentFieldsInformation 12234 If the method is called asynchronously, 12235 returns the request thread. 12236 """ 12237 kwargs['_return_http_data_only'] = True 12238 if kwargs.get('callback'): 12239 return self.update_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 12240 else: 12241 (data) = self.update_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 12242 return data 12243 12244 def update_document_fields_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 12245 """ 12246 Updates existing custom document fields in an existing envelope document. 12247 Updates existing custom document fields in an existing envelope document. 12248 This method makes a synchronous HTTP request by default. To make an 12249 asynchronous HTTP request, please define a `callback` function 12250 to be invoked when receiving the response. 12251 >>> def callback_function(response): 12252 >>> pprint(response) 12253 >>> 12254 >>> thread = api.update_document_fields_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 12255 12256 :param callback function: The callback function 12257 for asynchronous request. (optional) 12258 :param str account_id: The external account number (int) or account ID Guid. (required) 12259 :param str document_id: The ID of the document being accessed. (required) 12260 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12261 :param DocumentFieldsInformation document_fields_information: 12262 :return: DocumentFieldsInformation 12263 If the method is called asynchronously, 12264 returns the request thread. 12265 """ 12266 12267 all_params = ['account_id', 'document_id', 'envelope_id', 'document_fields_information'] 12268 all_params.append('callback') 12269 all_params.append('_return_http_data_only') 12270 all_params.append('_preload_content') 12271 all_params.append('_request_timeout') 12272 12273 params = locals() 12274 for key, val in iteritems(params['kwargs']): 12275 if key not in all_params: 12276 raise TypeError( 12277 "Got an unexpected keyword argument '%s'" 12278 " to method update_document_fields" % key 12279 ) 12280 params[key] = val 12281 del params['kwargs'] 12282 # verify the required parameter 'account_id' is set 12283 if ('account_id' not in params) or (params['account_id'] is None): 12284 raise ValueError("Missing the required parameter `account_id` when calling `update_document_fields`") 12285 # verify the required parameter 'document_id' is set 12286 if ('document_id' not in params) or (params['document_id'] is None): 12287 raise ValueError("Missing the required parameter `document_id` when calling `update_document_fields`") 12288 # verify the required parameter 'envelope_id' is set 12289 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12290 raise ValueError("Missing the required parameter `envelope_id` when calling `update_document_fields`") 12291 12292 12293 collection_formats = {} 12294 12295 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/fields'.replace('{format}', 'json') 12296 path_params = {} 12297 if 'account_id' in params: 12298 path_params['accountId'] = params['account_id'] 12299 if 'document_id' in params: 12300 path_params['documentId'] = params['document_id'] 12301 if 'envelope_id' in params: 12302 path_params['envelopeId'] = params['envelope_id'] 12303 12304 query_params = {} 12305 12306 header_params = {} 12307 12308 form_params = [] 12309 local_var_files = {} 12310 12311 body_params = None 12312 if 'document_fields_information' in params: 12313 body_params = params['document_fields_information'] 12314 # HTTP header `Accept` 12315 header_params['Accept'] = self.api_client.\ 12316 select_header_accept(['application/json']) 12317 12318 # Authentication setting 12319 auth_settings = [] 12320 12321 return self.api_client.call_api(resource_path, 'PUT', 12322 path_params, 12323 query_params, 12324 header_params, 12325 body=body_params, 12326 post_params=form_params, 12327 files=local_var_files, 12328 response_type='DocumentFieldsInformation', 12329 auth_settings=auth_settings, 12330 callback=params.get('callback'), 12331 _return_http_data_only=params.get('_return_http_data_only'), 12332 _preload_content=params.get('_preload_content', True), 12333 _request_timeout=params.get('_request_timeout'), 12334 collection_formats=collection_formats) 12335 12336 def update_document_tabs(self, account_id, document_id, envelope_id, **kwargs): 12337 """ 12338 Updates the tabs for an envelope document 12339 Updates tabs in the document specified by `documentId` in the envelope specified by `envelopeId`. 12340 This method makes a synchronous HTTP request by default. To make an 12341 asynchronous HTTP request, please define a `callback` function 12342 to be invoked when receiving the response. 12343 >>> def callback_function(response): 12344 >>> pprint(response) 12345 >>> 12346 >>> thread = api.update_document_tabs(account_id, document_id, envelope_id, callback=callback_function) 12347 12348 :param callback function: The callback function 12349 for asynchronous request. (optional) 12350 :param str account_id: The external account number (int) or account ID Guid. (required) 12351 :param str document_id: The ID of the document being accessed. (required) 12352 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12353 :param Tabs tabs: 12354 :return: Tabs 12355 If the method is called asynchronously, 12356 returns the request thread. 12357 """ 12358 kwargs['_return_http_data_only'] = True 12359 if kwargs.get('callback'): 12360 return self.update_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 12361 else: 12362 (data) = self.update_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 12363 return data 12364 12365 def update_document_tabs_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 12366 """ 12367 Updates the tabs for an envelope document 12368 Updates tabs in the document specified by `documentId` in the envelope specified by `envelopeId`. 12369 This method makes a synchronous HTTP request by default. To make an 12370 asynchronous HTTP request, please define a `callback` function 12371 to be invoked when receiving the response. 12372 >>> def callback_function(response): 12373 >>> pprint(response) 12374 >>> 12375 >>> thread = api.update_document_tabs_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 12376 12377 :param callback function: The callback function 12378 for asynchronous request. (optional) 12379 :param str account_id: The external account number (int) or account ID Guid. (required) 12380 :param str document_id: The ID of the document being accessed. (required) 12381 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12382 :param Tabs tabs: 12383 :return: Tabs 12384 If the method is called asynchronously, 12385 returns the request thread. 12386 """ 12387 12388 all_params = ['account_id', 'document_id', 'envelope_id', 'tabs'] 12389 all_params.append('callback') 12390 all_params.append('_return_http_data_only') 12391 all_params.append('_preload_content') 12392 all_params.append('_request_timeout') 12393 12394 params = locals() 12395 for key, val in iteritems(params['kwargs']): 12396 if key not in all_params: 12397 raise TypeError( 12398 "Got an unexpected keyword argument '%s'" 12399 " to method update_document_tabs" % key 12400 ) 12401 params[key] = val 12402 del params['kwargs'] 12403 # verify the required parameter 'account_id' is set 12404 if ('account_id' not in params) or (params['account_id'] is None): 12405 raise ValueError("Missing the required parameter `account_id` when calling `update_document_tabs`") 12406 # verify the required parameter 'document_id' is set 12407 if ('document_id' not in params) or (params['document_id'] is None): 12408 raise ValueError("Missing the required parameter `document_id` when calling `update_document_tabs`") 12409 # verify the required parameter 'envelope_id' is set 12410 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12411 raise ValueError("Missing the required parameter `envelope_id` when calling `update_document_tabs`") 12412 12413 12414 collection_formats = {} 12415 12416 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/tabs'.replace('{format}', 'json') 12417 path_params = {} 12418 if 'account_id' in params: 12419 path_params['accountId'] = params['account_id'] 12420 if 'document_id' in params: 12421 path_params['documentId'] = params['document_id'] 12422 if 'envelope_id' in params: 12423 path_params['envelopeId'] = params['envelope_id'] 12424 12425 query_params = {} 12426 12427 header_params = {} 12428 12429 form_params = [] 12430 local_var_files = {} 12431 12432 body_params = None 12433 if 'tabs' in params: 12434 body_params = params['tabs'] 12435 # HTTP header `Accept` 12436 header_params['Accept'] = self.api_client.\ 12437 select_header_accept(['application/json']) 12438 12439 # Authentication setting 12440 auth_settings = [] 12441 12442 return self.api_client.call_api(resource_path, 'PUT', 12443 path_params, 12444 query_params, 12445 header_params, 12446 body=body_params, 12447 post_params=form_params, 12448 files=local_var_files, 12449 response_type='Tabs', 12450 auth_settings=auth_settings, 12451 callback=params.get('callback'), 12452 _return_http_data_only=params.get('_return_http_data_only'), 12453 _preload_content=params.get('_preload_content', True), 12454 _request_timeout=params.get('_request_timeout'), 12455 collection_formats=collection_formats) 12456 12457 def update_documents(self, account_id, envelope_id, **kwargs): 12458 """ 12459 Adds one or more documents to an existing envelope document. 12460 Adds one or more documents to an existing envelope document. 12461 This method makes a synchronous HTTP request by default. To make an 12462 asynchronous HTTP request, please define a `callback` function 12463 to be invoked when receiving the response. 12464 >>> def callback_function(response): 12465 >>> pprint(response) 12466 >>> 12467 >>> thread = api.update_documents(account_id, envelope_id, callback=callback_function) 12468 12469 :param callback function: The callback function 12470 for asynchronous request. (optional) 12471 :param str account_id: The external account number (int) or account ID Guid. (required) 12472 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12473 :param EnvelopeDefinition envelope_definition: 12474 :return: EnvelopeDocumentsResult 12475 If the method is called asynchronously, 12476 returns the request thread. 12477 """ 12478 kwargs['_return_http_data_only'] = True 12479 if kwargs.get('callback'): 12480 return self.update_documents_with_http_info(account_id, envelope_id, **kwargs) 12481 else: 12482 (data) = self.update_documents_with_http_info(account_id, envelope_id, **kwargs) 12483 return data 12484 12485 def update_documents_with_http_info(self, account_id, envelope_id, **kwargs): 12486 """ 12487 Adds one or more documents to an existing envelope document. 12488 Adds one or more documents to an existing envelope document. 12489 This method makes a synchronous HTTP request by default. To make an 12490 asynchronous HTTP request, please define a `callback` function 12491 to be invoked when receiving the response. 12492 >>> def callback_function(response): 12493 >>> pprint(response) 12494 >>> 12495 >>> thread = api.update_documents_with_http_info(account_id, envelope_id, callback=callback_function) 12496 12497 :param callback function: The callback function 12498 for asynchronous request. (optional) 12499 :param str account_id: The external account number (int) or account ID Guid. (required) 12500 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12501 :param EnvelopeDefinition envelope_definition: 12502 :return: EnvelopeDocumentsResult 12503 If the method is called asynchronously, 12504 returns the request thread. 12505 """ 12506 12507 all_params = ['account_id', 'envelope_id', 'envelope_definition'] 12508 all_params.append('callback') 12509 all_params.append('_return_http_data_only') 12510 all_params.append('_preload_content') 12511 all_params.append('_request_timeout') 12512 12513 params = locals() 12514 for key, val in iteritems(params['kwargs']): 12515 if key not in all_params: 12516 raise TypeError( 12517 "Got an unexpected keyword argument '%s'" 12518 " to method update_documents" % key 12519 ) 12520 params[key] = val 12521 del params['kwargs'] 12522 # verify the required parameter 'account_id' is set 12523 if ('account_id' not in params) or (params['account_id'] is None): 12524 raise ValueError("Missing the required parameter `account_id` when calling `update_documents`") 12525 # verify the required parameter 'envelope_id' is set 12526 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12527 raise ValueError("Missing the required parameter `envelope_id` when calling `update_documents`") 12528 12529 12530 collection_formats = {} 12531 12532 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents'.replace('{format}', 'json') 12533 path_params = {} 12534 if 'account_id' in params: 12535 path_params['accountId'] = params['account_id'] 12536 if 'envelope_id' in params: 12537 path_params['envelopeId'] = params['envelope_id'] 12538 12539 query_params = {} 12540 12541 header_params = {} 12542 12543 form_params = [] 12544 local_var_files = {} 12545 12546 body_params = None 12547 if 'envelope_definition' in params: 12548 body_params = params['envelope_definition'] 12549 # HTTP header `Accept` 12550 header_params['Accept'] = self.api_client.\ 12551 select_header_accept(['application/json']) 12552 12553 # Authentication setting 12554 auth_settings = [] 12555 12556 return self.api_client.call_api(resource_path, 'PUT', 12557 path_params, 12558 query_params, 12559 header_params, 12560 body=body_params, 12561 post_params=form_params, 12562 files=local_var_files, 12563 response_type='EnvelopeDocumentsResult', 12564 auth_settings=auth_settings, 12565 callback=params.get('callback'), 12566 _return_http_data_only=params.get('_return_http_data_only'), 12567 _preload_content=params.get('_preload_content', True), 12568 _request_timeout=params.get('_request_timeout'), 12569 collection_formats=collection_formats) 12570 12571 def update_email_settings(self, account_id, envelope_id, **kwargs): 12572 """ 12573 Updates the email setting overrides for an envelope. 12574 Updates the existing email override settings for the specified envelope. Note that modifying email settings will only affect email communications that occur after the modification was made. This can also be used to delete an individual email override setting by using an empty string for the value to be deleted. 12575 This method makes a synchronous HTTP request by default. To make an 12576 asynchronous HTTP request, please define a `callback` function 12577 to be invoked when receiving the response. 12578 >>> def callback_function(response): 12579 >>> pprint(response) 12580 >>> 12581 >>> thread = api.update_email_settings(account_id, envelope_id, callback=callback_function) 12582 12583 :param callback function: The callback function 12584 for asynchronous request. (optional) 12585 :param str account_id: The external account number (int) or account ID Guid. (required) 12586 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12587 :param EmailSettings email_settings: 12588 :return: EmailSettings 12589 If the method is called asynchronously, 12590 returns the request thread. 12591 """ 12592 kwargs['_return_http_data_only'] = True 12593 if kwargs.get('callback'): 12594 return self.update_email_settings_with_http_info(account_id, envelope_id, **kwargs) 12595 else: 12596 (data) = self.update_email_settings_with_http_info(account_id, envelope_id, **kwargs) 12597 return data 12598 12599 def update_email_settings_with_http_info(self, account_id, envelope_id, **kwargs): 12600 """ 12601 Updates the email setting overrides for an envelope. 12602 Updates the existing email override settings for the specified envelope. Note that modifying email settings will only affect email communications that occur after the modification was made. This can also be used to delete an individual email override setting by using an empty string for the value to be deleted. 12603 This method makes a synchronous HTTP request by default. To make an 12604 asynchronous HTTP request, please define a `callback` function 12605 to be invoked when receiving the response. 12606 >>> def callback_function(response): 12607 >>> pprint(response) 12608 >>> 12609 >>> thread = api.update_email_settings_with_http_info(account_id, envelope_id, callback=callback_function) 12610 12611 :param callback function: The callback function 12612 for asynchronous request. (optional) 12613 :param str account_id: The external account number (int) or account ID Guid. (required) 12614 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12615 :param EmailSettings email_settings: 12616 :return: EmailSettings 12617 If the method is called asynchronously, 12618 returns the request thread. 12619 """ 12620 12621 all_params = ['account_id', 'envelope_id', 'email_settings'] 12622 all_params.append('callback') 12623 all_params.append('_return_http_data_only') 12624 all_params.append('_preload_content') 12625 all_params.append('_request_timeout') 12626 12627 params = locals() 12628 for key, val in iteritems(params['kwargs']): 12629 if key not in all_params: 12630 raise TypeError( 12631 "Got an unexpected keyword argument '%s'" 12632 " to method update_email_settings" % key 12633 ) 12634 params[key] = val 12635 del params['kwargs'] 12636 # verify the required parameter 'account_id' is set 12637 if ('account_id' not in params) or (params['account_id'] is None): 12638 raise ValueError("Missing the required parameter `account_id` when calling `update_email_settings`") 12639 # verify the required parameter 'envelope_id' is set 12640 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12641 raise ValueError("Missing the required parameter `envelope_id` when calling `update_email_settings`") 12642 12643 12644 collection_formats = {} 12645 12646 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/email_settings'.replace('{format}', 'json') 12647 path_params = {} 12648 if 'account_id' in params: 12649 path_params['accountId'] = params['account_id'] 12650 if 'envelope_id' in params: 12651 path_params['envelopeId'] = params['envelope_id'] 12652 12653 query_params = {} 12654 12655 header_params = {} 12656 12657 form_params = [] 12658 local_var_files = {} 12659 12660 body_params = None 12661 if 'email_settings' in params: 12662 body_params = params['email_settings'] 12663 # HTTP header `Accept` 12664 header_params['Accept'] = self.api_client.\ 12665 select_header_accept(['application/json']) 12666 12667 # Authentication setting 12668 auth_settings = [] 12669 12670 return self.api_client.call_api(resource_path, 'PUT', 12671 path_params, 12672 query_params, 12673 header_params, 12674 body=body_params, 12675 post_params=form_params, 12676 files=local_var_files, 12677 response_type='EmailSettings', 12678 auth_settings=auth_settings, 12679 callback=params.get('callback'), 12680 _return_http_data_only=params.get('_return_http_data_only'), 12681 _preload_content=params.get('_preload_content', True), 12682 _request_timeout=params.get('_request_timeout'), 12683 collection_formats=collection_formats) 12684 12685 def update_envelope_delayed_routing_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 12686 """ 12687 Updates the delayed routing rules for an envelope's workflow step definition. 12688 This method makes a synchronous HTTP request by default. To make an 12689 asynchronous HTTP request, please define a `callback` function 12690 to be invoked when receiving the response. 12691 >>> def callback_function(response): 12692 >>> pprint(response) 12693 >>> 12694 >>> thread = api.update_envelope_delayed_routing_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 12695 12696 :param callback function: The callback function 12697 for asynchronous request. (optional) 12698 :param str account_id: The external account number (int) or account ID Guid. (required) 12699 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12700 :param str workflow_step_id: (required) 12701 :param DelayedRouting delayed_routing: 12702 :return: DelayedRouting 12703 If the method is called asynchronously, 12704 returns the request thread. 12705 """ 12706 kwargs['_return_http_data_only'] = True 12707 if kwargs.get('callback'): 12708 return self.update_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 12709 else: 12710 (data) = self.update_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 12711 return data 12712 12713 def update_envelope_delayed_routing_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 12714 """ 12715 Updates the delayed routing rules for an envelope's workflow step definition. 12716 This method makes a synchronous HTTP request by default. To make an 12717 asynchronous HTTP request, please define a `callback` function 12718 to be invoked when receiving the response. 12719 >>> def callback_function(response): 12720 >>> pprint(response) 12721 >>> 12722 >>> thread = api.update_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 12723 12724 :param callback function: The callback function 12725 for asynchronous request. (optional) 12726 :param str account_id: The external account number (int) or account ID Guid. (required) 12727 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12728 :param str workflow_step_id: (required) 12729 :param DelayedRouting delayed_routing: 12730 :return: DelayedRouting 12731 If the method is called asynchronously, 12732 returns the request thread. 12733 """ 12734 12735 all_params = ['account_id', 'envelope_id', 'workflow_step_id', 'delayed_routing'] 12736 all_params.append('callback') 12737 all_params.append('_return_http_data_only') 12738 all_params.append('_preload_content') 12739 all_params.append('_request_timeout') 12740 12741 params = locals() 12742 for key, val in iteritems(params['kwargs']): 12743 if key not in all_params: 12744 raise TypeError( 12745 "Got an unexpected keyword argument '%s'" 12746 " to method update_envelope_delayed_routing_definition" % key 12747 ) 12748 params[key] = val 12749 del params['kwargs'] 12750 # verify the required parameter 'account_id' is set 12751 if ('account_id' not in params) or (params['account_id'] is None): 12752 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_delayed_routing_definition`") 12753 # verify the required parameter 'envelope_id' is set 12754 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12755 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_delayed_routing_definition`") 12756 # verify the required parameter 'workflow_step_id' is set 12757 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 12758 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_envelope_delayed_routing_definition`") 12759 12760 12761 collection_formats = {} 12762 12763 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 12764 path_params = {} 12765 if 'account_id' in params: 12766 path_params['accountId'] = params['account_id'] 12767 if 'envelope_id' in params: 12768 path_params['envelopeId'] = params['envelope_id'] 12769 if 'workflow_step_id' in params: 12770 path_params['workflowStepId'] = params['workflow_step_id'] 12771 12772 query_params = {} 12773 12774 header_params = {} 12775 12776 form_params = [] 12777 local_var_files = {} 12778 12779 body_params = None 12780 if 'delayed_routing' in params: 12781 body_params = params['delayed_routing'] 12782 # HTTP header `Accept` 12783 header_params['Accept'] = self.api_client.\ 12784 select_header_accept(['application/json']) 12785 12786 # Authentication setting 12787 auth_settings = [] 12788 12789 return self.api_client.call_api(resource_path, 'PUT', 12790 path_params, 12791 query_params, 12792 header_params, 12793 body=body_params, 12794 post_params=form_params, 12795 files=local_var_files, 12796 response_type='DelayedRouting', 12797 auth_settings=auth_settings, 12798 callback=params.get('callback'), 12799 _return_http_data_only=params.get('_return_http_data_only'), 12800 _preload_content=params.get('_preload_content', True), 12801 _request_timeout=params.get('_request_timeout'), 12802 collection_formats=collection_formats) 12803 12804 def update_envelope_doc_gen_form_fields(self, account_id, envelope_id, **kwargs): 12805 """ 12806 Updates formfields for an envelope 12807 This method makes a synchronous HTTP request by default. To make an 12808 asynchronous HTTP request, please define a `callback` function 12809 to be invoked when receiving the response. 12810 >>> def callback_function(response): 12811 >>> pprint(response) 12812 >>> 12813 >>> thread = api.update_envelope_doc_gen_form_fields(account_id, envelope_id, callback=callback_function) 12814 12815 :param callback function: The callback function 12816 for asynchronous request. (optional) 12817 :param str account_id: The external account number (int) or account ID Guid. (required) 12818 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12819 :param str update_docgen_formfields_only: 12820 :param DocGenFormFieldRequest doc_gen_form_field_request: 12821 :return: DocGenFormFieldResponse 12822 If the method is called asynchronously, 12823 returns the request thread. 12824 """ 12825 kwargs['_return_http_data_only'] = True 12826 if kwargs.get('callback'): 12827 return self.update_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, **kwargs) 12828 else: 12829 (data) = self.update_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, **kwargs) 12830 return data 12831 12832 def update_envelope_doc_gen_form_fields_with_http_info(self, account_id, envelope_id, **kwargs): 12833 """ 12834 Updates formfields for an envelope 12835 This method makes a synchronous HTTP request by default. To make an 12836 asynchronous HTTP request, please define a `callback` function 12837 to be invoked when receiving the response. 12838 >>> def callback_function(response): 12839 >>> pprint(response) 12840 >>> 12841 >>> thread = api.update_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, callback=callback_function) 12842 12843 :param callback function: The callback function 12844 for asynchronous request. (optional) 12845 :param str account_id: The external account number (int) or account ID Guid. (required) 12846 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12847 :param str update_docgen_formfields_only: 12848 :param DocGenFormFieldRequest doc_gen_form_field_request: 12849 :return: DocGenFormFieldResponse 12850 If the method is called asynchronously, 12851 returns the request thread. 12852 """ 12853 12854 all_params = ['account_id', 'envelope_id', 'update_docgen_formfields_only', 'doc_gen_form_field_request'] 12855 all_params.append('callback') 12856 all_params.append('_return_http_data_only') 12857 all_params.append('_preload_content') 12858 all_params.append('_request_timeout') 12859 12860 params = locals() 12861 for key, val in iteritems(params['kwargs']): 12862 if key not in all_params: 12863 raise TypeError( 12864 "Got an unexpected keyword argument '%s'" 12865 " to method update_envelope_doc_gen_form_fields" % key 12866 ) 12867 params[key] = val 12868 del params['kwargs'] 12869 # verify the required parameter 'account_id' is set 12870 if ('account_id' not in params) or (params['account_id'] is None): 12871 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_doc_gen_form_fields`") 12872 # verify the required parameter 'envelope_id' is set 12873 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12874 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_doc_gen_form_fields`") 12875 12876 12877 collection_formats = {} 12878 12879 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/docGenFormFields'.replace('{format}', 'json') 12880 path_params = {} 12881 if 'account_id' in params: 12882 path_params['accountId'] = params['account_id'] 12883 if 'envelope_id' in params: 12884 path_params['envelopeId'] = params['envelope_id'] 12885 12886 query_params = {} 12887 if 'update_docgen_formfields_only' in params: 12888 query_params['update_docgen_formfields_only'] = params['update_docgen_formfields_only'] 12889 12890 header_params = {} 12891 12892 form_params = [] 12893 local_var_files = {} 12894 12895 body_params = None 12896 if 'doc_gen_form_field_request' in params: 12897 body_params = params['doc_gen_form_field_request'] 12898 # HTTP header `Accept` 12899 header_params['Accept'] = self.api_client.\ 12900 select_header_accept(['application/json']) 12901 12902 # Authentication setting 12903 auth_settings = [] 12904 12905 return self.api_client.call_api(resource_path, 'PUT', 12906 path_params, 12907 query_params, 12908 header_params, 12909 body=body_params, 12910 post_params=form_params, 12911 files=local_var_files, 12912 response_type='DocGenFormFieldResponse', 12913 auth_settings=auth_settings, 12914 callback=params.get('callback'), 12915 _return_http_data_only=params.get('_return_http_data_only'), 12916 _preload_content=params.get('_preload_content', True), 12917 _request_timeout=params.get('_request_timeout'), 12918 collection_formats=collection_formats) 12919 12920 def update_envelope_scheduled_sending_definition(self, account_id, envelope_id, **kwargs): 12921 """ 12922 Updates the scheduled sending rules for an envelope's workflow definition. 12923 This method makes a synchronous HTTP request by default. To make an 12924 asynchronous HTTP request, please define a `callback` function 12925 to be invoked when receiving the response. 12926 >>> def callback_function(response): 12927 >>> pprint(response) 12928 >>> 12929 >>> thread = api.update_envelope_scheduled_sending_definition(account_id, envelope_id, callback=callback_function) 12930 12931 :param callback function: The callback function 12932 for asynchronous request. (optional) 12933 :param str account_id: The external account number (int) or account ID Guid. (required) 12934 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12935 :param ScheduledSending scheduled_sending: 12936 :return: ScheduledSending 12937 If the method is called asynchronously, 12938 returns the request thread. 12939 """ 12940 kwargs['_return_http_data_only'] = True 12941 if kwargs.get('callback'): 12942 return self.update_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 12943 else: 12944 (data) = self.update_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 12945 return data 12946 12947 def update_envelope_scheduled_sending_definition_with_http_info(self, account_id, envelope_id, **kwargs): 12948 """ 12949 Updates the scheduled sending rules for an envelope's workflow definition. 12950 This method makes a synchronous HTTP request by default. To make an 12951 asynchronous HTTP request, please define a `callback` function 12952 to be invoked when receiving the response. 12953 >>> def callback_function(response): 12954 >>> pprint(response) 12955 >>> 12956 >>> thread = api.update_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, callback=callback_function) 12957 12958 :param callback function: The callback function 12959 for asynchronous request. (optional) 12960 :param str account_id: The external account number (int) or account ID Guid. (required) 12961 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12962 :param ScheduledSending scheduled_sending: 12963 :return: ScheduledSending 12964 If the method is called asynchronously, 12965 returns the request thread. 12966 """ 12967 12968 all_params = ['account_id', 'envelope_id', 'scheduled_sending'] 12969 all_params.append('callback') 12970 all_params.append('_return_http_data_only') 12971 all_params.append('_preload_content') 12972 all_params.append('_request_timeout') 12973 12974 params = locals() 12975 for key, val in iteritems(params['kwargs']): 12976 if key not in all_params: 12977 raise TypeError( 12978 "Got an unexpected keyword argument '%s'" 12979 " to method update_envelope_scheduled_sending_definition" % key 12980 ) 12981 params[key] = val 12982 del params['kwargs'] 12983 # verify the required parameter 'account_id' is set 12984 if ('account_id' not in params) or (params['account_id'] is None): 12985 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_scheduled_sending_definition`") 12986 # verify the required parameter 'envelope_id' is set 12987 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12988 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_scheduled_sending_definition`") 12989 12990 12991 collection_formats = {} 12992 12993 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/scheduledSending'.replace('{format}', 'json') 12994 path_params = {} 12995 if 'account_id' in params: 12996 path_params['accountId'] = params['account_id'] 12997 if 'envelope_id' in params: 12998 path_params['envelopeId'] = params['envelope_id'] 12999 13000 query_params = {} 13001 13002 header_params = {} 13003 13004 form_params = [] 13005 local_var_files = {} 13006 13007 body_params = None 13008 if 'scheduled_sending' in params: 13009 body_params = params['scheduled_sending'] 13010 # HTTP header `Accept` 13011 header_params['Accept'] = self.api_client.\ 13012 select_header_accept(['application/json']) 13013 13014 # Authentication setting 13015 auth_settings = [] 13016 13017 return self.api_client.call_api(resource_path, 'PUT', 13018 path_params, 13019 query_params, 13020 header_params, 13021 body=body_params, 13022 post_params=form_params, 13023 files=local_var_files, 13024 response_type='ScheduledSending', 13025 auth_settings=auth_settings, 13026 callback=params.get('callback'), 13027 _return_http_data_only=params.get('_return_http_data_only'), 13028 _preload_content=params.get('_preload_content', True), 13029 _request_timeout=params.get('_request_timeout'), 13030 collection_formats=collection_formats) 13031 13032 def update_envelope_transfer_rule(self, account_id, envelope_transfer_rule_id, **kwargs): 13033 """ 13034 Update an envelope transfer rule for an account. 13035 This method changes the status of an envelope transfer rule. You use this method to change whether or not the rule is enabled. You must include the `envelopeTransferRuleId` both as a query parameter, and in the request body. **Note:** You cannot change any other information about the envelope transfer rule. Only Administrators can update an envelope transfer rule. In addition, to use envelope transfer rules, the **Transfer Custody** feature must be enabled for your account. 13036 This method makes a synchronous HTTP request by default. To make an 13037 asynchronous HTTP request, please define a `callback` function 13038 to be invoked when receiving the response. 13039 >>> def callback_function(response): 13040 >>> pprint(response) 13041 >>> 13042 >>> thread = api.update_envelope_transfer_rule(account_id, envelope_transfer_rule_id, callback=callback_function) 13043 13044 :param callback function: The callback function 13045 for asynchronous request. (optional) 13046 :param str account_id: The external account number (int) or account ID Guid. (required) 13047 :param str envelope_transfer_rule_id: (required) 13048 :param EnvelopeTransferRule envelope_transfer_rule: 13049 :return: EnvelopeTransferRule 13050 If the method is called asynchronously, 13051 returns the request thread. 13052 """ 13053 kwargs['_return_http_data_only'] = True 13054 if kwargs.get('callback'): 13055 return self.update_envelope_transfer_rule_with_http_info(account_id, envelope_transfer_rule_id, **kwargs) 13056 else: 13057 (data) = self.update_envelope_transfer_rule_with_http_info(account_id, envelope_transfer_rule_id, **kwargs) 13058 return data 13059 13060 def update_envelope_transfer_rule_with_http_info(self, account_id, envelope_transfer_rule_id, **kwargs): 13061 """ 13062 Update an envelope transfer rule for an account. 13063 This method changes the status of an envelope transfer rule. You use this method to change whether or not the rule is enabled. You must include the `envelopeTransferRuleId` both as a query parameter, and in the request body. **Note:** You cannot change any other information about the envelope transfer rule. Only Administrators can update an envelope transfer rule. In addition, to use envelope transfer rules, the **Transfer Custody** feature must be enabled for your account. 13064 This method makes a synchronous HTTP request by default. To make an 13065 asynchronous HTTP request, please define a `callback` function 13066 to be invoked when receiving the response. 13067 >>> def callback_function(response): 13068 >>> pprint(response) 13069 >>> 13070 >>> thread = api.update_envelope_transfer_rule_with_http_info(account_id, envelope_transfer_rule_id, callback=callback_function) 13071 13072 :param callback function: The callback function 13073 for asynchronous request. (optional) 13074 :param str account_id: The external account number (int) or account ID Guid. (required) 13075 :param str envelope_transfer_rule_id: (required) 13076 :param EnvelopeTransferRule envelope_transfer_rule: 13077 :return: EnvelopeTransferRule 13078 If the method is called asynchronously, 13079 returns the request thread. 13080 """ 13081 13082 all_params = ['account_id', 'envelope_transfer_rule_id', 'envelope_transfer_rule'] 13083 all_params.append('callback') 13084 all_params.append('_return_http_data_only') 13085 all_params.append('_preload_content') 13086 all_params.append('_request_timeout') 13087 13088 params = locals() 13089 for key, val in iteritems(params['kwargs']): 13090 if key not in all_params: 13091 raise TypeError( 13092 "Got an unexpected keyword argument '%s'" 13093 " to method update_envelope_transfer_rule" % key 13094 ) 13095 params[key] = val 13096 del params['kwargs'] 13097 # verify the required parameter 'account_id' is set 13098 if ('account_id' not in params) or (params['account_id'] is None): 13099 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_transfer_rule`") 13100 # verify the required parameter 'envelope_transfer_rule_id' is set 13101 if ('envelope_transfer_rule_id' not in params) or (params['envelope_transfer_rule_id'] is None): 13102 raise ValueError("Missing the required parameter `envelope_transfer_rule_id` when calling `update_envelope_transfer_rule`") 13103 13104 13105 collection_formats = {} 13106 13107 resource_path = '/v2.1/accounts/{accountId}/envelopes/transfer_rules/{envelopeTransferRuleId}'.replace('{format}', 'json') 13108 path_params = {} 13109 if 'account_id' in params: 13110 path_params['accountId'] = params['account_id'] 13111 if 'envelope_transfer_rule_id' in params: 13112 path_params['envelopeTransferRuleId'] = params['envelope_transfer_rule_id'] 13113 13114 query_params = {} 13115 13116 header_params = {} 13117 13118 form_params = [] 13119 local_var_files = {} 13120 13121 body_params = None 13122 if 'envelope_transfer_rule' in params: 13123 body_params = params['envelope_transfer_rule'] 13124 # HTTP header `Accept` 13125 header_params['Accept'] = self.api_client.\ 13126 select_header_accept(['application/json']) 13127 13128 # Authentication setting 13129 auth_settings = [] 13130 13131 return self.api_client.call_api(resource_path, 'PUT', 13132 path_params, 13133 query_params, 13134 header_params, 13135 body=body_params, 13136 post_params=form_params, 13137 files=local_var_files, 13138 response_type='EnvelopeTransferRule', 13139 auth_settings=auth_settings, 13140 callback=params.get('callback'), 13141 _return_http_data_only=params.get('_return_http_data_only'), 13142 _preload_content=params.get('_preload_content', True), 13143 _request_timeout=params.get('_request_timeout'), 13144 collection_formats=collection_formats) 13145 13146 def update_envelope_transfer_rules(self, account_id, **kwargs): 13147 """ 13148 Update envelope transfer rules for an account. 13149 This method changes the status for one or more envelope transfer rules based on the `envelopeTransferRuleId`s in the request body. You use this method to change whether or not the rules are enabled. **Note:** You cannot change any other information about the envelope transfer rule. Only Administrators can update envelope transfer rules. In addition, to use envelope transfer rules, the **Transfer Custody** feature must be enabled for your account. 13150 This method makes a synchronous HTTP request by default. To make an 13151 asynchronous HTTP request, please define a `callback` function 13152 to be invoked when receiving the response. 13153 >>> def callback_function(response): 13154 >>> pprint(response) 13155 >>> 13156 >>> thread = api.update_envelope_transfer_rules(account_id, callback=callback_function) 13157 13158 :param callback function: The callback function 13159 for asynchronous request. (optional) 13160 :param str account_id: The external account number (int) or account ID Guid. (required) 13161 :param EnvelopeTransferRuleInformation envelope_transfer_rule_information: 13162 :return: EnvelopeTransferRuleInformation 13163 If the method is called asynchronously, 13164 returns the request thread. 13165 """ 13166 kwargs['_return_http_data_only'] = True 13167 if kwargs.get('callback'): 13168 return self.update_envelope_transfer_rules_with_http_info(account_id, **kwargs) 13169 else: 13170 (data) = self.update_envelope_transfer_rules_with_http_info(account_id, **kwargs) 13171 return data 13172 13173 def update_envelope_transfer_rules_with_http_info(self, account_id, **kwargs): 13174 """ 13175 Update envelope transfer rules for an account. 13176 This method changes the status for one or more envelope transfer rules based on the `envelopeTransferRuleId`s in the request body. You use this method to change whether or not the rules are enabled. **Note:** You cannot change any other information about the envelope transfer rule. Only Administrators can update envelope transfer rules. In addition, to use envelope transfer rules, the **Transfer Custody** feature must be enabled for your account. 13177 This method makes a synchronous HTTP request by default. To make an 13178 asynchronous HTTP request, please define a `callback` function 13179 to be invoked when receiving the response. 13180 >>> def callback_function(response): 13181 >>> pprint(response) 13182 >>> 13183 >>> thread = api.update_envelope_transfer_rules_with_http_info(account_id, callback=callback_function) 13184 13185 :param callback function: The callback function 13186 for asynchronous request. (optional) 13187 :param str account_id: The external account number (int) or account ID Guid. (required) 13188 :param EnvelopeTransferRuleInformation envelope_transfer_rule_information: 13189 :return: EnvelopeTransferRuleInformation 13190 If the method is called asynchronously, 13191 returns the request thread. 13192 """ 13193 13194 all_params = ['account_id', 'envelope_transfer_rule_information'] 13195 all_params.append('callback') 13196 all_params.append('_return_http_data_only') 13197 all_params.append('_preload_content') 13198 all_params.append('_request_timeout') 13199 13200 params = locals() 13201 for key, val in iteritems(params['kwargs']): 13202 if key not in all_params: 13203 raise TypeError( 13204 "Got an unexpected keyword argument '%s'" 13205 " to method update_envelope_transfer_rules" % key 13206 ) 13207 params[key] = val 13208 del params['kwargs'] 13209 # verify the required parameter 'account_id' is set 13210 if ('account_id' not in params) or (params['account_id'] is None): 13211 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_transfer_rules`") 13212 13213 13214 collection_formats = {} 13215 13216 resource_path = '/v2.1/accounts/{accountId}/envelopes/transfer_rules'.replace('{format}', 'json') 13217 path_params = {} 13218 if 'account_id' in params: 13219 path_params['accountId'] = params['account_id'] 13220 13221 query_params = {} 13222 13223 header_params = {} 13224 13225 form_params = [] 13226 local_var_files = {} 13227 13228 body_params = None 13229 if 'envelope_transfer_rule_information' in params: 13230 body_params = params['envelope_transfer_rule_information'] 13231 # HTTP header `Accept` 13232 header_params['Accept'] = self.api_client.\ 13233 select_header_accept(['application/json']) 13234 13235 # Authentication setting 13236 auth_settings = [] 13237 13238 return self.api_client.call_api(resource_path, 'PUT', 13239 path_params, 13240 query_params, 13241 header_params, 13242 body=body_params, 13243 post_params=form_params, 13244 files=local_var_files, 13245 response_type='EnvelopeTransferRuleInformation', 13246 auth_settings=auth_settings, 13247 callback=params.get('callback'), 13248 _return_http_data_only=params.get('_return_http_data_only'), 13249 _preload_content=params.get('_preload_content', True), 13250 _request_timeout=params.get('_request_timeout'), 13251 collection_formats=collection_formats) 13252 13253 def update_envelope_workflow_definition(self, account_id, envelope_id, **kwargs): 13254 """ 13255 Updates the envelope workflow definition for an envelope. 13256 Updates the specified envelope's workflow definition if it has one. 13257 This method makes a synchronous HTTP request by default. To make an 13258 asynchronous HTTP request, please define a `callback` function 13259 to be invoked when receiving the response. 13260 >>> def callback_function(response): 13261 >>> pprint(response) 13262 >>> 13263 >>> thread = api.update_envelope_workflow_definition(account_id, envelope_id, callback=callback_function) 13264 13265 :param callback function: The callback function 13266 for asynchronous request. (optional) 13267 :param str account_id: The external account number (int) or account ID Guid. (required) 13268 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13269 :param Workflow workflow: 13270 :return: Workflow 13271 If the method is called asynchronously, 13272 returns the request thread. 13273 """ 13274 kwargs['_return_http_data_only'] = True 13275 if kwargs.get('callback'): 13276 return self.update_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 13277 else: 13278 (data) = self.update_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 13279 return data 13280 13281 def update_envelope_workflow_definition_with_http_info(self, account_id, envelope_id, **kwargs): 13282 """ 13283 Updates the envelope workflow definition for an envelope. 13284 Updates the specified envelope's workflow definition if it has one. 13285 This method makes a synchronous HTTP request by default. To make an 13286 asynchronous HTTP request, please define a `callback` function 13287 to be invoked when receiving the response. 13288 >>> def callback_function(response): 13289 >>> pprint(response) 13290 >>> 13291 >>> thread = api.update_envelope_workflow_definition_with_http_info(account_id, envelope_id, callback=callback_function) 13292 13293 :param callback function: The callback function 13294 for asynchronous request. (optional) 13295 :param str account_id: The external account number (int) or account ID Guid. (required) 13296 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13297 :param Workflow workflow: 13298 :return: Workflow 13299 If the method is called asynchronously, 13300 returns the request thread. 13301 """ 13302 13303 all_params = ['account_id', 'envelope_id', 'workflow'] 13304 all_params.append('callback') 13305 all_params.append('_return_http_data_only') 13306 all_params.append('_preload_content') 13307 all_params.append('_request_timeout') 13308 13309 params = locals() 13310 for key, val in iteritems(params['kwargs']): 13311 if key not in all_params: 13312 raise TypeError( 13313 "Got an unexpected keyword argument '%s'" 13314 " to method update_envelope_workflow_definition" % key 13315 ) 13316 params[key] = val 13317 del params['kwargs'] 13318 # verify the required parameter 'account_id' is set 13319 if ('account_id' not in params) or (params['account_id'] is None): 13320 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_workflow_definition`") 13321 # verify the required parameter 'envelope_id' is set 13322 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13323 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_workflow_definition`") 13324 13325 13326 collection_formats = {} 13327 13328 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow'.replace('{format}', 'json') 13329 path_params = {} 13330 if 'account_id' in params: 13331 path_params['accountId'] = params['account_id'] 13332 if 'envelope_id' in params: 13333 path_params['envelopeId'] = params['envelope_id'] 13334 13335 query_params = {} 13336 13337 header_params = {} 13338 13339 form_params = [] 13340 local_var_files = {} 13341 13342 body_params = None 13343 if 'workflow' in params: 13344 body_params = params['workflow'] 13345 # HTTP header `Accept` 13346 header_params['Accept'] = self.api_client.\ 13347 select_header_accept(['application/json']) 13348 13349 # Authentication setting 13350 auth_settings = [] 13351 13352 return self.api_client.call_api(resource_path, 'PUT', 13353 path_params, 13354 query_params, 13355 header_params, 13356 body=body_params, 13357 post_params=form_params, 13358 files=local_var_files, 13359 response_type='Workflow', 13360 auth_settings=auth_settings, 13361 callback=params.get('callback'), 13362 _return_http_data_only=params.get('_return_http_data_only'), 13363 _preload_content=params.get('_preload_content', True), 13364 _request_timeout=params.get('_request_timeout'), 13365 collection_formats=collection_formats) 13366 13367 def update_envelope_workflow_step_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 13368 """ 13369 Updates the envelope workflow step definition for an envelope. 13370 This method makes a synchronous HTTP request by default. To make an 13371 asynchronous HTTP request, please define a `callback` function 13372 to be invoked when receiving the response. 13373 >>> def callback_function(response): 13374 >>> pprint(response) 13375 >>> 13376 >>> thread = api.update_envelope_workflow_step_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 13377 13378 :param callback function: The callback function 13379 for asynchronous request. (optional) 13380 :param str account_id: The external account number (int) or account ID Guid. (required) 13381 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13382 :param str workflow_step_id: (required) 13383 :param WorkflowStep workflow_step: 13384 :return: WorkflowStep 13385 If the method is called asynchronously, 13386 returns the request thread. 13387 """ 13388 kwargs['_return_http_data_only'] = True 13389 if kwargs.get('callback'): 13390 return self.update_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 13391 else: 13392 (data) = self.update_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 13393 return data 13394 13395 def update_envelope_workflow_step_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 13396 """ 13397 Updates the envelope workflow step definition for an envelope. 13398 This method makes a synchronous HTTP request by default. To make an 13399 asynchronous HTTP request, please define a `callback` function 13400 to be invoked when receiving the response. 13401 >>> def callback_function(response): 13402 >>> pprint(response) 13403 >>> 13404 >>> thread = api.update_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 13405 13406 :param callback function: The callback function 13407 for asynchronous request. (optional) 13408 :param str account_id: The external account number (int) or account ID Guid. (required) 13409 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13410 :param str workflow_step_id: (required) 13411 :param WorkflowStep workflow_step: 13412 :return: WorkflowStep 13413 If the method is called asynchronously, 13414 returns the request thread. 13415 """ 13416 13417 all_params = ['account_id', 'envelope_id', 'workflow_step_id', 'workflow_step'] 13418 all_params.append('callback') 13419 all_params.append('_return_http_data_only') 13420 all_params.append('_preload_content') 13421 all_params.append('_request_timeout') 13422 13423 params = locals() 13424 for key, val in iteritems(params['kwargs']): 13425 if key not in all_params: 13426 raise TypeError( 13427 "Got an unexpected keyword argument '%s'" 13428 " to method update_envelope_workflow_step_definition" % key 13429 ) 13430 params[key] = val 13431 del params['kwargs'] 13432 # verify the required parameter 'account_id' is set 13433 if ('account_id' not in params) or (params['account_id'] is None): 13434 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_workflow_step_definition`") 13435 # verify the required parameter 'envelope_id' is set 13436 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13437 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_workflow_step_definition`") 13438 # verify the required parameter 'workflow_step_id' is set 13439 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 13440 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_envelope_workflow_step_definition`") 13441 13442 13443 collection_formats = {} 13444 13445 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 13446 path_params = {} 13447 if 'account_id' in params: 13448 path_params['accountId'] = params['account_id'] 13449 if 'envelope_id' in params: 13450 path_params['envelopeId'] = params['envelope_id'] 13451 if 'workflow_step_id' in params: 13452 path_params['workflowStepId'] = params['workflow_step_id'] 13453 13454 query_params = {} 13455 13456 header_params = {} 13457 13458 form_params = [] 13459 local_var_files = {} 13460 13461 body_params = None 13462 if 'workflow_step' in params: 13463 body_params = params['workflow_step'] 13464 # HTTP header `Accept` 13465 header_params['Accept'] = self.api_client.\ 13466 select_header_accept(['application/json']) 13467 13468 # Authentication setting 13469 auth_settings = [] 13470 13471 return self.api_client.call_api(resource_path, 'PUT', 13472 path_params, 13473 query_params, 13474 header_params, 13475 body=body_params, 13476 post_params=form_params, 13477 files=local_var_files, 13478 response_type='WorkflowStep', 13479 auth_settings=auth_settings, 13480 callback=params.get('callback'), 13481 _return_http_data_only=params.get('_return_http_data_only'), 13482 _preload_content=params.get('_preload_content', True), 13483 _request_timeout=params.get('_request_timeout'), 13484 collection_formats=collection_formats) 13485 13486 def update_lock(self, account_id, envelope_id, **kwargs): 13487 """ 13488 Updates an envelope lock. 13489 Updates the lock duration time or update the `lockedByApp` property information for the specified envelope. The user and integrator key must match the user specified by the `lockByUser` property and integrator key information and the `X-DocuSign-Edit` header must be included or an error will be generated. 13490 This method makes a synchronous HTTP request by default. To make an 13491 asynchronous HTTP request, please define a `callback` function 13492 to be invoked when receiving the response. 13493 >>> def callback_function(response): 13494 >>> pprint(response) 13495 >>> 13496 >>> thread = api.update_lock(account_id, envelope_id, callback=callback_function) 13497 13498 :param callback function: The callback function 13499 for asynchronous request. (optional) 13500 :param str account_id: The external account number (int) or account ID Guid. (required) 13501 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13502 :param LockRequest lock_request: 13503 :return: LockInformation 13504 If the method is called asynchronously, 13505 returns the request thread. 13506 """ 13507 kwargs['_return_http_data_only'] = True 13508 if kwargs.get('callback'): 13509 return self.update_lock_with_http_info(account_id, envelope_id, **kwargs) 13510 else: 13511 (data) = self.update_lock_with_http_info(account_id, envelope_id, **kwargs) 13512 return data 13513 13514 def update_lock_with_http_info(self, account_id, envelope_id, **kwargs): 13515 """ 13516 Updates an envelope lock. 13517 Updates the lock duration time or update the `lockedByApp` property information for the specified envelope. The user and integrator key must match the user specified by the `lockByUser` property and integrator key information and the `X-DocuSign-Edit` header must be included or an error will be generated. 13518 This method makes a synchronous HTTP request by default. To make an 13519 asynchronous HTTP request, please define a `callback` function 13520 to be invoked when receiving the response. 13521 >>> def callback_function(response): 13522 >>> pprint(response) 13523 >>> 13524 >>> thread = api.update_lock_with_http_info(account_id, envelope_id, callback=callback_function) 13525 13526 :param callback function: The callback function 13527 for asynchronous request. (optional) 13528 :param str account_id: The external account number (int) or account ID Guid. (required) 13529 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13530 :param LockRequest lock_request: 13531 :return: LockInformation 13532 If the method is called asynchronously, 13533 returns the request thread. 13534 """ 13535 13536 all_params = ['account_id', 'envelope_id', 'lock_request'] 13537 all_params.append('callback') 13538 all_params.append('_return_http_data_only') 13539 all_params.append('_preload_content') 13540 all_params.append('_request_timeout') 13541 13542 params = locals() 13543 for key, val in iteritems(params['kwargs']): 13544 if key not in all_params: 13545 raise TypeError( 13546 "Got an unexpected keyword argument '%s'" 13547 " to method update_lock" % key 13548 ) 13549 params[key] = val 13550 del params['kwargs'] 13551 # verify the required parameter 'account_id' is set 13552 if ('account_id' not in params) or (params['account_id'] is None): 13553 raise ValueError("Missing the required parameter `account_id` when calling `update_lock`") 13554 # verify the required parameter 'envelope_id' is set 13555 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13556 raise ValueError("Missing the required parameter `envelope_id` when calling `update_lock`") 13557 13558 13559 collection_formats = {} 13560 13561 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/lock'.replace('{format}', 'json') 13562 path_params = {} 13563 if 'account_id' in params: 13564 path_params['accountId'] = params['account_id'] 13565 if 'envelope_id' in params: 13566 path_params['envelopeId'] = params['envelope_id'] 13567 13568 query_params = {} 13569 13570 header_params = {} 13571 13572 form_params = [] 13573 local_var_files = {} 13574 13575 body_params = None 13576 if 'lock_request' in params: 13577 body_params = params['lock_request'] 13578 # HTTP header `Accept` 13579 header_params['Accept'] = self.api_client.\ 13580 select_header_accept(['application/json']) 13581 13582 # Authentication setting 13583 auth_settings = [] 13584 13585 return self.api_client.call_api(resource_path, 'PUT', 13586 path_params, 13587 query_params, 13588 header_params, 13589 body=body_params, 13590 post_params=form_params, 13591 files=local_var_files, 13592 response_type='LockInformation', 13593 auth_settings=auth_settings, 13594 callback=params.get('callback'), 13595 _return_http_data_only=params.get('_return_http_data_only'), 13596 _preload_content=params.get('_preload_content', True), 13597 _request_timeout=params.get('_request_timeout'), 13598 collection_formats=collection_formats) 13599 13600 def update_notification_settings(self, account_id, envelope_id, **kwargs): 13601 """ 13602 Sets envelope notification (Reminders/Expirations) structure for an existing envelope. 13603 This method sets the notifications (reminders and expirations) for an existing envelope. The request body sends a structure containing reminders and expirations settings. It also specifies whether to use the settings specified in the request, or the account default notification settings for the envelope. Note that this request only specifies when notifications are sent; it does not initiate sending of email messages. 13604 This method makes a synchronous HTTP request by default. To make an 13605 asynchronous HTTP request, please define a `callback` function 13606 to be invoked when receiving the response. 13607 >>> def callback_function(response): 13608 >>> pprint(response) 13609 >>> 13610 >>> thread = api.update_notification_settings(account_id, envelope_id, callback=callback_function) 13611 13612 :param callback function: The callback function 13613 for asynchronous request. (optional) 13614 :param str account_id: The external account number (int) or account ID Guid. (required) 13615 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13616 :param EnvelopeNotificationRequest envelope_notification_request: 13617 :return: Notification 13618 If the method is called asynchronously, 13619 returns the request thread. 13620 """ 13621 kwargs['_return_http_data_only'] = True 13622 if kwargs.get('callback'): 13623 return self.update_notification_settings_with_http_info(account_id, envelope_id, **kwargs) 13624 else: 13625 (data) = self.update_notification_settings_with_http_info(account_id, envelope_id, **kwargs) 13626 return data 13627 13628 def update_notification_settings_with_http_info(self, account_id, envelope_id, **kwargs): 13629 """ 13630 Sets envelope notification (Reminders/Expirations) structure for an existing envelope. 13631 This method sets the notifications (reminders and expirations) for an existing envelope. The request body sends a structure containing reminders and expirations settings. It also specifies whether to use the settings specified in the request, or the account default notification settings for the envelope. Note that this request only specifies when notifications are sent; it does not initiate sending of email messages. 13632 This method makes a synchronous HTTP request by default. To make an 13633 asynchronous HTTP request, please define a `callback` function 13634 to be invoked when receiving the response. 13635 >>> def callback_function(response): 13636 >>> pprint(response) 13637 >>> 13638 >>> thread = api.update_notification_settings_with_http_info(account_id, envelope_id, callback=callback_function) 13639 13640 :param callback function: The callback function 13641 for asynchronous request. (optional) 13642 :param str account_id: The external account number (int) or account ID Guid. (required) 13643 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13644 :param EnvelopeNotificationRequest envelope_notification_request: 13645 :return: Notification 13646 If the method is called asynchronously, 13647 returns the request thread. 13648 """ 13649 13650 all_params = ['account_id', 'envelope_id', 'envelope_notification_request'] 13651 all_params.append('callback') 13652 all_params.append('_return_http_data_only') 13653 all_params.append('_preload_content') 13654 all_params.append('_request_timeout') 13655 13656 params = locals() 13657 for key, val in iteritems(params['kwargs']): 13658 if key not in all_params: 13659 raise TypeError( 13660 "Got an unexpected keyword argument '%s'" 13661 " to method update_notification_settings" % key 13662 ) 13663 params[key] = val 13664 del params['kwargs'] 13665 # verify the required parameter 'account_id' is set 13666 if ('account_id' not in params) or (params['account_id'] is None): 13667 raise ValueError("Missing the required parameter `account_id` when calling `update_notification_settings`") 13668 # verify the required parameter 'envelope_id' is set 13669 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13670 raise ValueError("Missing the required parameter `envelope_id` when calling `update_notification_settings`") 13671 13672 13673 collection_formats = {} 13674 13675 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/notification'.replace('{format}', 'json') 13676 path_params = {} 13677 if 'account_id' in params: 13678 path_params['accountId'] = params['account_id'] 13679 if 'envelope_id' in params: 13680 path_params['envelopeId'] = params['envelope_id'] 13681 13682 query_params = {} 13683 13684 header_params = {} 13685 13686 form_params = [] 13687 local_var_files = {} 13688 13689 body_params = None 13690 if 'envelope_notification_request' in params: 13691 body_params = params['envelope_notification_request'] 13692 # HTTP header `Accept` 13693 header_params['Accept'] = self.api_client.\ 13694 select_header_accept(['application/json']) 13695 13696 # Authentication setting 13697 auth_settings = [] 13698 13699 return self.api_client.call_api(resource_path, 'PUT', 13700 path_params, 13701 query_params, 13702 header_params, 13703 body=body_params, 13704 post_params=form_params, 13705 files=local_var_files, 13706 response_type='Notification', 13707 auth_settings=auth_settings, 13708 callback=params.get('callback'), 13709 _return_http_data_only=params.get('_return_http_data_only'), 13710 _preload_content=params.get('_preload_content', True), 13711 _request_timeout=params.get('_request_timeout'), 13712 collection_formats=collection_formats) 13713 13714 def update_recipient_document_visibility(self, account_id, envelope_id, recipient_id, **kwargs): 13715 """ 13716 Updates document visibility for the recipients 13717 This method updates document visibility for a recipient. **Note:** A document cannot be hidden from a recipient if the recipient has tabs assigned to them on the document. Carbon Copy, Certified Delivery (Needs to Sign), Editor, and Agent recipients can always see all documents. 13718 This method makes a synchronous HTTP request by default. To make an 13719 asynchronous HTTP request, please define a `callback` function 13720 to be invoked when receiving the response. 13721 >>> def callback_function(response): 13722 >>> pprint(response) 13723 >>> 13724 >>> thread = api.update_recipient_document_visibility(account_id, envelope_id, recipient_id, callback=callback_function) 13725 13726 :param callback function: The callback function 13727 for asynchronous request. (optional) 13728 :param str account_id: The external account number (int) or account ID Guid. (required) 13729 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13730 :param str recipient_id: The ID of the recipient being accessed. (required) 13731 :param DocumentVisibilityList document_visibility_list: 13732 :return: DocumentVisibilityList 13733 If the method is called asynchronously, 13734 returns the request thread. 13735 """ 13736 kwargs['_return_http_data_only'] = True 13737 if kwargs.get('callback'): 13738 return self.update_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13739 else: 13740 (data) = self.update_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13741 return data 13742 13743 def update_recipient_document_visibility_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 13744 """ 13745 Updates document visibility for the recipients 13746 This method updates document visibility for a recipient. **Note:** A document cannot be hidden from a recipient if the recipient has tabs assigned to them on the document. Carbon Copy, Certified Delivery (Needs to Sign), Editor, and Agent recipients can always see all documents. 13747 This method makes a synchronous HTTP request by default. To make an 13748 asynchronous HTTP request, please define a `callback` function 13749 to be invoked when receiving the response. 13750 >>> def callback_function(response): 13751 >>> pprint(response) 13752 >>> 13753 >>> thread = api.update_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 13754 13755 :param callback function: The callback function 13756 for asynchronous request. (optional) 13757 :param str account_id: The external account number (int) or account ID Guid. (required) 13758 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13759 :param str recipient_id: The ID of the recipient being accessed. (required) 13760 :param DocumentVisibilityList document_visibility_list: 13761 :return: DocumentVisibilityList 13762 If the method is called asynchronously, 13763 returns the request thread. 13764 """ 13765 13766 all_params = ['account_id', 'envelope_id', 'recipient_id', 'document_visibility_list'] 13767 all_params.append('callback') 13768 all_params.append('_return_http_data_only') 13769 all_params.append('_preload_content') 13770 all_params.append('_request_timeout') 13771 13772 params = locals() 13773 for key, val in iteritems(params['kwargs']): 13774 if key not in all_params: 13775 raise TypeError( 13776 "Got an unexpected keyword argument '%s'" 13777 " to method update_recipient_document_visibility" % key 13778 ) 13779 params[key] = val 13780 del params['kwargs'] 13781 # verify the required parameter 'account_id' is set 13782 if ('account_id' not in params) or (params['account_id'] is None): 13783 raise ValueError("Missing the required parameter `account_id` when calling `update_recipient_document_visibility`") 13784 # verify the required parameter 'envelope_id' is set 13785 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13786 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipient_document_visibility`") 13787 # verify the required parameter 'recipient_id' is set 13788 if ('recipient_id' not in params) or (params['recipient_id'] is None): 13789 raise ValueError("Missing the required parameter `recipient_id` when calling `update_recipient_document_visibility`") 13790 13791 13792 collection_formats = {} 13793 13794 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/document_visibility'.replace('{format}', 'json') 13795 path_params = {} 13796 if 'account_id' in params: 13797 path_params['accountId'] = params['account_id'] 13798 if 'envelope_id' in params: 13799 path_params['envelopeId'] = params['envelope_id'] 13800 if 'recipient_id' in params: 13801 path_params['recipientId'] = params['recipient_id'] 13802 13803 query_params = {} 13804 13805 header_params = {} 13806 13807 form_params = [] 13808 local_var_files = {} 13809 13810 body_params = None 13811 if 'document_visibility_list' in params: 13812 body_params = params['document_visibility_list'] 13813 # HTTP header `Accept` 13814 header_params['Accept'] = self.api_client.\ 13815 select_header_accept(['application/json']) 13816 13817 # Authentication setting 13818 auth_settings = [] 13819 13820 return self.api_client.call_api(resource_path, 'PUT', 13821 path_params, 13822 query_params, 13823 header_params, 13824 body=body_params, 13825 post_params=form_params, 13826 files=local_var_files, 13827 response_type='DocumentVisibilityList', 13828 auth_settings=auth_settings, 13829 callback=params.get('callback'), 13830 _return_http_data_only=params.get('_return_http_data_only'), 13831 _preload_content=params.get('_preload_content', True), 13832 _request_timeout=params.get('_request_timeout'), 13833 collection_formats=collection_formats) 13834 13835 def update_recipient_initials_image(self, account_id, envelope_id, recipient_id, **kwargs): 13836 """ 13837 Sets the initials image for an accountless signer. 13838 Updates the initials image for a signer that does not have a DocuSign account. The supported image formats for this file are: gif, png, jpeg, and bmp. The file size must be less than 200K. For the Authentication/Authorization for this call, the credentials must match the sender of the envelope, the recipient must be an accountless signer or in person signer. The account must have the `CanSendEnvelope` property set to **true** and the `ExpressSendOnly` property in `SendingUser` structure must be set to **false**. 13839 This method makes a synchronous HTTP request by default. To make an 13840 asynchronous HTTP request, please define a `callback` function 13841 to be invoked when receiving the response. 13842 >>> def callback_function(response): 13843 >>> pprint(response) 13844 >>> 13845 >>> thread = api.update_recipient_initials_image(account_id, envelope_id, recipient_id, callback=callback_function) 13846 13847 :param callback function: The callback function 13848 for asynchronous request. (optional) 13849 :param str account_id: The external account number (int) or account ID Guid. (required) 13850 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13851 :param str recipient_id: The ID of the recipient being accessed. (required) 13852 :return: None 13853 If the method is called asynchronously, 13854 returns the request thread. 13855 """ 13856 kwargs['_return_http_data_only'] = True 13857 if kwargs.get('callback'): 13858 return self.update_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13859 else: 13860 (data) = self.update_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13861 return data 13862 13863 def update_recipient_initials_image_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 13864 """ 13865 Sets the initials image for an accountless signer. 13866 Updates the initials image for a signer that does not have a DocuSign account. The supported image formats for this file are: gif, png, jpeg, and bmp. The file size must be less than 200K. For the Authentication/Authorization for this call, the credentials must match the sender of the envelope, the recipient must be an accountless signer or in person signer. The account must have the `CanSendEnvelope` property set to **true** and the `ExpressSendOnly` property in `SendingUser` structure must be set to **false**. 13867 This method makes a synchronous HTTP request by default. To make an 13868 asynchronous HTTP request, please define a `callback` function 13869 to be invoked when receiving the response. 13870 >>> def callback_function(response): 13871 >>> pprint(response) 13872 >>> 13873 >>> thread = api.update_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 13874 13875 :param callback function: The callback function 13876 for asynchronous request. (optional) 13877 :param str account_id: The external account number (int) or account ID Guid. (required) 13878 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13879 :param str recipient_id: The ID of the recipient being accessed. (required) 13880 :return: None 13881 If the method is called asynchronously, 13882 returns the request thread. 13883 """ 13884 13885 all_params = ['account_id', 'envelope_id', 'recipient_id'] 13886 all_params.append('callback') 13887 all_params.append('_return_http_data_only') 13888 all_params.append('_preload_content') 13889 all_params.append('_request_timeout') 13890 13891 params = locals() 13892 for key, val in iteritems(params['kwargs']): 13893 if key not in all_params: 13894 raise TypeError( 13895 "Got an unexpected keyword argument '%s'" 13896 " to method update_recipient_initials_image" % key 13897 ) 13898 params[key] = val 13899 del params['kwargs'] 13900 # verify the required parameter 'account_id' is set 13901 if ('account_id' not in params) or (params['account_id'] is None): 13902 raise ValueError("Missing the required parameter `account_id` when calling `update_recipient_initials_image`") 13903 # verify the required parameter 'envelope_id' is set 13904 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13905 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipient_initials_image`") 13906 # verify the required parameter 'recipient_id' is set 13907 if ('recipient_id' not in params) or (params['recipient_id'] is None): 13908 raise ValueError("Missing the required parameter `recipient_id` when calling `update_recipient_initials_image`") 13909 13910 13911 collection_formats = {} 13912 13913 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/initials_image'.replace('{format}', 'json') 13914 path_params = {} 13915 if 'account_id' in params: 13916 path_params['accountId'] = params['account_id'] 13917 if 'envelope_id' in params: 13918 path_params['envelopeId'] = params['envelope_id'] 13919 if 'recipient_id' in params: 13920 path_params['recipientId'] = params['recipient_id'] 13921 13922 query_params = {} 13923 13924 header_params = {} 13925 13926 form_params = [] 13927 local_var_files = {} 13928 13929 body_params = None 13930 # HTTP header `Accept` 13931 header_params['Accept'] = self.api_client.\ 13932 select_header_accept(['application/json']) 13933 13934 # HTTP header `Content-Type` 13935 header_params['Content-Type'] = self.api_client.\ 13936 select_header_content_type(['image/gif']) 13937 13938 # Authentication setting 13939 auth_settings = [] 13940 13941 return self.api_client.call_api(resource_path, 'PUT', 13942 path_params, 13943 query_params, 13944 header_params, 13945 body=body_params, 13946 post_params=form_params, 13947 files=local_var_files, 13948 response_type=None, 13949 auth_settings=auth_settings, 13950 callback=params.get('callback'), 13951 _return_http_data_only=params.get('_return_http_data_only'), 13952 _preload_content=params.get('_preload_content', True), 13953 _request_timeout=params.get('_request_timeout'), 13954 collection_formats=collection_formats) 13955 13956 def update_recipient_signature_image(self, account_id, envelope_id, recipient_id, **kwargs): 13957 """ 13958 Sets the signature image for an accountless signer. 13959 Updates the signature image for an accountless signer. The supported image formats for this file are: gif, png, jpeg, and bmp. The file size must be less than 200K. For the Authentication/Authorization for this call, the credentials must match the sender of the envelope, the recipient must be an accountless signer or in person signer. The account must have the `CanSendEnvelope` property set to **true** and the `ExpressSendOnly` property in `SendingUser` structure must be set to **false**. 13960 This method makes a synchronous HTTP request by default. To make an 13961 asynchronous HTTP request, please define a `callback` function 13962 to be invoked when receiving the response. 13963 >>> def callback_function(response): 13964 >>> pprint(response) 13965 >>> 13966 >>> thread = api.update_recipient_signature_image(account_id, envelope_id, recipient_id, callback=callback_function) 13967 13968 :param callback function: The callback function 13969 for asynchronous request. (optional) 13970 :param str account_id: The external account number (int) or account ID Guid. (required) 13971 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13972 :param str recipient_id: The ID of the recipient being accessed. (required) 13973 :return: None 13974 If the method is called asynchronously, 13975 returns the request thread. 13976 """ 13977 kwargs['_return_http_data_only'] = True 13978 if kwargs.get('callback'): 13979 return self.update_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13980 else: 13981 (data) = self.update_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13982 return data 13983 13984 def update_recipient_signature_image_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 13985 """ 13986 Sets the signature image for an accountless signer. 13987 Updates the signature image for an accountless signer. The supported image formats for this file are: gif, png, jpeg, and bmp. The file size must be less than 200K. For the Authentication/Authorization for this call, the credentials must match the sender of the envelope, the recipient must be an accountless signer or in person signer. The account must have the `CanSendEnvelope` property set to **true** and the `ExpressSendOnly` property in `SendingUser` structure must be set to **false**. 13988 This method makes a synchronous HTTP request by default. To make an 13989 asynchronous HTTP request, please define a `callback` function 13990 to be invoked when receiving the response. 13991 >>> def callback_function(response): 13992 >>> pprint(response) 13993 >>> 13994 >>> thread = api.update_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 13995 13996 :param callback function: The callback function 13997 for asynchronous request. (optional) 13998 :param str account_id: The external account number (int) or account ID Guid. (required) 13999 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14000 :param str recipient_id: The ID of the recipient being accessed. (required) 14001 :return: None 14002 If the method is called asynchronously, 14003 returns the request thread. 14004 """ 14005 14006 all_params = ['account_id', 'envelope_id', 'recipient_id'] 14007 all_params.append('callback') 14008 all_params.append('_return_http_data_only') 14009 all_params.append('_preload_content') 14010 all_params.append('_request_timeout') 14011 14012 params = locals() 14013 for key, val in iteritems(params['kwargs']): 14014 if key not in all_params: 14015 raise TypeError( 14016 "Got an unexpected keyword argument '%s'" 14017 " to method update_recipient_signature_image" % key 14018 ) 14019 params[key] = val 14020 del params['kwargs'] 14021 # verify the required parameter 'account_id' is set 14022 if ('account_id' not in params) or (params['account_id'] is None): 14023 raise ValueError("Missing the required parameter `account_id` when calling `update_recipient_signature_image`") 14024 # verify the required parameter 'envelope_id' is set 14025 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14026 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipient_signature_image`") 14027 # verify the required parameter 'recipient_id' is set 14028 if ('recipient_id' not in params) or (params['recipient_id'] is None): 14029 raise ValueError("Missing the required parameter `recipient_id` when calling `update_recipient_signature_image`") 14030 14031 14032 collection_formats = {} 14033 14034 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/signature_image'.replace('{format}', 'json') 14035 path_params = {} 14036 if 'account_id' in params: 14037 path_params['accountId'] = params['account_id'] 14038 if 'envelope_id' in params: 14039 path_params['envelopeId'] = params['envelope_id'] 14040 if 'recipient_id' in params: 14041 path_params['recipientId'] = params['recipient_id'] 14042 14043 query_params = {} 14044 14045 header_params = {} 14046 14047 form_params = [] 14048 local_var_files = {} 14049 14050 body_params = None 14051 # HTTP header `Accept` 14052 header_params['Accept'] = self.api_client.\ 14053 select_header_accept(['application/json']) 14054 14055 # HTTP header `Content-Type` 14056 header_params['Content-Type'] = self.api_client.\ 14057 select_header_content_type(['image/gif']) 14058 14059 # Authentication setting 14060 auth_settings = [] 14061 14062 return self.api_client.call_api(resource_path, 'PUT', 14063 path_params, 14064 query_params, 14065 header_params, 14066 body=body_params, 14067 post_params=form_params, 14068 files=local_var_files, 14069 response_type=None, 14070 auth_settings=auth_settings, 14071 callback=params.get('callback'), 14072 _return_http_data_only=params.get('_return_http_data_only'), 14073 _preload_content=params.get('_preload_content', True), 14074 _request_timeout=params.get('_request_timeout'), 14075 collection_formats=collection_formats) 14076 14077 def update_recipients(self, account_id, envelope_id, **kwargs): 14078 """ 14079 Updates recipients in a draft envelope or corrects recipient information for an in process envelope. 14080 Updates recipients in a draft envelope or corrects recipient information for an in process envelope. For draft envelopes, you can edit the following properties: `email`, `userName`, `routingOrder`, `faxNumber`, `deliveryMethod`, `accessCode`, and `requireIdLookup`. Once an envelope has been sent, you can only edit: `email`, `userName`, `signerName`, `routingOrder`, `faxNumber`, and `deliveryMethod`. You can also select to resend an envelope by using the `resend_envelope` option. If you send information for a recipient that does not already exist in a draft envelope, the recipient is added to the envelope (similar to the POST). 14081 This method makes a synchronous HTTP request by default. To make an 14082 asynchronous HTTP request, please define a `callback` function 14083 to be invoked when receiving the response. 14084 >>> def callback_function(response): 14085 >>> pprint(response) 14086 >>> 14087 >>> thread = api.update_recipients(account_id, envelope_id, callback=callback_function) 14088 14089 :param callback function: The callback function 14090 for asynchronous request. (optional) 14091 :param str account_id: The external account number (int) or account ID Guid. (required) 14092 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14093 :param str combine_same_order_recipients: 14094 :param str offline_signing: 14095 :param str resend_envelope: When set to **true**, resends the envelope if the new recipient's routing order is before or the same as the envelope's next recipient. 14096 :param Recipients recipients: 14097 :return: RecipientsUpdateSummary 14098 If the method is called asynchronously, 14099 returns the request thread. 14100 """ 14101 kwargs['_return_http_data_only'] = True 14102 if kwargs.get('callback'): 14103 return self.update_recipients_with_http_info(account_id, envelope_id, **kwargs) 14104 else: 14105 (data) = self.update_recipients_with_http_info(account_id, envelope_id, **kwargs) 14106 return data 14107 14108 def update_recipients_with_http_info(self, account_id, envelope_id, **kwargs): 14109 """ 14110 Updates recipients in a draft envelope or corrects recipient information for an in process envelope. 14111 Updates recipients in a draft envelope or corrects recipient information for an in process envelope. For draft envelopes, you can edit the following properties: `email`, `userName`, `routingOrder`, `faxNumber`, `deliveryMethod`, `accessCode`, and `requireIdLookup`. Once an envelope has been sent, you can only edit: `email`, `userName`, `signerName`, `routingOrder`, `faxNumber`, and `deliveryMethod`. You can also select to resend an envelope by using the `resend_envelope` option. If you send information for a recipient that does not already exist in a draft envelope, the recipient is added to the envelope (similar to the POST). 14112 This method makes a synchronous HTTP request by default. To make an 14113 asynchronous HTTP request, please define a `callback` function 14114 to be invoked when receiving the response. 14115 >>> def callback_function(response): 14116 >>> pprint(response) 14117 >>> 14118 >>> thread = api.update_recipients_with_http_info(account_id, envelope_id, callback=callback_function) 14119 14120 :param callback function: The callback function 14121 for asynchronous request. (optional) 14122 :param str account_id: The external account number (int) or account ID Guid. (required) 14123 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14124 :param str combine_same_order_recipients: 14125 :param str offline_signing: 14126 :param str resend_envelope: When set to **true**, resends the envelope if the new recipient's routing order is before or the same as the envelope's next recipient. 14127 :param Recipients recipients: 14128 :return: RecipientsUpdateSummary 14129 If the method is called asynchronously, 14130 returns the request thread. 14131 """ 14132 14133 all_params = ['account_id', 'envelope_id', 'combine_same_order_recipients', 'offline_signing', 'resend_envelope', 'recipients'] 14134 all_params.append('callback') 14135 all_params.append('_return_http_data_only') 14136 all_params.append('_preload_content') 14137 all_params.append('_request_timeout') 14138 14139 params = locals() 14140 for key, val in iteritems(params['kwargs']): 14141 if key not in all_params: 14142 raise TypeError( 14143 "Got an unexpected keyword argument '%s'" 14144 " to method update_recipients" % key 14145 ) 14146 params[key] = val 14147 del params['kwargs'] 14148 # verify the required parameter 'account_id' is set 14149 if ('account_id' not in params) or (params['account_id'] is None): 14150 raise ValueError("Missing the required parameter `account_id` when calling `update_recipients`") 14151 # verify the required parameter 'envelope_id' is set 14152 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14153 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipients`") 14154 14155 14156 collection_formats = {} 14157 14158 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients'.replace('{format}', 'json') 14159 path_params = {} 14160 if 'account_id' in params: 14161 path_params['accountId'] = params['account_id'] 14162 if 'envelope_id' in params: 14163 path_params['envelopeId'] = params['envelope_id'] 14164 14165 query_params = {} 14166 if 'combine_same_order_recipients' in params: 14167 query_params['combine_same_order_recipients'] = params['combine_same_order_recipients'] 14168 if 'offline_signing' in params: 14169 query_params['offline_signing'] = params['offline_signing'] 14170 if 'resend_envelope' in params: 14171 query_params['resend_envelope'] = params['resend_envelope'] 14172 14173 header_params = {} 14174 14175 form_params = [] 14176 local_var_files = {} 14177 14178 body_params = None 14179 if 'recipients' in params: 14180 body_params = params['recipients'] 14181 # HTTP header `Accept` 14182 header_params['Accept'] = self.api_client.\ 14183 select_header_accept(['application/json']) 14184 14185 # Authentication setting 14186 auth_settings = [] 14187 14188 return self.api_client.call_api(resource_path, 'PUT', 14189 path_params, 14190 query_params, 14191 header_params, 14192 body=body_params, 14193 post_params=form_params, 14194 files=local_var_files, 14195 response_type='RecipientsUpdateSummary', 14196 auth_settings=auth_settings, 14197 callback=params.get('callback'), 14198 _return_http_data_only=params.get('_return_http_data_only'), 14199 _preload_content=params.get('_preload_content', True), 14200 _request_timeout=params.get('_request_timeout'), 14201 collection_formats=collection_formats) 14202 14203 def update_recipients_document_visibility(self, account_id, envelope_id, **kwargs): 14204 """ 14205 Updates document visibility for the recipients 14206 This method updates document visibility for one or more recipients based on the `recipientId` and `visible` values that you include in the request body. **Note:** A document cannot be hidden from a recipient if the recipient has tabs assigned to them on the document. Carbon Copy, Certified Delivery (Needs to Sign), Editor, and Agent recipients can always see all documents. 14207 This method makes a synchronous HTTP request by default. To make an 14208 asynchronous HTTP request, please define a `callback` function 14209 to be invoked when receiving the response. 14210 >>> def callback_function(response): 14211 >>> pprint(response) 14212 >>> 14213 >>> thread = api.update_recipients_document_visibility(account_id, envelope_id, callback=callback_function) 14214 14215 :param callback function: The callback function 14216 for asynchronous request. (optional) 14217 :param str account_id: The external account number (int) or account ID Guid. (required) 14218 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14219 :param DocumentVisibilityList document_visibility_list: 14220 :return: DocumentVisibilityList 14221 If the method is called asynchronously, 14222 returns the request thread. 14223 """ 14224 kwargs['_return_http_data_only'] = True 14225 if kwargs.get('callback'): 14226 return self.update_recipients_document_visibility_with_http_info(account_id, envelope_id, **kwargs) 14227 else: 14228 (data) = self.update_recipients_document_visibility_with_http_info(account_id, envelope_id, **kwargs) 14229 return data 14230 14231 def update_recipients_document_visibility_with_http_info(self, account_id, envelope_id, **kwargs): 14232 """ 14233 Updates document visibility for the recipients 14234 This method updates document visibility for one or more recipients based on the `recipientId` and `visible` values that you include in the request body. **Note:** A document cannot be hidden from a recipient if the recipient has tabs assigned to them on the document. Carbon Copy, Certified Delivery (Needs to Sign), Editor, and Agent recipients can always see all documents. 14235 This method makes a synchronous HTTP request by default. To make an 14236 asynchronous HTTP request, please define a `callback` function 14237 to be invoked when receiving the response. 14238 >>> def callback_function(response): 14239 >>> pprint(response) 14240 >>> 14241 >>> thread = api.update_recipients_document_visibility_with_http_info(account_id, envelope_id, callback=callback_function) 14242 14243 :param callback function: The callback function 14244 for asynchronous request. (optional) 14245 :param str account_id: The external account number (int) or account ID Guid. (required) 14246 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14247 :param DocumentVisibilityList document_visibility_list: 14248 :return: DocumentVisibilityList 14249 If the method is called asynchronously, 14250 returns the request thread. 14251 """ 14252 14253 all_params = ['account_id', 'envelope_id', 'document_visibility_list'] 14254 all_params.append('callback') 14255 all_params.append('_return_http_data_only') 14256 all_params.append('_preload_content') 14257 all_params.append('_request_timeout') 14258 14259 params = locals() 14260 for key, val in iteritems(params['kwargs']): 14261 if key not in all_params: 14262 raise TypeError( 14263 "Got an unexpected keyword argument '%s'" 14264 " to method update_recipients_document_visibility" % key 14265 ) 14266 params[key] = val 14267 del params['kwargs'] 14268 # verify the required parameter 'account_id' is set 14269 if ('account_id' not in params) or (params['account_id'] is None): 14270 raise ValueError("Missing the required parameter `account_id` when calling `update_recipients_document_visibility`") 14271 # verify the required parameter 'envelope_id' is set 14272 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14273 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipients_document_visibility`") 14274 14275 14276 collection_formats = {} 14277 14278 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/document_visibility'.replace('{format}', 'json') 14279 path_params = {} 14280 if 'account_id' in params: 14281 path_params['accountId'] = params['account_id'] 14282 if 'envelope_id' in params: 14283 path_params['envelopeId'] = params['envelope_id'] 14284 14285 query_params = {} 14286 14287 header_params = {} 14288 14289 form_params = [] 14290 local_var_files = {} 14291 14292 body_params = None 14293 if 'document_visibility_list' in params: 14294 body_params = params['document_visibility_list'] 14295 # HTTP header `Accept` 14296 header_params['Accept'] = self.api_client.\ 14297 select_header_accept(['application/json']) 14298 14299 # Authentication setting 14300 auth_settings = [] 14301 14302 return self.api_client.call_api(resource_path, 'PUT', 14303 path_params, 14304 query_params, 14305 header_params, 14306 body=body_params, 14307 post_params=form_params, 14308 files=local_var_files, 14309 response_type='DocumentVisibilityList', 14310 auth_settings=auth_settings, 14311 callback=params.get('callback'), 14312 _return_http_data_only=params.get('_return_http_data_only'), 14313 _preload_content=params.get('_preload_content', True), 14314 _request_timeout=params.get('_request_timeout'), 14315 collection_formats=collection_formats) 14316 14317 def update_tabs(self, account_id, envelope_id, recipient_id, **kwargs): 14318 """ 14319 Updates the tabs for a recipient. 14320 Updates one or more tabs for a recipient in a draft envelope. 14321 This method makes a synchronous HTTP request by default. To make an 14322 asynchronous HTTP request, please define a `callback` function 14323 to be invoked when receiving the response. 14324 >>> def callback_function(response): 14325 >>> pprint(response) 14326 >>> 14327 >>> thread = api.update_tabs(account_id, envelope_id, recipient_id, callback=callback_function) 14328 14329 :param callback function: The callback function 14330 for asynchronous request. (optional) 14331 :param str account_id: The external account number (int) or account ID Guid. (required) 14332 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14333 :param str recipient_id: The ID of the recipient being accessed. (required) 14334 :param Tabs tabs: 14335 :return: Tabs 14336 If the method is called asynchronously, 14337 returns the request thread. 14338 """ 14339 kwargs['_return_http_data_only'] = True 14340 if kwargs.get('callback'): 14341 return self.update_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 14342 else: 14343 (data) = self.update_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 14344 return data 14345 14346 def update_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 14347 """ 14348 Updates the tabs for a recipient. 14349 Updates one or more tabs for a recipient in a draft envelope. 14350 This method makes a synchronous HTTP request by default. To make an 14351 asynchronous HTTP request, please define a `callback` function 14352 to be invoked when receiving the response. 14353 >>> def callback_function(response): 14354 >>> pprint(response) 14355 >>> 14356 >>> thread = api.update_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 14357 14358 :param callback function: The callback function 14359 for asynchronous request. (optional) 14360 :param str account_id: The external account number (int) or account ID Guid. (required) 14361 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14362 :param str recipient_id: The ID of the recipient being accessed. (required) 14363 :param Tabs tabs: 14364 :return: Tabs 14365 If the method is called asynchronously, 14366 returns the request thread. 14367 """ 14368 14369 all_params = ['account_id', 'envelope_id', 'recipient_id', 'tabs'] 14370 all_params.append('callback') 14371 all_params.append('_return_http_data_only') 14372 all_params.append('_preload_content') 14373 all_params.append('_request_timeout') 14374 14375 params = locals() 14376 for key, val in iteritems(params['kwargs']): 14377 if key not in all_params: 14378 raise TypeError( 14379 "Got an unexpected keyword argument '%s'" 14380 " to method update_tabs" % key 14381 ) 14382 params[key] = val 14383 del params['kwargs'] 14384 # verify the required parameter 'account_id' is set 14385 if ('account_id' not in params) or (params['account_id'] is None): 14386 raise ValueError("Missing the required parameter `account_id` when calling `update_tabs`") 14387 # verify the required parameter 'envelope_id' is set 14388 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14389 raise ValueError("Missing the required parameter `envelope_id` when calling `update_tabs`") 14390 # verify the required parameter 'recipient_id' is set 14391 if ('recipient_id' not in params) or (params['recipient_id'] is None): 14392 raise ValueError("Missing the required parameter `recipient_id` when calling `update_tabs`") 14393 14394 14395 collection_formats = {} 14396 14397 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/tabs'.replace('{format}', 'json') 14398 path_params = {} 14399 if 'account_id' in params: 14400 path_params['accountId'] = params['account_id'] 14401 if 'envelope_id' in params: 14402 path_params['envelopeId'] = params['envelope_id'] 14403 if 'recipient_id' in params: 14404 path_params['recipientId'] = params['recipient_id'] 14405 14406 query_params = {} 14407 14408 header_params = {} 14409 14410 form_params = [] 14411 local_var_files = {} 14412 14413 body_params = None 14414 if 'tabs' in params: 14415 body_params = params['tabs'] 14416 # HTTP header `Accept` 14417 header_params['Accept'] = self.api_client.\ 14418 select_header_accept(['application/json']) 14419 14420 # Authentication setting 14421 auth_settings = [] 14422 14423 return self.api_client.call_api(resource_path, 'PUT', 14424 path_params, 14425 query_params, 14426 header_params, 14427 body=body_params, 14428 post_params=form_params, 14429 files=local_var_files, 14430 response_type='Tabs', 14431 auth_settings=auth_settings, 14432 callback=params.get('callback'), 14433 _return_http_data_only=params.get('_return_http_data_only'), 14434 _preload_content=params.get('_preload_content', True), 14435 _request_timeout=params.get('_request_timeout'), 14436 collection_formats=collection_formats) 14437 14438 def update_tabs_blob(self, account_id, envelope_id, **kwargs): 14439 """ 14440 Update encrypted tabs for envelope. 14441 14442 This method makes a synchronous HTTP request by default. To make an 14443 asynchronous HTTP request, please define a `callback` function 14444 to be invoked when receiving the response. 14445 >>> def callback_function(response): 14446 >>> pprint(response) 14447 >>> 14448 >>> thread = api.update_tabs_blob(account_id, envelope_id, callback=callback_function) 14449 14450 :param callback function: The callback function 14451 for asynchronous request. (optional) 14452 :param str account_id: The external account number (int) or account ID Guid. (required) 14453 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14454 :return: None 14455 If the method is called asynchronously, 14456 returns the request thread. 14457 """ 14458 kwargs['_return_http_data_only'] = True 14459 if kwargs.get('callback'): 14460 return self.update_tabs_blob_with_http_info(account_id, envelope_id, **kwargs) 14461 else: 14462 (data) = self.update_tabs_blob_with_http_info(account_id, envelope_id, **kwargs) 14463 return data 14464 14465 def update_tabs_blob_with_http_info(self, account_id, envelope_id, **kwargs): 14466 """ 14467 Update encrypted tabs for envelope. 14468 14469 This method makes a synchronous HTTP request by default. To make an 14470 asynchronous HTTP request, please define a `callback` function 14471 to be invoked when receiving the response. 14472 >>> def callback_function(response): 14473 >>> pprint(response) 14474 >>> 14475 >>> thread = api.update_tabs_blob_with_http_info(account_id, envelope_id, callback=callback_function) 14476 14477 :param callback function: The callback function 14478 for asynchronous request. (optional) 14479 :param str account_id: The external account number (int) or account ID Guid. (required) 14480 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14481 :return: None 14482 If the method is called asynchronously, 14483 returns the request thread. 14484 """ 14485 14486 all_params = ['account_id', 'envelope_id'] 14487 all_params.append('callback') 14488 all_params.append('_return_http_data_only') 14489 all_params.append('_preload_content') 14490 all_params.append('_request_timeout') 14491 14492 params = locals() 14493 for key, val in iteritems(params['kwargs']): 14494 if key not in all_params: 14495 raise TypeError( 14496 "Got an unexpected keyword argument '%s'" 14497 " to method update_tabs_blob" % key 14498 ) 14499 params[key] = val 14500 del params['kwargs'] 14501 # verify the required parameter 'account_id' is set 14502 if ('account_id' not in params) or (params['account_id'] is None): 14503 raise ValueError("Missing the required parameter `account_id` when calling `update_tabs_blob`") 14504 # verify the required parameter 'envelope_id' is set 14505 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14506 raise ValueError("Missing the required parameter `envelope_id` when calling `update_tabs_blob`") 14507 14508 14509 collection_formats = {} 14510 14511 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/tabs_blob'.replace('{format}', 'json') 14512 path_params = {} 14513 if 'account_id' in params: 14514 path_params['accountId'] = params['account_id'] 14515 if 'envelope_id' in params: 14516 path_params['envelopeId'] = params['envelope_id'] 14517 14518 query_params = {} 14519 14520 header_params = {} 14521 14522 form_params = [] 14523 local_var_files = {} 14524 14525 body_params = None 14526 # HTTP header `Accept` 14527 header_params['Accept'] = self.api_client.\ 14528 select_header_accept(['application/json']) 14529 14530 # Authentication setting 14531 auth_settings = [] 14532 14533 return self.api_client.call_api(resource_path, 'PUT', 14534 path_params, 14535 query_params, 14536 header_params, 14537 body=body_params, 14538 post_params=form_params, 14539 files=local_var_files, 14540 response_type=None, 14541 auth_settings=auth_settings, 14542 callback=params.get('callback'), 14543 _return_http_data_only=params.get('_return_http_data_only'), 14544 _preload_content=params.get('_preload_content', True), 14545 _request_timeout=params.get('_request_timeout'), 14546 collection_formats=collection_formats) 14547 14548 def update_template_delayed_routing_definition(self, account_id, template_id, workflow_step_id, **kwargs): 14549 """ 14550 Updates the delayed routing rules for a template's workflow step definition. 14551 This method makes a synchronous HTTP request by default. To make an 14552 asynchronous HTTP request, please define a `callback` function 14553 to be invoked when receiving the response. 14554 >>> def callback_function(response): 14555 >>> pprint(response) 14556 >>> 14557 >>> thread = api.update_template_delayed_routing_definition(account_id, template_id, workflow_step_id, callback=callback_function) 14558 14559 :param callback function: The callback function 14560 for asynchronous request. (optional) 14561 :param str account_id: The external account number (int) or account ID Guid. (required) 14562 :param str template_id: The ID of the template being accessed. (required) 14563 :param str workflow_step_id: (required) 14564 :param DelayedRouting delayed_routing: 14565 :return: DelayedRouting 14566 If the method is called asynchronously, 14567 returns the request thread. 14568 """ 14569 kwargs['_return_http_data_only'] = True 14570 if kwargs.get('callback'): 14571 return self.update_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 14572 else: 14573 (data) = self.update_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 14574 return data 14575 14576 def update_template_delayed_routing_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 14577 """ 14578 Updates the delayed routing rules for a template's workflow step definition. 14579 This method makes a synchronous HTTP request by default. To make an 14580 asynchronous HTTP request, please define a `callback` function 14581 to be invoked when receiving the response. 14582 >>> def callback_function(response): 14583 >>> pprint(response) 14584 >>> 14585 >>> thread = api.update_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 14586 14587 :param callback function: The callback function 14588 for asynchronous request. (optional) 14589 :param str account_id: The external account number (int) or account ID Guid. (required) 14590 :param str template_id: The ID of the template being accessed. (required) 14591 :param str workflow_step_id: (required) 14592 :param DelayedRouting delayed_routing: 14593 :return: DelayedRouting 14594 If the method is called asynchronously, 14595 returns the request thread. 14596 """ 14597 14598 all_params = ['account_id', 'template_id', 'workflow_step_id', 'delayed_routing'] 14599 all_params.append('callback') 14600 all_params.append('_return_http_data_only') 14601 all_params.append('_preload_content') 14602 all_params.append('_request_timeout') 14603 14604 params = locals() 14605 for key, val in iteritems(params['kwargs']): 14606 if key not in all_params: 14607 raise TypeError( 14608 "Got an unexpected keyword argument '%s'" 14609 " to method update_template_delayed_routing_definition" % key 14610 ) 14611 params[key] = val 14612 del params['kwargs'] 14613 # verify the required parameter 'account_id' is set 14614 if ('account_id' not in params) or (params['account_id'] is None): 14615 raise ValueError("Missing the required parameter `account_id` when calling `update_template_delayed_routing_definition`") 14616 # verify the required parameter 'template_id' is set 14617 if ('template_id' not in params) or (params['template_id'] is None): 14618 raise ValueError("Missing the required parameter `template_id` when calling `update_template_delayed_routing_definition`") 14619 # verify the required parameter 'workflow_step_id' is set 14620 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 14621 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_template_delayed_routing_definition`") 14622 14623 14624 collection_formats = {} 14625 14626 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 14627 path_params = {} 14628 if 'account_id' in params: 14629 path_params['accountId'] = params['account_id'] 14630 if 'template_id' in params: 14631 path_params['templateId'] = params['template_id'] 14632 if 'workflow_step_id' in params: 14633 path_params['workflowStepId'] = params['workflow_step_id'] 14634 14635 query_params = {} 14636 14637 header_params = {} 14638 14639 form_params = [] 14640 local_var_files = {} 14641 14642 body_params = None 14643 if 'delayed_routing' in params: 14644 body_params = params['delayed_routing'] 14645 # HTTP header `Accept` 14646 header_params['Accept'] = self.api_client.\ 14647 select_header_accept(['application/json']) 14648 14649 # Authentication setting 14650 auth_settings = [] 14651 14652 return self.api_client.call_api(resource_path, 'PUT', 14653 path_params, 14654 query_params, 14655 header_params, 14656 body=body_params, 14657 post_params=form_params, 14658 files=local_var_files, 14659 response_type='DelayedRouting', 14660 auth_settings=auth_settings, 14661 callback=params.get('callback'), 14662 _return_http_data_only=params.get('_return_http_data_only'), 14663 _preload_content=params.get('_preload_content', True), 14664 _request_timeout=params.get('_request_timeout'), 14665 collection_formats=collection_formats) 14666 14667 def update_template_recipient_document_visibility(self, account_id, recipient_id, template_id, **kwargs): 14668 """ 14669 Updates document visibility for the recipients 14670 This method updates the document visibility for a template recipient. **Note:** A document cannot be hidden from a recipient if the recipient has tabs assigned to them on the document. Carbon Copy, Certified Delivery (Needs to Sign), Editor, and Agent recipients can always see all documents. 14671 This method makes a synchronous HTTP request by default. To make an 14672 asynchronous HTTP request, please define a `callback` function 14673 to be invoked when receiving the response. 14674 >>> def callback_function(response): 14675 >>> pprint(response) 14676 >>> 14677 >>> thread = api.update_template_recipient_document_visibility(account_id, recipient_id, template_id, callback=callback_function) 14678 14679 :param callback function: The callback function 14680 for asynchronous request. (optional) 14681 :param str account_id: The external account number (int) or account ID Guid. (required) 14682 :param str recipient_id: The ID of the recipient being accessed. (required) 14683 :param str template_id: The ID of the template being accessed. (required) 14684 :param TemplateDocumentVisibilityList template_document_visibility_list: 14685 :return: TemplateDocumentVisibilityList 14686 If the method is called asynchronously, 14687 returns the request thread. 14688 """ 14689 kwargs['_return_http_data_only'] = True 14690 if kwargs.get('callback'): 14691 return self.update_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, **kwargs) 14692 else: 14693 (data) = self.update_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, **kwargs) 14694 return data 14695 14696 def update_template_recipient_document_visibility_with_http_info(self, account_id, recipient_id, template_id, **kwargs): 14697 """ 14698 Updates document visibility for the recipients 14699 This method updates the document visibility for a template recipient. **Note:** A document cannot be hidden from a recipient if the recipient has tabs assigned to them on the document. Carbon Copy, Certified Delivery (Needs to Sign), Editor, and Agent recipients can always see all documents. 14700 This method makes a synchronous HTTP request by default. To make an 14701 asynchronous HTTP request, please define a `callback` function 14702 to be invoked when receiving the response. 14703 >>> def callback_function(response): 14704 >>> pprint(response) 14705 >>> 14706 >>> thread = api.update_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, callback=callback_function) 14707 14708 :param callback function: The callback function 14709 for asynchronous request. (optional) 14710 :param str account_id: The external account number (int) or account ID Guid. (required) 14711 :param str recipient_id: The ID of the recipient being accessed. (required) 14712 :param str template_id: The ID of the template being accessed. (required) 14713 :param TemplateDocumentVisibilityList template_document_visibility_list: 14714 :return: TemplateDocumentVisibilityList 14715 If the method is called asynchronously, 14716 returns the request thread. 14717 """ 14718 14719 all_params = ['account_id', 'recipient_id', 'template_id', 'template_document_visibility_list'] 14720 all_params.append('callback') 14721 all_params.append('_return_http_data_only') 14722 all_params.append('_preload_content') 14723 all_params.append('_request_timeout') 14724 14725 params = locals() 14726 for key, val in iteritems(params['kwargs']): 14727 if key not in all_params: 14728 raise TypeError( 14729 "Got an unexpected keyword argument '%s'" 14730 " to method update_template_recipient_document_visibility" % key 14731 ) 14732 params[key] = val 14733 del params['kwargs'] 14734 # verify the required parameter 'account_id' is set 14735 if ('account_id' not in params) or (params['account_id'] is None): 14736 raise ValueError("Missing the required parameter `account_id` when calling `update_template_recipient_document_visibility`") 14737 # verify the required parameter 'recipient_id' is set 14738 if ('recipient_id' not in params) or (params['recipient_id'] is None): 14739 raise ValueError("Missing the required parameter `recipient_id` when calling `update_template_recipient_document_visibility`") 14740 # verify the required parameter 'template_id' is set 14741 if ('template_id' not in params) or (params['template_id'] is None): 14742 raise ValueError("Missing the required parameter `template_id` when calling `update_template_recipient_document_visibility`") 14743 14744 14745 collection_formats = {} 14746 14747 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/recipients/{recipientId}/document_visibility'.replace('{format}', 'json') 14748 path_params = {} 14749 if 'account_id' in params: 14750 path_params['accountId'] = params['account_id'] 14751 if 'recipient_id' in params: 14752 path_params['recipientId'] = params['recipient_id'] 14753 if 'template_id' in params: 14754 path_params['templateId'] = params['template_id'] 14755 14756 query_params = {} 14757 14758 header_params = {} 14759 14760 form_params = [] 14761 local_var_files = {} 14762 14763 body_params = None 14764 if 'template_document_visibility_list' in params: 14765 body_params = params['template_document_visibility_list'] 14766 # HTTP header `Accept` 14767 header_params['Accept'] = self.api_client.\ 14768 select_header_accept(['application/json']) 14769 14770 # Authentication setting 14771 auth_settings = [] 14772 14773 return self.api_client.call_api(resource_path, 'PUT', 14774 path_params, 14775 query_params, 14776 header_params, 14777 body=body_params, 14778 post_params=form_params, 14779 files=local_var_files, 14780 response_type='TemplateDocumentVisibilityList', 14781 auth_settings=auth_settings, 14782 callback=params.get('callback'), 14783 _return_http_data_only=params.get('_return_http_data_only'), 14784 _preload_content=params.get('_preload_content', True), 14785 _request_timeout=params.get('_request_timeout'), 14786 collection_formats=collection_formats) 14787 14788 def update_template_recipients_document_visibility(self, account_id, template_id, **kwargs): 14789 """ 14790 Updates document visibility for the recipients 14791 This method updates document visibility for one or more template recipients based on the `recipientId` and `visible` values that you include in the request body. **Note:** A document cannot be hidden from a recipient if the recipient has tabs assigned to them on the document. Carbon Copy, Certified Delivery (Needs to Sign), Editor, and Agent recipients can always see all documents. 14792 This method makes a synchronous HTTP request by default. To make an 14793 asynchronous HTTP request, please define a `callback` function 14794 to be invoked when receiving the response. 14795 >>> def callback_function(response): 14796 >>> pprint(response) 14797 >>> 14798 >>> thread = api.update_template_recipients_document_visibility(account_id, template_id, callback=callback_function) 14799 14800 :param callback function: The callback function 14801 for asynchronous request. (optional) 14802 :param str account_id: The external account number (int) or account ID Guid. (required) 14803 :param str template_id: The ID of the template being accessed. (required) 14804 :param TemplateDocumentVisibilityList template_document_visibility_list: 14805 :return: TemplateDocumentVisibilityList 14806 If the method is called asynchronously, 14807 returns the request thread. 14808 """ 14809 kwargs['_return_http_data_only'] = True 14810 if kwargs.get('callback'): 14811 return self.update_template_recipients_document_visibility_with_http_info(account_id, template_id, **kwargs) 14812 else: 14813 (data) = self.update_template_recipients_document_visibility_with_http_info(account_id, template_id, **kwargs) 14814 return data 14815 14816 def update_template_recipients_document_visibility_with_http_info(self, account_id, template_id, **kwargs): 14817 """ 14818 Updates document visibility for the recipients 14819 This method updates document visibility for one or more template recipients based on the `recipientId` and `visible` values that you include in the request body. **Note:** A document cannot be hidden from a recipient if the recipient has tabs assigned to them on the document. Carbon Copy, Certified Delivery (Needs to Sign), Editor, and Agent recipients can always see all documents. 14820 This method makes a synchronous HTTP request by default. To make an 14821 asynchronous HTTP request, please define a `callback` function 14822 to be invoked when receiving the response. 14823 >>> def callback_function(response): 14824 >>> pprint(response) 14825 >>> 14826 >>> thread = api.update_template_recipients_document_visibility_with_http_info(account_id, template_id, callback=callback_function) 14827 14828 :param callback function: The callback function 14829 for asynchronous request. (optional) 14830 :param str account_id: The external account number (int) or account ID Guid. (required) 14831 :param str template_id: The ID of the template being accessed. (required) 14832 :param TemplateDocumentVisibilityList template_document_visibility_list: 14833 :return: TemplateDocumentVisibilityList 14834 If the method is called asynchronously, 14835 returns the request thread. 14836 """ 14837 14838 all_params = ['account_id', 'template_id', 'template_document_visibility_list'] 14839 all_params.append('callback') 14840 all_params.append('_return_http_data_only') 14841 all_params.append('_preload_content') 14842 all_params.append('_request_timeout') 14843 14844 params = locals() 14845 for key, val in iteritems(params['kwargs']): 14846 if key not in all_params: 14847 raise TypeError( 14848 "Got an unexpected keyword argument '%s'" 14849 " to method update_template_recipients_document_visibility" % key 14850 ) 14851 params[key] = val 14852 del params['kwargs'] 14853 # verify the required parameter 'account_id' is set 14854 if ('account_id' not in params) or (params['account_id'] is None): 14855 raise ValueError("Missing the required parameter `account_id` when calling `update_template_recipients_document_visibility`") 14856 # verify the required parameter 'template_id' is set 14857 if ('template_id' not in params) or (params['template_id'] is None): 14858 raise ValueError("Missing the required parameter `template_id` when calling `update_template_recipients_document_visibility`") 14859 14860 14861 collection_formats = {} 14862 14863 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/recipients/document_visibility'.replace('{format}', 'json') 14864 path_params = {} 14865 if 'account_id' in params: 14866 path_params['accountId'] = params['account_id'] 14867 if 'template_id' in params: 14868 path_params['templateId'] = params['template_id'] 14869 14870 query_params = {} 14871 14872 header_params = {} 14873 14874 form_params = [] 14875 local_var_files = {} 14876 14877 body_params = None 14878 if 'template_document_visibility_list' in params: 14879 body_params = params['template_document_visibility_list'] 14880 # HTTP header `Accept` 14881 header_params['Accept'] = self.api_client.\ 14882 select_header_accept(['application/json']) 14883 14884 # Authentication setting 14885 auth_settings = [] 14886 14887 return self.api_client.call_api(resource_path, 'PUT', 14888 path_params, 14889 query_params, 14890 header_params, 14891 body=body_params, 14892 post_params=form_params, 14893 files=local_var_files, 14894 response_type='TemplateDocumentVisibilityList', 14895 auth_settings=auth_settings, 14896 callback=params.get('callback'), 14897 _return_http_data_only=params.get('_return_http_data_only'), 14898 _preload_content=params.get('_preload_content', True), 14899 _request_timeout=params.get('_request_timeout'), 14900 collection_formats=collection_formats) 14901 14902 def update_template_scheduled_sending_definition(self, account_id, template_id, **kwargs): 14903 """ 14904 Updates the scheduled sending rules for a template's workflow definition. 14905 This method makes a synchronous HTTP request by default. To make an 14906 asynchronous HTTP request, please define a `callback` function 14907 to be invoked when receiving the response. 14908 >>> def callback_function(response): 14909 >>> pprint(response) 14910 >>> 14911 >>> thread = api.update_template_scheduled_sending_definition(account_id, template_id, callback=callback_function) 14912 14913 :param callback function: The callback function 14914 for asynchronous request. (optional) 14915 :param str account_id: The external account number (int) or account ID Guid. (required) 14916 :param str template_id: The ID of the template being accessed. (required) 14917 :param ScheduledSending scheduled_sending: 14918 :return: ScheduledSending 14919 If the method is called asynchronously, 14920 returns the request thread. 14921 """ 14922 kwargs['_return_http_data_only'] = True 14923 if kwargs.get('callback'): 14924 return self.update_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 14925 else: 14926 (data) = self.update_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 14927 return data 14928 14929 def update_template_scheduled_sending_definition_with_http_info(self, account_id, template_id, **kwargs): 14930 """ 14931 Updates the scheduled sending rules for a template's workflow definition. 14932 This method makes a synchronous HTTP request by default. To make an 14933 asynchronous HTTP request, please define a `callback` function 14934 to be invoked when receiving the response. 14935 >>> def callback_function(response): 14936 >>> pprint(response) 14937 >>> 14938 >>> thread = api.update_template_scheduled_sending_definition_with_http_info(account_id, template_id, callback=callback_function) 14939 14940 :param callback function: The callback function 14941 for asynchronous request. (optional) 14942 :param str account_id: The external account number (int) or account ID Guid. (required) 14943 :param str template_id: The ID of the template being accessed. (required) 14944 :param ScheduledSending scheduled_sending: 14945 :return: ScheduledSending 14946 If the method is called asynchronously, 14947 returns the request thread. 14948 """ 14949 14950 all_params = ['account_id', 'template_id', 'scheduled_sending'] 14951 all_params.append('callback') 14952 all_params.append('_return_http_data_only') 14953 all_params.append('_preload_content') 14954 all_params.append('_request_timeout') 14955 14956 params = locals() 14957 for key, val in iteritems(params['kwargs']): 14958 if key not in all_params: 14959 raise TypeError( 14960 "Got an unexpected keyword argument '%s'" 14961 " to method update_template_scheduled_sending_definition" % key 14962 ) 14963 params[key] = val 14964 del params['kwargs'] 14965 # verify the required parameter 'account_id' is set 14966 if ('account_id' not in params) or (params['account_id'] is None): 14967 raise ValueError("Missing the required parameter `account_id` when calling `update_template_scheduled_sending_definition`") 14968 # verify the required parameter 'template_id' is set 14969 if ('template_id' not in params) or (params['template_id'] is None): 14970 raise ValueError("Missing the required parameter `template_id` when calling `update_template_scheduled_sending_definition`") 14971 14972 14973 collection_formats = {} 14974 14975 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/scheduledSending'.replace('{format}', 'json') 14976 path_params = {} 14977 if 'account_id' in params: 14978 path_params['accountId'] = params['account_id'] 14979 if 'template_id' in params: 14980 path_params['templateId'] = params['template_id'] 14981 14982 query_params = {} 14983 14984 header_params = {} 14985 14986 form_params = [] 14987 local_var_files = {} 14988 14989 body_params = None 14990 if 'scheduled_sending' in params: 14991 body_params = params['scheduled_sending'] 14992 # HTTP header `Accept` 14993 header_params['Accept'] = self.api_client.\ 14994 select_header_accept(['application/json']) 14995 14996 # Authentication setting 14997 auth_settings = [] 14998 14999 return self.api_client.call_api(resource_path, 'PUT', 15000 path_params, 15001 query_params, 15002 header_params, 15003 body=body_params, 15004 post_params=form_params, 15005 files=local_var_files, 15006 response_type='ScheduledSending', 15007 auth_settings=auth_settings, 15008 callback=params.get('callback'), 15009 _return_http_data_only=params.get('_return_http_data_only'), 15010 _preload_content=params.get('_preload_content', True), 15011 _request_timeout=params.get('_request_timeout'), 15012 collection_formats=collection_formats) 15013 15014 def update_template_workflow_definition(self, account_id, template_id, **kwargs): 15015 """ 15016 Updates the workflow definition for a template. 15017 Updates the specified template's workflow definition if it has one. 15018 This method makes a synchronous HTTP request by default. To make an 15019 asynchronous HTTP request, please define a `callback` function 15020 to be invoked when receiving the response. 15021 >>> def callback_function(response): 15022 >>> pprint(response) 15023 >>> 15024 >>> thread = api.update_template_workflow_definition(account_id, template_id, callback=callback_function) 15025 15026 :param callback function: The callback function 15027 for asynchronous request. (optional) 15028 :param str account_id: The external account number (int) or account ID Guid. (required) 15029 :param str template_id: The ID of the template being accessed. (required) 15030 :param Workflow workflow: 15031 :return: Workflow 15032 If the method is called asynchronously, 15033 returns the request thread. 15034 """ 15035 kwargs['_return_http_data_only'] = True 15036 if kwargs.get('callback'): 15037 return self.update_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 15038 else: 15039 (data) = self.update_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 15040 return data 15041 15042 def update_template_workflow_definition_with_http_info(self, account_id, template_id, **kwargs): 15043 """ 15044 Updates the workflow definition for a template. 15045 Updates the specified template's workflow definition if it has one. 15046 This method makes a synchronous HTTP request by default. To make an 15047 asynchronous HTTP request, please define a `callback` function 15048 to be invoked when receiving the response. 15049 >>> def callback_function(response): 15050 >>> pprint(response) 15051 >>> 15052 >>> thread = api.update_template_workflow_definition_with_http_info(account_id, template_id, callback=callback_function) 15053 15054 :param callback function: The callback function 15055 for asynchronous request. (optional) 15056 :param str account_id: The external account number (int) or account ID Guid. (required) 15057 :param str template_id: The ID of the template being accessed. (required) 15058 :param Workflow workflow: 15059 :return: Workflow 15060 If the method is called asynchronously, 15061 returns the request thread. 15062 """ 15063 15064 all_params = ['account_id', 'template_id', 'workflow'] 15065 all_params.append('callback') 15066 all_params.append('_return_http_data_only') 15067 all_params.append('_preload_content') 15068 all_params.append('_request_timeout') 15069 15070 params = locals() 15071 for key, val in iteritems(params['kwargs']): 15072 if key not in all_params: 15073 raise TypeError( 15074 "Got an unexpected keyword argument '%s'" 15075 " to method update_template_workflow_definition" % key 15076 ) 15077 params[key] = val 15078 del params['kwargs'] 15079 # verify the required parameter 'account_id' is set 15080 if ('account_id' not in params) or (params['account_id'] is None): 15081 raise ValueError("Missing the required parameter `account_id` when calling `update_template_workflow_definition`") 15082 # verify the required parameter 'template_id' is set 15083 if ('template_id' not in params) or (params['template_id'] is None): 15084 raise ValueError("Missing the required parameter `template_id` when calling `update_template_workflow_definition`") 15085 15086 15087 collection_formats = {} 15088 15089 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow'.replace('{format}', 'json') 15090 path_params = {} 15091 if 'account_id' in params: 15092 path_params['accountId'] = params['account_id'] 15093 if 'template_id' in params: 15094 path_params['templateId'] = params['template_id'] 15095 15096 query_params = {} 15097 15098 header_params = {} 15099 15100 form_params = [] 15101 local_var_files = {} 15102 15103 body_params = None 15104 if 'workflow' in params: 15105 body_params = params['workflow'] 15106 # HTTP header `Accept` 15107 header_params['Accept'] = self.api_client.\ 15108 select_header_accept(['application/json']) 15109 15110 # Authentication setting 15111 auth_settings = [] 15112 15113 return self.api_client.call_api(resource_path, 'PUT', 15114 path_params, 15115 query_params, 15116 header_params, 15117 body=body_params, 15118 post_params=form_params, 15119 files=local_var_files, 15120 response_type='Workflow', 15121 auth_settings=auth_settings, 15122 callback=params.get('callback'), 15123 _return_http_data_only=params.get('_return_http_data_only'), 15124 _preload_content=params.get('_preload_content', True), 15125 _request_timeout=params.get('_request_timeout'), 15126 collection_formats=collection_formats) 15127 15128 def update_template_workflow_step_definition(self, account_id, template_id, workflow_step_id, **kwargs): 15129 """ 15130 Updates the template workflow step definition for an envelope. 15131 This method makes a synchronous HTTP request by default. To make an 15132 asynchronous HTTP request, please define a `callback` function 15133 to be invoked when receiving the response. 15134 >>> def callback_function(response): 15135 >>> pprint(response) 15136 >>> 15137 >>> thread = api.update_template_workflow_step_definition(account_id, template_id, workflow_step_id, callback=callback_function) 15138 15139 :param callback function: The callback function 15140 for asynchronous request. (optional) 15141 :param str account_id: The external account number (int) or account ID Guid. (required) 15142 :param str template_id: The ID of the template being accessed. (required) 15143 :param str workflow_step_id: (required) 15144 :param WorkflowStep workflow_step: 15145 :return: WorkflowStep 15146 If the method is called asynchronously, 15147 returns the request thread. 15148 """ 15149 kwargs['_return_http_data_only'] = True 15150 if kwargs.get('callback'): 15151 return self.update_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 15152 else: 15153 (data) = self.update_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 15154 return data 15155 15156 def update_template_workflow_step_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 15157 """ 15158 Updates the template workflow step definition for an envelope. 15159 This method makes a synchronous HTTP request by default. To make an 15160 asynchronous HTTP request, please define a `callback` function 15161 to be invoked when receiving the response. 15162 >>> def callback_function(response): 15163 >>> pprint(response) 15164 >>> 15165 >>> thread = api.update_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 15166 15167 :param callback function: The callback function 15168 for asynchronous request. (optional) 15169 :param str account_id: The external account number (int) or account ID Guid. (required) 15170 :param str template_id: The ID of the template being accessed. (required) 15171 :param str workflow_step_id: (required) 15172 :param WorkflowStep workflow_step: 15173 :return: WorkflowStep 15174 If the method is called asynchronously, 15175 returns the request thread. 15176 """ 15177 15178 all_params = ['account_id', 'template_id', 'workflow_step_id', 'workflow_step'] 15179 all_params.append('callback') 15180 all_params.append('_return_http_data_only') 15181 all_params.append('_preload_content') 15182 all_params.append('_request_timeout') 15183 15184 params = locals() 15185 for key, val in iteritems(params['kwargs']): 15186 if key not in all_params: 15187 raise TypeError( 15188 "Got an unexpected keyword argument '%s'" 15189 " to method update_template_workflow_step_definition" % key 15190 ) 15191 params[key] = val 15192 del params['kwargs'] 15193 # verify the required parameter 'account_id' is set 15194 if ('account_id' not in params) or (params['account_id'] is None): 15195 raise ValueError("Missing the required parameter `account_id` when calling `update_template_workflow_step_definition`") 15196 # verify the required parameter 'template_id' is set 15197 if ('template_id' not in params) or (params['template_id'] is None): 15198 raise ValueError("Missing the required parameter `template_id` when calling `update_template_workflow_step_definition`") 15199 # verify the required parameter 'workflow_step_id' is set 15200 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 15201 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_template_workflow_step_definition`") 15202 15203 15204 collection_formats = {} 15205 15206 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 15207 path_params = {} 15208 if 'account_id' in params: 15209 path_params['accountId'] = params['account_id'] 15210 if 'template_id' in params: 15211 path_params['templateId'] = params['template_id'] 15212 if 'workflow_step_id' in params: 15213 path_params['workflowStepId'] = params['workflow_step_id'] 15214 15215 query_params = {} 15216 15217 header_params = {} 15218 15219 form_params = [] 15220 local_var_files = {} 15221 15222 body_params = None 15223 if 'workflow_step' in params: 15224 body_params = params['workflow_step'] 15225 # HTTP header `Accept` 15226 header_params['Accept'] = self.api_client.\ 15227 select_header_accept(['application/json']) 15228 15229 # Authentication setting 15230 auth_settings = [] 15231 15232 return self.api_client.call_api(resource_path, 'PUT', 15233 path_params, 15234 query_params, 15235 header_params, 15236 body=body_params, 15237 post_params=form_params, 15238 files=local_var_files, 15239 response_type='WorkflowStep', 15240 auth_settings=auth_settings, 15241 callback=params.get('callback'), 15242 _return_http_data_only=params.get('_return_http_data_only'), 15243 _preload_content=params.get('_preload_content', True), 15244 _request_timeout=params.get('_request_timeout'), 15245 collection_formats=collection_formats)
class
EnvelopesApi:
28class EnvelopesApi(object): 29 """ 30 NOTE: This class is auto generated by the swagger code generator program. 31 Do not edit the class manually. 32 Ref: https://github.com/swagger-api/swagger-codegen 33 """ 34 35 def __init__(self, api_client=None): 36 config = Configuration() 37 if api_client: 38 self.api_client = api_client 39 else: 40 if not config.api_client: 41 config.api_client = ApiClient() 42 self.api_client = config.api_client 43 44 def apply_template(self, account_id, envelope_id, **kwargs): 45 """ 46 Adds templates to an envelope. 47 Adds templates to the specified envelope. 48 This method makes a synchronous HTTP request by default. To make an 49 asynchronous HTTP request, please define a `callback` function 50 to be invoked when receiving the response. 51 >>> def callback_function(response): 52 >>> pprint(response) 53 >>> 54 >>> thread = api.apply_template(account_id, envelope_id, callback=callback_function) 55 56 :param callback function: The callback function 57 for asynchronous request. (optional) 58 :param str account_id: The external account number (int) or account ID Guid. (required) 59 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 60 :param str preserve_template_recipient: 61 :param DocumentTemplateList document_template_list: 62 :return: DocumentTemplateList 63 If the method is called asynchronously, 64 returns the request thread. 65 """ 66 kwargs['_return_http_data_only'] = True 67 if kwargs.get('callback'): 68 return self.apply_template_with_http_info(account_id, envelope_id, **kwargs) 69 else: 70 (data) = self.apply_template_with_http_info(account_id, envelope_id, **kwargs) 71 return data 72 73 def apply_template_with_http_info(self, account_id, envelope_id, **kwargs): 74 """ 75 Adds templates to an envelope. 76 Adds templates to the specified envelope. 77 This method makes a synchronous HTTP request by default. To make an 78 asynchronous HTTP request, please define a `callback` function 79 to be invoked when receiving the response. 80 >>> def callback_function(response): 81 >>> pprint(response) 82 >>> 83 >>> thread = api.apply_template_with_http_info(account_id, envelope_id, callback=callback_function) 84 85 :param callback function: The callback function 86 for asynchronous request. (optional) 87 :param str account_id: The external account number (int) or account ID Guid. (required) 88 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 89 :param str preserve_template_recipient: 90 :param DocumentTemplateList document_template_list: 91 :return: DocumentTemplateList 92 If the method is called asynchronously, 93 returns the request thread. 94 """ 95 96 all_params = ['account_id', 'envelope_id', 'preserve_template_recipient', 'document_template_list'] 97 all_params.append('callback') 98 all_params.append('_return_http_data_only') 99 all_params.append('_preload_content') 100 all_params.append('_request_timeout') 101 102 params = locals() 103 for key, val in iteritems(params['kwargs']): 104 if key not in all_params: 105 raise TypeError( 106 "Got an unexpected keyword argument '%s'" 107 " to method apply_template" % key 108 ) 109 params[key] = val 110 del params['kwargs'] 111 # verify the required parameter 'account_id' is set 112 if ('account_id' not in params) or (params['account_id'] is None): 113 raise ValueError("Missing the required parameter `account_id` when calling `apply_template`") 114 # verify the required parameter 'envelope_id' is set 115 if ('envelope_id' not in params) or (params['envelope_id'] is None): 116 raise ValueError("Missing the required parameter `envelope_id` when calling `apply_template`") 117 118 119 collection_formats = {} 120 121 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/templates'.replace('{format}', 'json') 122 path_params = {} 123 if 'account_id' in params: 124 path_params['accountId'] = params['account_id'] 125 if 'envelope_id' in params: 126 path_params['envelopeId'] = params['envelope_id'] 127 128 query_params = {} 129 if 'preserve_template_recipient' in params: 130 query_params['preserve_template_recipient'] = params['preserve_template_recipient'] 131 132 header_params = {} 133 134 form_params = [] 135 local_var_files = {} 136 137 body_params = None 138 if 'document_template_list' in params: 139 body_params = params['document_template_list'] 140 # HTTP header `Accept` 141 header_params['Accept'] = self.api_client.\ 142 select_header_accept(['application/json']) 143 144 # Authentication setting 145 auth_settings = [] 146 147 return self.api_client.call_api(resource_path, 'POST', 148 path_params, 149 query_params, 150 header_params, 151 body=body_params, 152 post_params=form_params, 153 files=local_var_files, 154 response_type='DocumentTemplateList', 155 auth_settings=auth_settings, 156 callback=params.get('callback'), 157 _return_http_data_only=params.get('_return_http_data_only'), 158 _preload_content=params.get('_preload_content', True), 159 _request_timeout=params.get('_request_timeout'), 160 collection_formats=collection_formats) 161 162 def apply_template_to_document(self, account_id, document_id, envelope_id, **kwargs): 163 """ 164 Adds templates to a document in an envelope. 165 Adds templates to a document in the specified envelope. 166 This method makes a synchronous HTTP request by default. To make an 167 asynchronous HTTP request, please define a `callback` function 168 to be invoked when receiving the response. 169 >>> def callback_function(response): 170 >>> pprint(response) 171 >>> 172 >>> thread = api.apply_template_to_document(account_id, document_id, envelope_id, callback=callback_function) 173 174 :param callback function: The callback function 175 for asynchronous request. (optional) 176 :param str account_id: The external account number (int) or account ID Guid. (required) 177 :param str document_id: The ID of the document being accessed. (required) 178 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 179 :param str preserve_template_recipient: 180 :param DocumentTemplateList document_template_list: 181 :return: DocumentTemplateList 182 If the method is called asynchronously, 183 returns the request thread. 184 """ 185 kwargs['_return_http_data_only'] = True 186 if kwargs.get('callback'): 187 return self.apply_template_to_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 188 else: 189 (data) = self.apply_template_to_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 190 return data 191 192 def apply_template_to_document_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 193 """ 194 Adds templates to a document in an envelope. 195 Adds templates to a document in the specified envelope. 196 This method makes a synchronous HTTP request by default. To make an 197 asynchronous HTTP request, please define a `callback` function 198 to be invoked when receiving the response. 199 >>> def callback_function(response): 200 >>> pprint(response) 201 >>> 202 >>> thread = api.apply_template_to_document_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 203 204 :param callback function: The callback function 205 for asynchronous request. (optional) 206 :param str account_id: The external account number (int) or account ID Guid. (required) 207 :param str document_id: The ID of the document being accessed. (required) 208 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 209 :param str preserve_template_recipient: 210 :param DocumentTemplateList document_template_list: 211 :return: DocumentTemplateList 212 If the method is called asynchronously, 213 returns the request thread. 214 """ 215 216 all_params = ['account_id', 'document_id', 'envelope_id', 'preserve_template_recipient', 'document_template_list'] 217 all_params.append('callback') 218 all_params.append('_return_http_data_only') 219 all_params.append('_preload_content') 220 all_params.append('_request_timeout') 221 222 params = locals() 223 for key, val in iteritems(params['kwargs']): 224 if key not in all_params: 225 raise TypeError( 226 "Got an unexpected keyword argument '%s'" 227 " to method apply_template_to_document" % key 228 ) 229 params[key] = val 230 del params['kwargs'] 231 # verify the required parameter 'account_id' is set 232 if ('account_id' not in params) or (params['account_id'] is None): 233 raise ValueError("Missing the required parameter `account_id` when calling `apply_template_to_document`") 234 # verify the required parameter 'document_id' is set 235 if ('document_id' not in params) or (params['document_id'] is None): 236 raise ValueError("Missing the required parameter `document_id` when calling `apply_template_to_document`") 237 # verify the required parameter 'envelope_id' is set 238 if ('envelope_id' not in params) or (params['envelope_id'] is None): 239 raise ValueError("Missing the required parameter `envelope_id` when calling `apply_template_to_document`") 240 241 242 collection_formats = {} 243 244 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/templates'.replace('{format}', 'json') 245 path_params = {} 246 if 'account_id' in params: 247 path_params['accountId'] = params['account_id'] 248 if 'document_id' in params: 249 path_params['documentId'] = params['document_id'] 250 if 'envelope_id' in params: 251 path_params['envelopeId'] = params['envelope_id'] 252 253 query_params = {} 254 if 'preserve_template_recipient' in params: 255 query_params['preserve_template_recipient'] = params['preserve_template_recipient'] 256 257 header_params = {} 258 259 form_params = [] 260 local_var_files = {} 261 262 body_params = None 263 if 'document_template_list' in params: 264 body_params = params['document_template_list'] 265 # HTTP header `Accept` 266 header_params['Accept'] = self.api_client.\ 267 select_header_accept(['application/json']) 268 269 # Authentication setting 270 auth_settings = [] 271 272 return self.api_client.call_api(resource_path, 'POST', 273 path_params, 274 query_params, 275 header_params, 276 body=body_params, 277 post_params=form_params, 278 files=local_var_files, 279 response_type='DocumentTemplateList', 280 auth_settings=auth_settings, 281 callback=params.get('callback'), 282 _return_http_data_only=params.get('_return_http_data_only'), 283 _preload_content=params.get('_preload_content', True), 284 _request_timeout=params.get('_request_timeout'), 285 collection_formats=collection_formats) 286 287 def create_chunked_upload(self, account_id, **kwargs): 288 """ 289 Initiate a new ChunkedUpload. 290 This method initiates a new chunked upload with the first part of the content. 291 This method makes a synchronous HTTP request by default. To make an 292 asynchronous HTTP request, please define a `callback` function 293 to be invoked when receiving the response. 294 >>> def callback_function(response): 295 >>> pprint(response) 296 >>> 297 >>> thread = api.create_chunked_upload(account_id, callback=callback_function) 298 299 :param callback function: The callback function 300 for asynchronous request. (optional) 301 :param str account_id: The external account number (int) or account ID Guid. (required) 302 :param ChunkedUploadRequest chunked_upload_request: 303 :return: ChunkedUploadResponse 304 If the method is called asynchronously, 305 returns the request thread. 306 """ 307 kwargs['_return_http_data_only'] = True 308 if kwargs.get('callback'): 309 return self.create_chunked_upload_with_http_info(account_id, **kwargs) 310 else: 311 (data) = self.create_chunked_upload_with_http_info(account_id, **kwargs) 312 return data 313 314 def create_chunked_upload_with_http_info(self, account_id, **kwargs): 315 """ 316 Initiate a new ChunkedUpload. 317 This method initiates a new chunked upload with the first part of the content. 318 This method makes a synchronous HTTP request by default. To make an 319 asynchronous HTTP request, please define a `callback` function 320 to be invoked when receiving the response. 321 >>> def callback_function(response): 322 >>> pprint(response) 323 >>> 324 >>> thread = api.create_chunked_upload_with_http_info(account_id, callback=callback_function) 325 326 :param callback function: The callback function 327 for asynchronous request. (optional) 328 :param str account_id: The external account number (int) or account ID Guid. (required) 329 :param ChunkedUploadRequest chunked_upload_request: 330 :return: ChunkedUploadResponse 331 If the method is called asynchronously, 332 returns the request thread. 333 """ 334 335 all_params = ['account_id', 'chunked_upload_request'] 336 all_params.append('callback') 337 all_params.append('_return_http_data_only') 338 all_params.append('_preload_content') 339 all_params.append('_request_timeout') 340 341 params = locals() 342 for key, val in iteritems(params['kwargs']): 343 if key not in all_params: 344 raise TypeError( 345 "Got an unexpected keyword argument '%s'" 346 " to method create_chunked_upload" % key 347 ) 348 params[key] = val 349 del params['kwargs'] 350 # verify the required parameter 'account_id' is set 351 if ('account_id' not in params) or (params['account_id'] is None): 352 raise ValueError("Missing the required parameter `account_id` when calling `create_chunked_upload`") 353 354 355 collection_formats = {} 356 357 resource_path = '/v2.1/accounts/{accountId}/chunked_uploads'.replace('{format}', 'json') 358 path_params = {} 359 if 'account_id' in params: 360 path_params['accountId'] = params['account_id'] 361 362 query_params = {} 363 364 header_params = {} 365 366 form_params = [] 367 local_var_files = {} 368 369 body_params = None 370 if 'chunked_upload_request' in params: 371 body_params = params['chunked_upload_request'] 372 # HTTP header `Accept` 373 header_params['Accept'] = self.api_client.\ 374 select_header_accept(['application/json']) 375 376 # Authentication setting 377 auth_settings = [] 378 379 return self.api_client.call_api(resource_path, 'POST', 380 path_params, 381 query_params, 382 header_params, 383 body=body_params, 384 post_params=form_params, 385 files=local_var_files, 386 response_type='ChunkedUploadResponse', 387 auth_settings=auth_settings, 388 callback=params.get('callback'), 389 _return_http_data_only=params.get('_return_http_data_only'), 390 _preload_content=params.get('_preload_content', True), 391 _request_timeout=params.get('_request_timeout'), 392 collection_formats=collection_formats) 393 394 def create_console_view(self, account_id, **kwargs): 395 """ 396 Returns a URL to the authentication view UI. 397 Returns a URL that allows you to embed the authentication view of the DocuSign UI in your applications. 398 This method makes a synchronous HTTP request by default. To make an 399 asynchronous HTTP request, please define a `callback` function 400 to be invoked when receiving the response. 401 >>> def callback_function(response): 402 >>> pprint(response) 403 >>> 404 >>> thread = api.create_console_view(account_id, callback=callback_function) 405 406 :param callback function: The callback function 407 for asynchronous request. (optional) 408 :param str account_id: The external account number (int) or account ID Guid. (required) 409 :param ConsoleViewRequest console_view_request: 410 :return: ViewUrl 411 If the method is called asynchronously, 412 returns the request thread. 413 """ 414 kwargs['_return_http_data_only'] = True 415 if kwargs.get('callback'): 416 return self.create_console_view_with_http_info(account_id, **kwargs) 417 else: 418 (data) = self.create_console_view_with_http_info(account_id, **kwargs) 419 return data 420 421 def create_console_view_with_http_info(self, account_id, **kwargs): 422 """ 423 Returns a URL to the authentication view UI. 424 Returns a URL that allows you to embed the authentication view of the DocuSign UI in your applications. 425 This method makes a synchronous HTTP request by default. To make an 426 asynchronous HTTP request, please define a `callback` function 427 to be invoked when receiving the response. 428 >>> def callback_function(response): 429 >>> pprint(response) 430 >>> 431 >>> thread = api.create_console_view_with_http_info(account_id, callback=callback_function) 432 433 :param callback function: The callback function 434 for asynchronous request. (optional) 435 :param str account_id: The external account number (int) or account ID Guid. (required) 436 :param ConsoleViewRequest console_view_request: 437 :return: ViewUrl 438 If the method is called asynchronously, 439 returns the request thread. 440 """ 441 442 all_params = ['account_id', 'console_view_request'] 443 all_params.append('callback') 444 all_params.append('_return_http_data_only') 445 all_params.append('_preload_content') 446 all_params.append('_request_timeout') 447 448 params = locals() 449 for key, val in iteritems(params['kwargs']): 450 if key not in all_params: 451 raise TypeError( 452 "Got an unexpected keyword argument '%s'" 453 " to method create_console_view" % key 454 ) 455 params[key] = val 456 del params['kwargs'] 457 # verify the required parameter 'account_id' is set 458 if ('account_id' not in params) or (params['account_id'] is None): 459 raise ValueError("Missing the required parameter `account_id` when calling `create_console_view`") 460 461 462 collection_formats = {} 463 464 resource_path = '/v2.1/accounts/{accountId}/views/console'.replace('{format}', 'json') 465 path_params = {} 466 if 'account_id' in params: 467 path_params['accountId'] = params['account_id'] 468 469 query_params = {} 470 471 header_params = {} 472 473 form_params = [] 474 local_var_files = {} 475 476 body_params = None 477 if 'console_view_request' in params: 478 body_params = params['console_view_request'] 479 # HTTP header `Accept` 480 header_params['Accept'] = self.api_client.\ 481 select_header_accept(['application/json']) 482 483 # Authentication setting 484 auth_settings = [] 485 486 return self.api_client.call_api(resource_path, 'POST', 487 path_params, 488 query_params, 489 header_params, 490 body=body_params, 491 post_params=form_params, 492 files=local_var_files, 493 response_type='ViewUrl', 494 auth_settings=auth_settings, 495 callback=params.get('callback'), 496 _return_http_data_only=params.get('_return_http_data_only'), 497 _preload_content=params.get('_preload_content', True), 498 _request_timeout=params.get('_request_timeout'), 499 collection_formats=collection_formats) 500 501 def create_correct_view(self, account_id, envelope_id, **kwargs): 502 """ 503 Returns a URL to the envelope correction UI. 504 Returns a URL that allows you to embed the envelope correction view of the DocuSign UI in your applications. Important: iFrames should not be used for embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends using a WebView. 505 This method makes a synchronous HTTP request by default. To make an 506 asynchronous HTTP request, please define a `callback` function 507 to be invoked when receiving the response. 508 >>> def callback_function(response): 509 >>> pprint(response) 510 >>> 511 >>> thread = api.create_correct_view(account_id, envelope_id, callback=callback_function) 512 513 :param callback function: The callback function 514 for asynchronous request. (optional) 515 :param str account_id: The external account number (int) or account ID Guid. (required) 516 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 517 :param EnvelopeViewRequest envelope_view_request: 518 :return: ViewUrl 519 If the method is called asynchronously, 520 returns the request thread. 521 """ 522 kwargs['_return_http_data_only'] = True 523 if kwargs.get('callback'): 524 return self.create_correct_view_with_http_info(account_id, envelope_id, **kwargs) 525 else: 526 (data) = self.create_correct_view_with_http_info(account_id, envelope_id, **kwargs) 527 return data 528 529 def create_correct_view_with_http_info(self, account_id, envelope_id, **kwargs): 530 """ 531 Returns a URL to the envelope correction UI. 532 Returns a URL that allows you to embed the envelope correction view of the DocuSign UI in your applications. Important: iFrames should not be used for embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends using a WebView. 533 This method makes a synchronous HTTP request by default. To make an 534 asynchronous HTTP request, please define a `callback` function 535 to be invoked when receiving the response. 536 >>> def callback_function(response): 537 >>> pprint(response) 538 >>> 539 >>> thread = api.create_correct_view_with_http_info(account_id, envelope_id, callback=callback_function) 540 541 :param callback function: The callback function 542 for asynchronous request. (optional) 543 :param str account_id: The external account number (int) or account ID Guid. (required) 544 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 545 :param EnvelopeViewRequest envelope_view_request: 546 :return: ViewUrl 547 If the method is called asynchronously, 548 returns the request thread. 549 """ 550 551 all_params = ['account_id', 'envelope_id', 'envelope_view_request'] 552 all_params.append('callback') 553 all_params.append('_return_http_data_only') 554 all_params.append('_preload_content') 555 all_params.append('_request_timeout') 556 557 params = locals() 558 for key, val in iteritems(params['kwargs']): 559 if key not in all_params: 560 raise TypeError( 561 "Got an unexpected keyword argument '%s'" 562 " to method create_correct_view" % key 563 ) 564 params[key] = val 565 del params['kwargs'] 566 # verify the required parameter 'account_id' is set 567 if ('account_id' not in params) or (params['account_id'] is None): 568 raise ValueError("Missing the required parameter `account_id` when calling `create_correct_view`") 569 # verify the required parameter 'envelope_id' is set 570 if ('envelope_id' not in params) or (params['envelope_id'] is None): 571 raise ValueError("Missing the required parameter `envelope_id` when calling `create_correct_view`") 572 573 574 collection_formats = {} 575 576 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/correct'.replace('{format}', 'json') 577 path_params = {} 578 if 'account_id' in params: 579 path_params['accountId'] = params['account_id'] 580 if 'envelope_id' in params: 581 path_params['envelopeId'] = params['envelope_id'] 582 583 query_params = {} 584 585 header_params = {} 586 587 form_params = [] 588 local_var_files = {} 589 590 body_params = None 591 if 'envelope_view_request' in params: 592 body_params = params['envelope_view_request'] 593 # HTTP header `Accept` 594 header_params['Accept'] = self.api_client.\ 595 select_header_accept(['application/json']) 596 597 # Authentication setting 598 auth_settings = [] 599 600 return self.api_client.call_api(resource_path, 'POST', 601 path_params, 602 query_params, 603 header_params, 604 body=body_params, 605 post_params=form_params, 606 files=local_var_files, 607 response_type='ViewUrl', 608 auth_settings=auth_settings, 609 callback=params.get('callback'), 610 _return_http_data_only=params.get('_return_http_data_only'), 611 _preload_content=params.get('_preload_content', True), 612 _request_timeout=params.get('_request_timeout'), 613 collection_formats=collection_formats) 614 615 def create_custom_fields(self, account_id, envelope_id, **kwargs): 616 """ 617 Updates envelope custom fields for an envelope. 618 Updates the envelope custom fields for draft and in-process envelopes. Each custom field used in an envelope must have a unique name. 619 This method makes a synchronous HTTP request by default. To make an 620 asynchronous HTTP request, please define a `callback` function 621 to be invoked when receiving the response. 622 >>> def callback_function(response): 623 >>> pprint(response) 624 >>> 625 >>> thread = api.create_custom_fields(account_id, envelope_id, callback=callback_function) 626 627 :param callback function: The callback function 628 for asynchronous request. (optional) 629 :param str account_id: The external account number (int) or account ID Guid. (required) 630 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 631 :param CustomFields custom_fields: 632 :return: CustomFields 633 If the method is called asynchronously, 634 returns the request thread. 635 """ 636 kwargs['_return_http_data_only'] = True 637 if kwargs.get('callback'): 638 return self.create_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 639 else: 640 (data) = self.create_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 641 return data 642 643 def create_custom_fields_with_http_info(self, account_id, envelope_id, **kwargs): 644 """ 645 Updates envelope custom fields for an envelope. 646 Updates the envelope custom fields for draft and in-process envelopes. Each custom field used in an envelope must have a unique name. 647 This method makes a synchronous HTTP request by default. To make an 648 asynchronous HTTP request, please define a `callback` function 649 to be invoked when receiving the response. 650 >>> def callback_function(response): 651 >>> pprint(response) 652 >>> 653 >>> thread = api.create_custom_fields_with_http_info(account_id, envelope_id, callback=callback_function) 654 655 :param callback function: The callback function 656 for asynchronous request. (optional) 657 :param str account_id: The external account number (int) or account ID Guid. (required) 658 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 659 :param CustomFields custom_fields: 660 :return: CustomFields 661 If the method is called asynchronously, 662 returns the request thread. 663 """ 664 665 all_params = ['account_id', 'envelope_id', 'custom_fields'] 666 all_params.append('callback') 667 all_params.append('_return_http_data_only') 668 all_params.append('_preload_content') 669 all_params.append('_request_timeout') 670 671 params = locals() 672 for key, val in iteritems(params['kwargs']): 673 if key not in all_params: 674 raise TypeError( 675 "Got an unexpected keyword argument '%s'" 676 " to method create_custom_fields" % key 677 ) 678 params[key] = val 679 del params['kwargs'] 680 # verify the required parameter 'account_id' is set 681 if ('account_id' not in params) or (params['account_id'] is None): 682 raise ValueError("Missing the required parameter `account_id` when calling `create_custom_fields`") 683 # verify the required parameter 'envelope_id' is set 684 if ('envelope_id' not in params) or (params['envelope_id'] is None): 685 raise ValueError("Missing the required parameter `envelope_id` when calling `create_custom_fields`") 686 687 688 collection_formats = {} 689 690 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/custom_fields'.replace('{format}', 'json') 691 path_params = {} 692 if 'account_id' in params: 693 path_params['accountId'] = params['account_id'] 694 if 'envelope_id' in params: 695 path_params['envelopeId'] = params['envelope_id'] 696 697 query_params = {} 698 699 header_params = {} 700 701 form_params = [] 702 local_var_files = {} 703 704 body_params = None 705 if 'custom_fields' in params: 706 body_params = params['custom_fields'] 707 # HTTP header `Accept` 708 header_params['Accept'] = self.api_client.\ 709 select_header_accept(['application/json']) 710 711 # Authentication setting 712 auth_settings = [] 713 714 return self.api_client.call_api(resource_path, 'POST', 715 path_params, 716 query_params, 717 header_params, 718 body=body_params, 719 post_params=form_params, 720 files=local_var_files, 721 response_type='CustomFields', 722 auth_settings=auth_settings, 723 callback=params.get('callback'), 724 _return_http_data_only=params.get('_return_http_data_only'), 725 _preload_content=params.get('_preload_content', True), 726 _request_timeout=params.get('_request_timeout'), 727 collection_formats=collection_formats) 728 729 def create_document_fields(self, account_id, document_id, envelope_id, **kwargs): 730 """ 731 Creates custom document fields in an existing envelope document. 732 Creates custom document fields in an existing envelope document. 733 This method makes a synchronous HTTP request by default. To make an 734 asynchronous HTTP request, please define a `callback` function 735 to be invoked when receiving the response. 736 >>> def callback_function(response): 737 >>> pprint(response) 738 >>> 739 >>> thread = api.create_document_fields(account_id, document_id, envelope_id, callback=callback_function) 740 741 :param callback function: The callback function 742 for asynchronous request. (optional) 743 :param str account_id: The external account number (int) or account ID Guid. (required) 744 :param str document_id: The ID of the document being accessed. (required) 745 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 746 :param DocumentFieldsInformation document_fields_information: 747 :return: DocumentFieldsInformation 748 If the method is called asynchronously, 749 returns the request thread. 750 """ 751 kwargs['_return_http_data_only'] = True 752 if kwargs.get('callback'): 753 return self.create_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 754 else: 755 (data) = self.create_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 756 return data 757 758 def create_document_fields_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 759 """ 760 Creates custom document fields in an existing envelope document. 761 Creates custom document fields in an existing envelope document. 762 This method makes a synchronous HTTP request by default. To make an 763 asynchronous HTTP request, please define a `callback` function 764 to be invoked when receiving the response. 765 >>> def callback_function(response): 766 >>> pprint(response) 767 >>> 768 >>> thread = api.create_document_fields_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 769 770 :param callback function: The callback function 771 for asynchronous request. (optional) 772 :param str account_id: The external account number (int) or account ID Guid. (required) 773 :param str document_id: The ID of the document being accessed. (required) 774 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 775 :param DocumentFieldsInformation document_fields_information: 776 :return: DocumentFieldsInformation 777 If the method is called asynchronously, 778 returns the request thread. 779 """ 780 781 all_params = ['account_id', 'document_id', 'envelope_id', 'document_fields_information'] 782 all_params.append('callback') 783 all_params.append('_return_http_data_only') 784 all_params.append('_preload_content') 785 all_params.append('_request_timeout') 786 787 params = locals() 788 for key, val in iteritems(params['kwargs']): 789 if key not in all_params: 790 raise TypeError( 791 "Got an unexpected keyword argument '%s'" 792 " to method create_document_fields" % key 793 ) 794 params[key] = val 795 del params['kwargs'] 796 # verify the required parameter 'account_id' is set 797 if ('account_id' not in params) or (params['account_id'] is None): 798 raise ValueError("Missing the required parameter `account_id` when calling `create_document_fields`") 799 # verify the required parameter 'document_id' is set 800 if ('document_id' not in params) or (params['document_id'] is None): 801 raise ValueError("Missing the required parameter `document_id` when calling `create_document_fields`") 802 # verify the required parameter 'envelope_id' is set 803 if ('envelope_id' not in params) or (params['envelope_id'] is None): 804 raise ValueError("Missing the required parameter `envelope_id` when calling `create_document_fields`") 805 806 807 collection_formats = {} 808 809 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/fields'.replace('{format}', 'json') 810 path_params = {} 811 if 'account_id' in params: 812 path_params['accountId'] = params['account_id'] 813 if 'document_id' in params: 814 path_params['documentId'] = params['document_id'] 815 if 'envelope_id' in params: 816 path_params['envelopeId'] = params['envelope_id'] 817 818 query_params = {} 819 820 header_params = {} 821 822 form_params = [] 823 local_var_files = {} 824 825 body_params = None 826 if 'document_fields_information' in params: 827 body_params = params['document_fields_information'] 828 # HTTP header `Accept` 829 header_params['Accept'] = self.api_client.\ 830 select_header_accept(['application/json']) 831 832 # Authentication setting 833 auth_settings = [] 834 835 return self.api_client.call_api(resource_path, 'POST', 836 path_params, 837 query_params, 838 header_params, 839 body=body_params, 840 post_params=form_params, 841 files=local_var_files, 842 response_type='DocumentFieldsInformation', 843 auth_settings=auth_settings, 844 callback=params.get('callback'), 845 _return_http_data_only=params.get('_return_http_data_only'), 846 _preload_content=params.get('_preload_content', True), 847 _request_timeout=params.get('_request_timeout'), 848 collection_formats=collection_formats) 849 850 def create_document_responsive_html_preview(self, account_id, document_id, envelope_id, **kwargs): 851 """ 852 Get Responsive HTML Preview for a document in an envelope. 853 Creates a preview of the [responsive](/docs/esign-rest-api/esign101/concepts/responsive/) HTML version of a specific document. This method enables you to preview a PDF document conversion to responsive HTML across device types prior to sending. The request body is a `documentHtmlDefinition` object, which holds the responsive signing parameters that define how to generate the HTML version of the signing document. 854 This method makes a synchronous HTTP request by default. To make an 855 asynchronous HTTP request, please define a `callback` function 856 to be invoked when receiving the response. 857 >>> def callback_function(response): 858 >>> pprint(response) 859 >>> 860 >>> thread = api.create_document_responsive_html_preview(account_id, document_id, envelope_id, callback=callback_function) 861 862 :param callback function: The callback function 863 for asynchronous request. (optional) 864 :param str account_id: The external account number (int) or account ID Guid. (required) 865 :param str document_id: The ID of the document being accessed. (required) 866 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 867 :param DocumentHtmlDefinition document_html_definition: 868 :return: DocumentHtmlDefinitions 869 If the method is called asynchronously, 870 returns the request thread. 871 """ 872 kwargs['_return_http_data_only'] = True 873 if kwargs.get('callback'): 874 return self.create_document_responsive_html_preview_with_http_info(account_id, document_id, envelope_id, **kwargs) 875 else: 876 (data) = self.create_document_responsive_html_preview_with_http_info(account_id, document_id, envelope_id, **kwargs) 877 return data 878 879 def create_document_responsive_html_preview_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 880 """ 881 Get Responsive HTML Preview for a document in an envelope. 882 Creates a preview of the [responsive](/docs/esign-rest-api/esign101/concepts/responsive/) HTML version of a specific document. This method enables you to preview a PDF document conversion to responsive HTML across device types prior to sending. The request body is a `documentHtmlDefinition` object, which holds the responsive signing parameters that define how to generate the HTML version of the signing document. 883 This method makes a synchronous HTTP request by default. To make an 884 asynchronous HTTP request, please define a `callback` function 885 to be invoked when receiving the response. 886 >>> def callback_function(response): 887 >>> pprint(response) 888 >>> 889 >>> thread = api.create_document_responsive_html_preview_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 890 891 :param callback function: The callback function 892 for asynchronous request. (optional) 893 :param str account_id: The external account number (int) or account ID Guid. (required) 894 :param str document_id: The ID of the document being accessed. (required) 895 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 896 :param DocumentHtmlDefinition document_html_definition: 897 :return: DocumentHtmlDefinitions 898 If the method is called asynchronously, 899 returns the request thread. 900 """ 901 902 all_params = ['account_id', 'document_id', 'envelope_id', 'document_html_definition'] 903 all_params.append('callback') 904 all_params.append('_return_http_data_only') 905 all_params.append('_preload_content') 906 all_params.append('_request_timeout') 907 908 params = locals() 909 for key, val in iteritems(params['kwargs']): 910 if key not in all_params: 911 raise TypeError( 912 "Got an unexpected keyword argument '%s'" 913 " to method create_document_responsive_html_preview" % key 914 ) 915 params[key] = val 916 del params['kwargs'] 917 # verify the required parameter 'account_id' is set 918 if ('account_id' not in params) or (params['account_id'] is None): 919 raise ValueError("Missing the required parameter `account_id` when calling `create_document_responsive_html_preview`") 920 # verify the required parameter 'document_id' is set 921 if ('document_id' not in params) or (params['document_id'] is None): 922 raise ValueError("Missing the required parameter `document_id` when calling `create_document_responsive_html_preview`") 923 # verify the required parameter 'envelope_id' is set 924 if ('envelope_id' not in params) or (params['envelope_id'] is None): 925 raise ValueError("Missing the required parameter `envelope_id` when calling `create_document_responsive_html_preview`") 926 927 928 collection_formats = {} 929 930 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/responsive_html_preview'.replace('{format}', 'json') 931 path_params = {} 932 if 'account_id' in params: 933 path_params['accountId'] = params['account_id'] 934 if 'document_id' in params: 935 path_params['documentId'] = params['document_id'] 936 if 'envelope_id' in params: 937 path_params['envelopeId'] = params['envelope_id'] 938 939 query_params = {} 940 941 header_params = {} 942 943 form_params = [] 944 local_var_files = {} 945 946 body_params = None 947 if 'document_html_definition' in params: 948 body_params = params['document_html_definition'] 949 # HTTP header `Accept` 950 header_params['Accept'] = self.api_client.\ 951 select_header_accept(['application/json']) 952 953 # Authentication setting 954 auth_settings = [] 955 956 return self.api_client.call_api(resource_path, 'POST', 957 path_params, 958 query_params, 959 header_params, 960 body=body_params, 961 post_params=form_params, 962 files=local_var_files, 963 response_type='DocumentHtmlDefinitions', 964 auth_settings=auth_settings, 965 callback=params.get('callback'), 966 _return_http_data_only=params.get('_return_http_data_only'), 967 _preload_content=params.get('_preload_content', True), 968 _request_timeout=params.get('_request_timeout'), 969 collection_formats=collection_formats) 970 971 def create_document_tabs(self, account_id, document_id, envelope_id, **kwargs): 972 """ 973 Adds the tabs to an envelope document 974 Adds tabs to the document specified by `documentId` in the envelope specified by `envelopeId`. In the request body, you only need to specify the tabs that your are adding. For example, to add a text [prefill tab](/docs/esign-rest-api/reference/envelopes/envelopedocumenttabs/create/#definition__tabs_prefilltabs), your request body might look like this: ``` { \"prefillTabs\": { \"textTabs\": [ { \"value\": \"a prefill text tab\", \"pageNumber\": \"1\", \"documentId\": \"1\", \"xPosition\": 316, \"yPosition\": 97 } ] } } ``` 975 This method makes a synchronous HTTP request by default. To make an 976 asynchronous HTTP request, please define a `callback` function 977 to be invoked when receiving the response. 978 >>> def callback_function(response): 979 >>> pprint(response) 980 >>> 981 >>> thread = api.create_document_tabs(account_id, document_id, envelope_id, callback=callback_function) 982 983 :param callback function: The callback function 984 for asynchronous request. (optional) 985 :param str account_id: The external account number (int) or account ID Guid. (required) 986 :param str document_id: The ID of the document being accessed. (required) 987 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 988 :param Tabs tabs: 989 :return: Tabs 990 If the method is called asynchronously, 991 returns the request thread. 992 """ 993 kwargs['_return_http_data_only'] = True 994 if kwargs.get('callback'): 995 return self.create_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 996 else: 997 (data) = self.create_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 998 return data 999 1000 def create_document_tabs_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 1001 """ 1002 Adds the tabs to an envelope document 1003 Adds tabs to the document specified by `documentId` in the envelope specified by `envelopeId`. In the request body, you only need to specify the tabs that your are adding. For example, to add a text [prefill tab](/docs/esign-rest-api/reference/envelopes/envelopedocumenttabs/create/#definition__tabs_prefilltabs), your request body might look like this: ``` { \"prefillTabs\": { \"textTabs\": [ { \"value\": \"a prefill text tab\", \"pageNumber\": \"1\", \"documentId\": \"1\", \"xPosition\": 316, \"yPosition\": 97 } ] } } ``` 1004 This method makes a synchronous HTTP request by default. To make an 1005 asynchronous HTTP request, please define a `callback` function 1006 to be invoked when receiving the response. 1007 >>> def callback_function(response): 1008 >>> pprint(response) 1009 >>> 1010 >>> thread = api.create_document_tabs_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 1011 1012 :param callback function: The callback function 1013 for asynchronous request. (optional) 1014 :param str account_id: The external account number (int) or account ID Guid. (required) 1015 :param str document_id: The ID of the document being accessed. (required) 1016 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1017 :param Tabs tabs: 1018 :return: Tabs 1019 If the method is called asynchronously, 1020 returns the request thread. 1021 """ 1022 1023 all_params = ['account_id', 'document_id', 'envelope_id', 'tabs'] 1024 all_params.append('callback') 1025 all_params.append('_return_http_data_only') 1026 all_params.append('_preload_content') 1027 all_params.append('_request_timeout') 1028 1029 params = locals() 1030 for key, val in iteritems(params['kwargs']): 1031 if key not in all_params: 1032 raise TypeError( 1033 "Got an unexpected keyword argument '%s'" 1034 " to method create_document_tabs" % key 1035 ) 1036 params[key] = val 1037 del params['kwargs'] 1038 # verify the required parameter 'account_id' is set 1039 if ('account_id' not in params) or (params['account_id'] is None): 1040 raise ValueError("Missing the required parameter `account_id` when calling `create_document_tabs`") 1041 # verify the required parameter 'document_id' is set 1042 if ('document_id' not in params) or (params['document_id'] is None): 1043 raise ValueError("Missing the required parameter `document_id` when calling `create_document_tabs`") 1044 # verify the required parameter 'envelope_id' is set 1045 if ('envelope_id' not in params) or (params['envelope_id'] is None): 1046 raise ValueError("Missing the required parameter `envelope_id` when calling `create_document_tabs`") 1047 1048 1049 collection_formats = {} 1050 1051 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/tabs'.replace('{format}', 'json') 1052 path_params = {} 1053 if 'account_id' in params: 1054 path_params['accountId'] = params['account_id'] 1055 if 'document_id' in params: 1056 path_params['documentId'] = params['document_id'] 1057 if 'envelope_id' in params: 1058 path_params['envelopeId'] = params['envelope_id'] 1059 1060 query_params = {} 1061 1062 header_params = {} 1063 1064 form_params = [] 1065 local_var_files = {} 1066 1067 body_params = None 1068 if 'tabs' in params: 1069 body_params = params['tabs'] 1070 # HTTP header `Accept` 1071 header_params['Accept'] = self.api_client.\ 1072 select_header_accept(['application/json']) 1073 1074 # Authentication setting 1075 auth_settings = [] 1076 1077 return self.api_client.call_api(resource_path, 'POST', 1078 path_params, 1079 query_params, 1080 header_params, 1081 body=body_params, 1082 post_params=form_params, 1083 files=local_var_files, 1084 response_type='Tabs', 1085 auth_settings=auth_settings, 1086 callback=params.get('callback'), 1087 _return_http_data_only=params.get('_return_http_data_only'), 1088 _preload_content=params.get('_preload_content', True), 1089 _request_timeout=params.get('_request_timeout'), 1090 collection_formats=collection_formats) 1091 1092 def create_edit_view(self, account_id, envelope_id, **kwargs): 1093 """ 1094 Returns a URL to the edit view UI. 1095 Returns a URL that allows you to embed the edit view of the DocuSign UI in your applications. This is a one-time use login token that allows the user to be placed into the DocuSign editing view. Upon sending completion, the user is returned to the return URL provided by the API application. Important: iFrames should not be used for embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends using a WebView. 1096 This method makes a synchronous HTTP request by default. To make an 1097 asynchronous HTTP request, please define a `callback` function 1098 to be invoked when receiving the response. 1099 >>> def callback_function(response): 1100 >>> pprint(response) 1101 >>> 1102 >>> thread = api.create_edit_view(account_id, envelope_id, callback=callback_function) 1103 1104 :param callback function: The callback function 1105 for asynchronous request. (optional) 1106 :param str account_id: The external account number (int) or account ID Guid. (required) 1107 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1108 :param EnvelopeViewRequest envelope_view_request: 1109 :return: ViewUrl 1110 If the method is called asynchronously, 1111 returns the request thread. 1112 """ 1113 kwargs['_return_http_data_only'] = True 1114 if kwargs.get('callback'): 1115 return self.create_edit_view_with_http_info(account_id, envelope_id, **kwargs) 1116 else: 1117 (data) = self.create_edit_view_with_http_info(account_id, envelope_id, **kwargs) 1118 return data 1119 1120 def create_edit_view_with_http_info(self, account_id, envelope_id, **kwargs): 1121 """ 1122 Returns a URL to the edit view UI. 1123 Returns a URL that allows you to embed the edit view of the DocuSign UI in your applications. This is a one-time use login token that allows the user to be placed into the DocuSign editing view. Upon sending completion, the user is returned to the return URL provided by the API application. Important: iFrames should not be used for embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends using a WebView. 1124 This method makes a synchronous HTTP request by default. To make an 1125 asynchronous HTTP request, please define a `callback` function 1126 to be invoked when receiving the response. 1127 >>> def callback_function(response): 1128 >>> pprint(response) 1129 >>> 1130 >>> thread = api.create_edit_view_with_http_info(account_id, envelope_id, callback=callback_function) 1131 1132 :param callback function: The callback function 1133 for asynchronous request. (optional) 1134 :param str account_id: The external account number (int) or account ID Guid. (required) 1135 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1136 :param EnvelopeViewRequest envelope_view_request: 1137 :return: ViewUrl 1138 If the method is called asynchronously, 1139 returns the request thread. 1140 """ 1141 1142 all_params = ['account_id', 'envelope_id', 'envelope_view_request'] 1143 all_params.append('callback') 1144 all_params.append('_return_http_data_only') 1145 all_params.append('_preload_content') 1146 all_params.append('_request_timeout') 1147 1148 params = locals() 1149 for key, val in iteritems(params['kwargs']): 1150 if key not in all_params: 1151 raise TypeError( 1152 "Got an unexpected keyword argument '%s'" 1153 " to method create_edit_view" % key 1154 ) 1155 params[key] = val 1156 del params['kwargs'] 1157 # verify the required parameter 'account_id' is set 1158 if ('account_id' not in params) or (params['account_id'] is None): 1159 raise ValueError("Missing the required parameter `account_id` when calling `create_edit_view`") 1160 # verify the required parameter 'envelope_id' is set 1161 if ('envelope_id' not in params) or (params['envelope_id'] is None): 1162 raise ValueError("Missing the required parameter `envelope_id` when calling `create_edit_view`") 1163 1164 1165 collection_formats = {} 1166 1167 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/edit'.replace('{format}', 'json') 1168 path_params = {} 1169 if 'account_id' in params: 1170 path_params['accountId'] = params['account_id'] 1171 if 'envelope_id' in params: 1172 path_params['envelopeId'] = params['envelope_id'] 1173 1174 query_params = {} 1175 1176 header_params = {} 1177 1178 form_params = [] 1179 local_var_files = {} 1180 1181 body_params = None 1182 if 'envelope_view_request' in params: 1183 body_params = params['envelope_view_request'] 1184 # HTTP header `Accept` 1185 header_params['Accept'] = self.api_client.\ 1186 select_header_accept(['application/json']) 1187 1188 # Authentication setting 1189 auth_settings = [] 1190 1191 return self.api_client.call_api(resource_path, 'POST', 1192 path_params, 1193 query_params, 1194 header_params, 1195 body=body_params, 1196 post_params=form_params, 1197 files=local_var_files, 1198 response_type='ViewUrl', 1199 auth_settings=auth_settings, 1200 callback=params.get('callback'), 1201 _return_http_data_only=params.get('_return_http_data_only'), 1202 _preload_content=params.get('_preload_content', True), 1203 _request_timeout=params.get('_request_timeout'), 1204 collection_formats=collection_formats) 1205 1206 def create_email_settings(self, account_id, envelope_id, **kwargs): 1207 """ 1208 Adds email setting overrides to an envelope. 1209 Adds email override settings, changing the email address to reply to an email address, name, or the BCC for email archive information, for the envelope. Note that adding email settings will only affect email communications that occur after the addition was made. ### Important: The BCC Email address feature is designed to provide a copy of all email communications for external archiving purposes. DocuSign recommends that envelopes sent using the BCC for Email Archive feature, including the BCC Email Override option, include additional signer authentication options. To send a copy of the envelope to a recipient who does not need to sign, use a Carbon Copies or Certified Deliveries Recipient Type. 1210 This method makes a synchronous HTTP request by default. To make an 1211 asynchronous HTTP request, please define a `callback` function 1212 to be invoked when receiving the response. 1213 >>> def callback_function(response): 1214 >>> pprint(response) 1215 >>> 1216 >>> thread = api.create_email_settings(account_id, envelope_id, callback=callback_function) 1217 1218 :param callback function: The callback function 1219 for asynchronous request. (optional) 1220 :param str account_id: The external account number (int) or account ID Guid. (required) 1221 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1222 :param EmailSettings email_settings: 1223 :return: EmailSettings 1224 If the method is called asynchronously, 1225 returns the request thread. 1226 """ 1227 kwargs['_return_http_data_only'] = True 1228 if kwargs.get('callback'): 1229 return self.create_email_settings_with_http_info(account_id, envelope_id, **kwargs) 1230 else: 1231 (data) = self.create_email_settings_with_http_info(account_id, envelope_id, **kwargs) 1232 return data 1233 1234 def create_email_settings_with_http_info(self, account_id, envelope_id, **kwargs): 1235 """ 1236 Adds email setting overrides to an envelope. 1237 Adds email override settings, changing the email address to reply to an email address, name, or the BCC for email archive information, for the envelope. Note that adding email settings will only affect email communications that occur after the addition was made. ### Important: The BCC Email address feature is designed to provide a copy of all email communications for external archiving purposes. DocuSign recommends that envelopes sent using the BCC for Email Archive feature, including the BCC Email Override option, include additional signer authentication options. To send a copy of the envelope to a recipient who does not need to sign, use a Carbon Copies or Certified Deliveries Recipient Type. 1238 This method makes a synchronous HTTP request by default. To make an 1239 asynchronous HTTP request, please define a `callback` function 1240 to be invoked when receiving the response. 1241 >>> def callback_function(response): 1242 >>> pprint(response) 1243 >>> 1244 >>> thread = api.create_email_settings_with_http_info(account_id, envelope_id, callback=callback_function) 1245 1246 :param callback function: The callback function 1247 for asynchronous request. (optional) 1248 :param str account_id: The external account number (int) or account ID Guid. (required) 1249 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1250 :param EmailSettings email_settings: 1251 :return: EmailSettings 1252 If the method is called asynchronously, 1253 returns the request thread. 1254 """ 1255 1256 all_params = ['account_id', 'envelope_id', 'email_settings'] 1257 all_params.append('callback') 1258 all_params.append('_return_http_data_only') 1259 all_params.append('_preload_content') 1260 all_params.append('_request_timeout') 1261 1262 params = locals() 1263 for key, val in iteritems(params['kwargs']): 1264 if key not in all_params: 1265 raise TypeError( 1266 "Got an unexpected keyword argument '%s'" 1267 " to method create_email_settings" % key 1268 ) 1269 params[key] = val 1270 del params['kwargs'] 1271 # verify the required parameter 'account_id' is set 1272 if ('account_id' not in params) or (params['account_id'] is None): 1273 raise ValueError("Missing the required parameter `account_id` when calling `create_email_settings`") 1274 # verify the required parameter 'envelope_id' is set 1275 if ('envelope_id' not in params) or (params['envelope_id'] is None): 1276 raise ValueError("Missing the required parameter `envelope_id` when calling `create_email_settings`") 1277 1278 1279 collection_formats = {} 1280 1281 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/email_settings'.replace('{format}', 'json') 1282 path_params = {} 1283 if 'account_id' in params: 1284 path_params['accountId'] = params['account_id'] 1285 if 'envelope_id' in params: 1286 path_params['envelopeId'] = params['envelope_id'] 1287 1288 query_params = {} 1289 1290 header_params = {} 1291 1292 form_params = [] 1293 local_var_files = {} 1294 1295 body_params = None 1296 if 'email_settings' in params: 1297 body_params = params['email_settings'] 1298 # HTTP header `Accept` 1299 header_params['Accept'] = self.api_client.\ 1300 select_header_accept(['application/json']) 1301 1302 # Authentication setting 1303 auth_settings = [] 1304 1305 return self.api_client.call_api(resource_path, 'POST', 1306 path_params, 1307 query_params, 1308 header_params, 1309 body=body_params, 1310 post_params=form_params, 1311 files=local_var_files, 1312 response_type='EmailSettings', 1313 auth_settings=auth_settings, 1314 callback=params.get('callback'), 1315 _return_http_data_only=params.get('_return_http_data_only'), 1316 _preload_content=params.get('_preload_content', True), 1317 _request_timeout=params.get('_request_timeout'), 1318 collection_formats=collection_formats) 1319 1320 def create_envelope(self, account_id, **kwargs): 1321 """ 1322 Creates an envelope. 1323 Creates an envelope. Using this function you can: * Create an envelope and send it. * Create an envelope from an existing template and send it. In either case, you can choose to save the envelope as a draft envelope instead of sending it by setting the request's `status` property to `created` instead of `sent`. ## Sending Envelopes Documents can be included with the Envelopes::create call itself or a template can include documents. Documents can be added by using a multi-part/form request or by using the `documentBase64` field of the [`document` object](#/definitions/document) ### Recipient Types An [`envelopeDefinition` object](#/definitions/envelopeDefinition) is used as the method's body. Envelope recipients can be defined in the envelope or in templates. The `envelopeDefinition` object's `recipients` field is an [`EnvelopeRecipients` resource object](#/definitions/EnvelopeRecipients). It includes arrays of the seven types of recipients defined by DocuSign: Recipient type | Object definition -------------- | ----------------- agent (can add name and email information for later recipients/signers) | [`agent`](#/definitions/agent) carbon copy (receives a copy of the documents) | [`carbonCopy`](#/definitions/carbonCopy) certified delivery (receives a copy of the documents and must acknowledge receipt) | [`certifiedDelivery`](#/definitions/certifiedDelivery) editor (can change recipients and document fields for later recipients/signers) | [`editor`](#/definitions/editor) in-person signer (\"hosts\" someone who signs in-person) | [`inPersonSigner`](#/definitions/inPersonSigner) intermediary (can add name and email information for some later recipients/signers.) | [`intermediary`](#/definitions/intermediary) signer (signs and/or updates document fields) | [`signer`](#/definitions/signer) Additional information about the different types of recipients is available from the [`EnvelopeRecipients` resource page](../../EnvelopeRecipients) and from the [Developer Center](https://www.docusign.com/developer-center/explore/features/recipients) ### Tabs Tabs (also referred to as `tags` and as `fields` in the web sending user interface), can be defined in the `envelopeDefinition`, in templates, by transforming PDF Form Fields, or by using Composite Templates (see below). Defining tabs: the `inPersonSigner`, and `signer` recipient objects include a `tabs` field. It is an [`EnvelopeTabs` resource object](#/definitions/EnvelopeTabs). It includes arrays of the 24 different tab types available. See the [`EnvelopeTabs` resource](../../EnvelopeTabs) for more information. ## Using Templates Envelopes use specific people or groups as recipients. Templates can specify a role, eg `account_manager.` When a template is used in an envelope, the roles must be replaced with specific people or groups. When you create an envelope using a `templateId`, the different recipient type objects within the [`EnvelopeRecipients` object](#/definitions/EnvelopeRecipients) are used to assign recipients to the template's roles via the `roleName` property. The recipient objects can also override settings that were specified in the template, and set values for tab fields that were defined in the template. ### Message Lock When a template is added or applied to an envelope and the template has a locked email subject and message, that subject and message are used for the envelope and cannot be changed even if another locked template is subsequently added or applied to the envelope. The field `messageLock` is used to lock the email subject and message. If an email subject or message is entered before adding or applying a template with `messageLock` **true**, the email subject and message is overwritten with the locked email subject and message from the template. ## Envelope Status The status of sent envelopes can be determined through the DocuSign webhook system or by polling. Webhooks are highly recommended: they provide your application with the quickest updates when an envelope's status changes. DocuSign limits polling to once every 15 minutes or less frequently. When a webhook is used, DocuSign calls your application, via the URL you provide, with a notification XML message. See the [Webhook recipe](https://www.docusign.com/developer-center/recipes/webhook-status) for examples and live demos of using webhooks. ## Webhook Options The two webhook options, *eventNotification* and *Connect* use the same notification mechanism and message formats. eventNotification is used to create a webhook for a specific envelope sent via the API. Connect webhooks can be used for any envelope sent from an account, from any user, from any client. ### eventNotification Webhooks The Envelopes::create method includes an optional [eventNotification object](#definition-eventNotification) that adds a webhook to the envelope. eventNotification webhooks are available for all DocuSign accounts with API access. ### Connect Webhooks Connect can be used to create a webhook for all envelopes sent by all users in an account, either through the API or via other DocuSign clients (web, mobile, etc). Connect configurations are independent of specific envelopes. A Connect configuration includes a filter that may be used to limit the webhook to specific users, envelope statuses, etc. Connect configurations may be created and managed using the [ConnectConfigurations resource](../../Connect/ConnectConfigurations). Configurations can also be created and managed from the Administration tool accessed by selecting \"Go to Admin\" from the menu next to your picture on the DocuSign web app. See the Integrations/Connect section of the Admin tool. For repeatability, and to minimize support questions, creating Connect configurations via the API is recommended, especially for ISVs. Connect is available for some DocuSign account types. Please contact DocuSign Sales for more information. ## Composite Templates The Composite Templates feature, like [compositing in film production](https://en.wikipedia.org/wiki/Compositing), enables you to *overlay* document, recipient, and tab definitions from multiple sources, including PDF Form Field definitions, templates defined on the server, and more. Each Composite Template consists of optional elements: server templates, inline templates, PDF Metadata templates, and documents. * The Composite Template ID is an optional element used to identify the composite template. It is used as a reference when adding document object information via a multi-part HTTP message. If used, the document content-disposition must include the `compositeTemplateId` to which the document should be added. If `compositeTemplateId` is not specified in the content-disposition, the document is applied based on the `documentId` only. If no document object is specified, the composite template inherits the first document. * Server Templates are server-side templates stored on the DocuSign platform. If supplied, they are overlaid into the envelope in the order of their Sequence value. * Inline Templates provide a container to add documents, recipients, tabs, and custom fields. If inline templates are supplied, they are overlaid into the envelope in the order of their Sequence value. * Document objects are optional structures that provide a container to pass in a document or form. If this object is not included, the composite template inherits the *first* document it finds from a server template or inline template, starting with the lowest sequence value. PDF Form objects are only transformed from the document object. DocuSign does not derive PDF form properties from server templates or inline templates. To instruct DocuSign to transform fields from the PDF form, set `transformPdfFields` to \"true\" for the document. See the Transform PDF Fields section for more information about process. * PDF Metadata Templates provide a container to embed design-time template information into a PDF document. DocuSign uses this information when processing the Envelope. This convention allows the document to carry the signing instructions with it, so that less information needs to be provided at run-time through an inline template or synchronized with an external structure like a server template. PDF Metadata templates are stored in the Metadata layer of a PDF in accordance with Acrobat's XMP specification. DocuSign will only find PDF Metadata templates inside documents passed in the Document object (see below). If supplied, the PDF metadata template will be overlaid into the envelope in the order of its Sequence value. ### Compositing the definitions Each Composite Template adds a new document and templates overlay into the envelope. For each Composite Template these rules are applied: * Templates are overlaid in the order of their Sequence value. * If Document is not passed into the Composite Template's `document` field, the *first* template's document (based on the template's Sequence value) is used. * Last in wins in all cases except for the document (i.e. envelope information, recipient information, secure field information). There is no special casing. For example, if you want higher security on a tab, then that needs to be specified in a later template (by sequence number) then where the tab is included. If you want higher security on a role recipient, then it needs to be in a later template then where that role recipient is specified. * Recipient matching is based on Recipient Role and Routing Order. If there are matches, the recipient information is merged together. A final pass is done on all Composite Templates, after all template overlays have been applied, to collapse recipients with the same email, username and routing order. This prevents having the same recipients at the same routing order. * If you specify in a template that a recipient is locked, once that recipient is overlaid the recipient attributes can no longer be changed. The only items that can be changed for the recipient in this case are the email, username, access code and IDCheckInformationInput. * Tab matching is based on Tab Labels, Tab Types and Documents. If a Tab Label matches but the Document is not supplied, the Tab is overlaid for all the Documents. For example, if you have a simple inline template with only one tab in it with a label and a value, the Signature, Initial, Company, Envelope ID, User Name tabs will only be matched and collapsed if they fall in the exact same X and Y locations. * roleName and tabLabel matching is case sensitive. * The defaultRecipient field enables you to specify which recipient the generated tabs from a PDF form are mapped to. You can also set PDF form generated tabs to a recipient other than the DefaultRecipient by specifying the mapping of the tab label that is created to one of the template recipients. * You can use tabLabel wild carding to map a series of tabs from the PDF form. To use this you must end a tab label with \"\\*\" and then the system matches tabs that start with the label. * If no DefaultRecipient is specified, tabs must be explicitly mapped to recipients in order to be generated from the form. Unmapped form objects will not be generated into their DocuSign equivalents. (In the case of Signature/Initials, the tabs will be disregarded entirely; in the case of pdf text fields, the field data will be flattened on the Envelope document, but there will not be a corresponding DocuSign data tab.) ### Including the Document Content for Composite Templates Document content can be supplied inline, using the `documentBase64` or can be included in a multi-part HTTP message. If a multi-part message is used and there are multiple Composite Templates, the document content-disposition can include the `compositeTemplateId` to which the document should be added. Using the `compositeTemplateId` sets which documents are associated with particular composite templates. An example of this usage is: ``` --5cd3320a-5aac-4453-b3a4-cbb52a4cba5d Content-Type: application/pdf Content-Disposition: file; filename=\"eula.pdf\"; documentId=1; compositeTemplateId=\"1\" Content-Transfer-Encoding: base64 ``` ### PDF Form Field Transformation Only the following PDF Form FieldTypes will be transformed to DocuSign tabs: CheckBox, DateTime, ListBox, Numeric, Password, Radio, Signature, and Text Field Properties that will be transformed: Read Only, Required, Max Length, Positions, and Initial Data. When transforming a *PDF Form Digital Signature Field,* the following rules are used: If the PDF Field Name Contains | Then the DocuSign Tab Will be ------- | -------- DocuSignSignHere or eSignSignHere | Signature DocuSignSignHereOptional or eSignSignHereOptional | Optional Signature DocuSignInitialHere or eSignInitialHere | Initials DocuSignInitialHereOptional or eSignInitialHereOptional | Optional Initials Any other PDF Form Digital Signature Field will be transformed to a DocuSign Signature tab When transforming *PDF Form Text Fields,* the following rules are used: If the PDF Field Name Contains | Then the DocuSign Tab Will be ------- | -------- DocuSignSignHere or eSignSignHere | Signature DocuSignSignHereOptional or eSignSignHereOptional | Optional Signature DocuSignInitialHere or eSignInitialHere | Initials DocuSignInitialHereOptional or eSignInitialHereOptional | Optional Initials DocuSignEnvelopeID or eSignEnvelopeID | EnvelopeID DocuSignCompany or eSignCompany | Company DocuSignDateSigned or eSignDateSigned | Date Signed DocuSignTitle or eSignTitle | Title DocuSignFullName or eSignFullName | Full Name DocuSignSignerAttachmentOptional or eSignSignerAttachmentOptional | Optional Signer Attachment Any other PDF Form Text Field will be transformed to a DocuSign data (text) tab. PDF Form Field Names that include \"DocuSignIgnoreTransform\" or \"eSignIgnoreTransform\" will not be transformed. PDF Form Date fields will be transformed to Date Signed fields if their name includes DocuSignDateSigned or eSignDateSigned. ## Template Email Subject Merge Fields This feature enables you to insert recipient name and email address merge fields into the email subject line when creating or sending from a template. The merge fields, based on the recipient's `roleName`, are added to the `emailSubject` when the template is created or when the template is used to create an envelope. After a template sender adds the name and email information for the recipient and sends the envelope, the recipient information is automatically merged into the appropriate fields in the email subject line. Both the sender and the recipients will see the information in the email subject line for any emails associated with the template. This provides an easy way for senders to organize their envelope emails without having to open an envelope to check the recipient. If merging the recipient information into the subject line causes the subject line to exceed 100 characters, then any characters over the 100 character limit are not included in the subject line. For cases where the recipient name or email is expected to be long, you should consider placing the merge field at the start of the email subject. * To add a recipient's name in the subject line add the following text in the `emailSubject` when creating the template or when sending an envelope from a template: [[<roleName>_UserName]] Example: `\"emailSubject\":\"[[Signer 1_UserName]], Please sign this NDA\",` * To add a recipient's email address in the subject line add the following text in the emailSubject when creating the template or when sending an envelope from a template: [[<roleName>_Email]] Example: `\"emailSubject\":\"[[Signer 1_Email]], Please sign this NDA\",` In both cases the <roleName> is the recipient's `roleName` in the template. For cases where another recipient (such as an Agent, Editor, or Intermediary recipient) is entering the name and email information for the recipient included in the email subject, then [[<roleName>_UserName]] or [[<roleName>_Email]] is shown in the email subject. ## Branding an envelope The following rules are used to determine the `brandId` used in an envelope: * If a `brandId` is specified in the envelope/template and that brandId is available to the account, that brand is used in the envelope. * If more than one template is used in an envelope and more than one `brandId` is specified, the first `brandId` specified is used throughout the envelope. * In cases where no brand is specified and the sender belongs to a Group; if there is only one brand associated with the Group, then that brand is used in the envelope. Otherwise, the account's default signing brand is used. * For envelopes that do not meet any of the previous criteria, the account's default signing brand is used for the envelope. ## BCC Email address feature The BCC Email address feature is designed to provide a copy of all email communications for external archiving purposes. DocuSign recommends that envelopes sent using the BCC for Email Archive feature, including the BCC Email Override option, include additional signer authentication options. To send a copy of the envelope to a recipient who does not need to sign, don't use the BCC Email field. Use a Carbon Copy or Certified Delivery Recipient type. ## Merge Recipient Roles for Draft Envelopes When an envelope with multiple templates is sent, the recipients from the templates are merged according to the template roles, and empty recipients are removed. When creating an envelope with multiple templates, but not sending it (keeping it in a created state), duplicate recipients are not merged, which could cause leave duplicate recipients in the envelope. To prevent this, the query parameter `merge_roles_on_draft` should be added when posting a draft envelope (status=created) with multiple templates. Doing this will merge template roles and remove empty recipients. ###### Note: DocuSign recommends that the `merge_roles_on_draft` query parameter be used anytime you are creating an envelope with multiple templates and keeping it in draft (created) status. 1324 This method makes a synchronous HTTP request by default. To make an 1325 asynchronous HTTP request, please define a `callback` function 1326 to be invoked when receiving the response. 1327 >>> def callback_function(response): 1328 >>> pprint(response) 1329 >>> 1330 >>> thread = api.create_envelope(account_id, callback=callback_function) 1331 1332 :param callback function: The callback function 1333 for asynchronous request. (optional) 1334 :param str account_id: The external account number (int) or account ID Guid. (required) 1335 :param str cdse_mode: 1336 :param str change_routing_order: 1337 :param str completed_documents_only: If set to true then we want to set the sourceEnvelopeId to indicate that this is a\"forward\" envelope action 1338 :param str merge_roles_on_draft: When set to **true**, merges template roles and remove empty recipients when you create an envelope with multiple templates. 1339 :param str tab_label_exact_matches: 1340 :param EnvelopeDefinition envelope_definition: 1341 :return: EnvelopeSummary 1342 If the method is called asynchronously, 1343 returns the request thread. 1344 """ 1345 kwargs['_return_http_data_only'] = True 1346 if kwargs.get('callback'): 1347 return self.create_envelope_with_http_info(account_id, **kwargs) 1348 else: 1349 (data) = self.create_envelope_with_http_info(account_id, **kwargs) 1350 return data 1351 1352 def create_envelope_with_http_info(self, account_id, **kwargs): 1353 """ 1354 Creates an envelope. 1355 Creates an envelope. Using this function you can: * Create an envelope and send it. * Create an envelope from an existing template and send it. In either case, you can choose to save the envelope as a draft envelope instead of sending it by setting the request's `status` property to `created` instead of `sent`. ## Sending Envelopes Documents can be included with the Envelopes::create call itself or a template can include documents. Documents can be added by using a multi-part/form request or by using the `documentBase64` field of the [`document` object](#/definitions/document) ### Recipient Types An [`envelopeDefinition` object](#/definitions/envelopeDefinition) is used as the method's body. Envelope recipients can be defined in the envelope or in templates. The `envelopeDefinition` object's `recipients` field is an [`EnvelopeRecipients` resource object](#/definitions/EnvelopeRecipients). It includes arrays of the seven types of recipients defined by DocuSign: Recipient type | Object definition -------------- | ----------------- agent (can add name and email information for later recipients/signers) | [`agent`](#/definitions/agent) carbon copy (receives a copy of the documents) | [`carbonCopy`](#/definitions/carbonCopy) certified delivery (receives a copy of the documents and must acknowledge receipt) | [`certifiedDelivery`](#/definitions/certifiedDelivery) editor (can change recipients and document fields for later recipients/signers) | [`editor`](#/definitions/editor) in-person signer (\"hosts\" someone who signs in-person) | [`inPersonSigner`](#/definitions/inPersonSigner) intermediary (can add name and email information for some later recipients/signers.) | [`intermediary`](#/definitions/intermediary) signer (signs and/or updates document fields) | [`signer`](#/definitions/signer) Additional information about the different types of recipients is available from the [`EnvelopeRecipients` resource page](../../EnvelopeRecipients) and from the [Developer Center](https://www.docusign.com/developer-center/explore/features/recipients) ### Tabs Tabs (also referred to as `tags` and as `fields` in the web sending user interface), can be defined in the `envelopeDefinition`, in templates, by transforming PDF Form Fields, or by using Composite Templates (see below). Defining tabs: the `inPersonSigner`, and `signer` recipient objects include a `tabs` field. It is an [`EnvelopeTabs` resource object](#/definitions/EnvelopeTabs). It includes arrays of the 24 different tab types available. See the [`EnvelopeTabs` resource](../../EnvelopeTabs) for more information. ## Using Templates Envelopes use specific people or groups as recipients. Templates can specify a role, eg `account_manager.` When a template is used in an envelope, the roles must be replaced with specific people or groups. When you create an envelope using a `templateId`, the different recipient type objects within the [`EnvelopeRecipients` object](#/definitions/EnvelopeRecipients) are used to assign recipients to the template's roles via the `roleName` property. The recipient objects can also override settings that were specified in the template, and set values for tab fields that were defined in the template. ### Message Lock When a template is added or applied to an envelope and the template has a locked email subject and message, that subject and message are used for the envelope and cannot be changed even if another locked template is subsequently added or applied to the envelope. The field `messageLock` is used to lock the email subject and message. If an email subject or message is entered before adding or applying a template with `messageLock` **true**, the email subject and message is overwritten with the locked email subject and message from the template. ## Envelope Status The status of sent envelopes can be determined through the DocuSign webhook system or by polling. Webhooks are highly recommended: they provide your application with the quickest updates when an envelope's status changes. DocuSign limits polling to once every 15 minutes or less frequently. When a webhook is used, DocuSign calls your application, via the URL you provide, with a notification XML message. See the [Webhook recipe](https://www.docusign.com/developer-center/recipes/webhook-status) for examples and live demos of using webhooks. ## Webhook Options The two webhook options, *eventNotification* and *Connect* use the same notification mechanism and message formats. eventNotification is used to create a webhook for a specific envelope sent via the API. Connect webhooks can be used for any envelope sent from an account, from any user, from any client. ### eventNotification Webhooks The Envelopes::create method includes an optional [eventNotification object](#definition-eventNotification) that adds a webhook to the envelope. eventNotification webhooks are available for all DocuSign accounts with API access. ### Connect Webhooks Connect can be used to create a webhook for all envelopes sent by all users in an account, either through the API or via other DocuSign clients (web, mobile, etc). Connect configurations are independent of specific envelopes. A Connect configuration includes a filter that may be used to limit the webhook to specific users, envelope statuses, etc. Connect configurations may be created and managed using the [ConnectConfigurations resource](../../Connect/ConnectConfigurations). Configurations can also be created and managed from the Administration tool accessed by selecting \"Go to Admin\" from the menu next to your picture on the DocuSign web app. See the Integrations/Connect section of the Admin tool. For repeatability, and to minimize support questions, creating Connect configurations via the API is recommended, especially for ISVs. Connect is available for some DocuSign account types. Please contact DocuSign Sales for more information. ## Composite Templates The Composite Templates feature, like [compositing in film production](https://en.wikipedia.org/wiki/Compositing), enables you to *overlay* document, recipient, and tab definitions from multiple sources, including PDF Form Field definitions, templates defined on the server, and more. Each Composite Template consists of optional elements: server templates, inline templates, PDF Metadata templates, and documents. * The Composite Template ID is an optional element used to identify the composite template. It is used as a reference when adding document object information via a multi-part HTTP message. If used, the document content-disposition must include the `compositeTemplateId` to which the document should be added. If `compositeTemplateId` is not specified in the content-disposition, the document is applied based on the `documentId` only. If no document object is specified, the composite template inherits the first document. * Server Templates are server-side templates stored on the DocuSign platform. If supplied, they are overlaid into the envelope in the order of their Sequence value. * Inline Templates provide a container to add documents, recipients, tabs, and custom fields. If inline templates are supplied, they are overlaid into the envelope in the order of their Sequence value. * Document objects are optional structures that provide a container to pass in a document or form. If this object is not included, the composite template inherits the *first* document it finds from a server template or inline template, starting with the lowest sequence value. PDF Form objects are only transformed from the document object. DocuSign does not derive PDF form properties from server templates or inline templates. To instruct DocuSign to transform fields from the PDF form, set `transformPdfFields` to \"true\" for the document. See the Transform PDF Fields section for more information about process. * PDF Metadata Templates provide a container to embed design-time template information into a PDF document. DocuSign uses this information when processing the Envelope. This convention allows the document to carry the signing instructions with it, so that less information needs to be provided at run-time through an inline template or synchronized with an external structure like a server template. PDF Metadata templates are stored in the Metadata layer of a PDF in accordance with Acrobat's XMP specification. DocuSign will only find PDF Metadata templates inside documents passed in the Document object (see below). If supplied, the PDF metadata template will be overlaid into the envelope in the order of its Sequence value. ### Compositing the definitions Each Composite Template adds a new document and templates overlay into the envelope. For each Composite Template these rules are applied: * Templates are overlaid in the order of their Sequence value. * If Document is not passed into the Composite Template's `document` field, the *first* template's document (based on the template's Sequence value) is used. * Last in wins in all cases except for the document (i.e. envelope information, recipient information, secure field information). There is no special casing. For example, if you want higher security on a tab, then that needs to be specified in a later template (by sequence number) then where the tab is included. If you want higher security on a role recipient, then it needs to be in a later template then where that role recipient is specified. * Recipient matching is based on Recipient Role and Routing Order. If there are matches, the recipient information is merged together. A final pass is done on all Composite Templates, after all template overlays have been applied, to collapse recipients with the same email, username and routing order. This prevents having the same recipients at the same routing order. * If you specify in a template that a recipient is locked, once that recipient is overlaid the recipient attributes can no longer be changed. The only items that can be changed for the recipient in this case are the email, username, access code and IDCheckInformationInput. * Tab matching is based on Tab Labels, Tab Types and Documents. If a Tab Label matches but the Document is not supplied, the Tab is overlaid for all the Documents. For example, if you have a simple inline template with only one tab in it with a label and a value, the Signature, Initial, Company, Envelope ID, User Name tabs will only be matched and collapsed if they fall in the exact same X and Y locations. * roleName and tabLabel matching is case sensitive. * The defaultRecipient field enables you to specify which recipient the generated tabs from a PDF form are mapped to. You can also set PDF form generated tabs to a recipient other than the DefaultRecipient by specifying the mapping of the tab label that is created to one of the template recipients. * You can use tabLabel wild carding to map a series of tabs from the PDF form. To use this you must end a tab label with \"\\*\" and then the system matches tabs that start with the label. * If no DefaultRecipient is specified, tabs must be explicitly mapped to recipients in order to be generated from the form. Unmapped form objects will not be generated into their DocuSign equivalents. (In the case of Signature/Initials, the tabs will be disregarded entirely; in the case of pdf text fields, the field data will be flattened on the Envelope document, but there will not be a corresponding DocuSign data tab.) ### Including the Document Content for Composite Templates Document content can be supplied inline, using the `documentBase64` or can be included in a multi-part HTTP message. If a multi-part message is used and there are multiple Composite Templates, the document content-disposition can include the `compositeTemplateId` to which the document should be added. Using the `compositeTemplateId` sets which documents are associated with particular composite templates. An example of this usage is: ``` --5cd3320a-5aac-4453-b3a4-cbb52a4cba5d Content-Type: application/pdf Content-Disposition: file; filename=\"eula.pdf\"; documentId=1; compositeTemplateId=\"1\" Content-Transfer-Encoding: base64 ``` ### PDF Form Field Transformation Only the following PDF Form FieldTypes will be transformed to DocuSign tabs: CheckBox, DateTime, ListBox, Numeric, Password, Radio, Signature, and Text Field Properties that will be transformed: Read Only, Required, Max Length, Positions, and Initial Data. When transforming a *PDF Form Digital Signature Field,* the following rules are used: If the PDF Field Name Contains | Then the DocuSign Tab Will be ------- | -------- DocuSignSignHere or eSignSignHere | Signature DocuSignSignHereOptional or eSignSignHereOptional | Optional Signature DocuSignInitialHere or eSignInitialHere | Initials DocuSignInitialHereOptional or eSignInitialHereOptional | Optional Initials Any other PDF Form Digital Signature Field will be transformed to a DocuSign Signature tab When transforming *PDF Form Text Fields,* the following rules are used: If the PDF Field Name Contains | Then the DocuSign Tab Will be ------- | -------- DocuSignSignHere or eSignSignHere | Signature DocuSignSignHereOptional or eSignSignHereOptional | Optional Signature DocuSignInitialHere or eSignInitialHere | Initials DocuSignInitialHereOptional or eSignInitialHereOptional | Optional Initials DocuSignEnvelopeID or eSignEnvelopeID | EnvelopeID DocuSignCompany or eSignCompany | Company DocuSignDateSigned or eSignDateSigned | Date Signed DocuSignTitle or eSignTitle | Title DocuSignFullName or eSignFullName | Full Name DocuSignSignerAttachmentOptional or eSignSignerAttachmentOptional | Optional Signer Attachment Any other PDF Form Text Field will be transformed to a DocuSign data (text) tab. PDF Form Field Names that include \"DocuSignIgnoreTransform\" or \"eSignIgnoreTransform\" will not be transformed. PDF Form Date fields will be transformed to Date Signed fields if their name includes DocuSignDateSigned or eSignDateSigned. ## Template Email Subject Merge Fields This feature enables you to insert recipient name and email address merge fields into the email subject line when creating or sending from a template. The merge fields, based on the recipient's `roleName`, are added to the `emailSubject` when the template is created or when the template is used to create an envelope. After a template sender adds the name and email information for the recipient and sends the envelope, the recipient information is automatically merged into the appropriate fields in the email subject line. Both the sender and the recipients will see the information in the email subject line for any emails associated with the template. This provides an easy way for senders to organize their envelope emails without having to open an envelope to check the recipient. If merging the recipient information into the subject line causes the subject line to exceed 100 characters, then any characters over the 100 character limit are not included in the subject line. For cases where the recipient name or email is expected to be long, you should consider placing the merge field at the start of the email subject. * To add a recipient's name in the subject line add the following text in the `emailSubject` when creating the template or when sending an envelope from a template: [[<roleName>_UserName]] Example: `\"emailSubject\":\"[[Signer 1_UserName]], Please sign this NDA\",` * To add a recipient's email address in the subject line add the following text in the emailSubject when creating the template or when sending an envelope from a template: [[<roleName>_Email]] Example: `\"emailSubject\":\"[[Signer 1_Email]], Please sign this NDA\",` In both cases the <roleName> is the recipient's `roleName` in the template. For cases where another recipient (such as an Agent, Editor, or Intermediary recipient) is entering the name and email information for the recipient included in the email subject, then [[<roleName>_UserName]] or [[<roleName>_Email]] is shown in the email subject. ## Branding an envelope The following rules are used to determine the `brandId` used in an envelope: * If a `brandId` is specified in the envelope/template and that brandId is available to the account, that brand is used in the envelope. * If more than one template is used in an envelope and more than one `brandId` is specified, the first `brandId` specified is used throughout the envelope. * In cases where no brand is specified and the sender belongs to a Group; if there is only one brand associated with the Group, then that brand is used in the envelope. Otherwise, the account's default signing brand is used. * For envelopes that do not meet any of the previous criteria, the account's default signing brand is used for the envelope. ## BCC Email address feature The BCC Email address feature is designed to provide a copy of all email communications for external archiving purposes. DocuSign recommends that envelopes sent using the BCC for Email Archive feature, including the BCC Email Override option, include additional signer authentication options. To send a copy of the envelope to a recipient who does not need to sign, don't use the BCC Email field. Use a Carbon Copy or Certified Delivery Recipient type. ## Merge Recipient Roles for Draft Envelopes When an envelope with multiple templates is sent, the recipients from the templates are merged according to the template roles, and empty recipients are removed. When creating an envelope with multiple templates, but not sending it (keeping it in a created state), duplicate recipients are not merged, which could cause leave duplicate recipients in the envelope. To prevent this, the query parameter `merge_roles_on_draft` should be added when posting a draft envelope (status=created) with multiple templates. Doing this will merge template roles and remove empty recipients. ###### Note: DocuSign recommends that the `merge_roles_on_draft` query parameter be used anytime you are creating an envelope with multiple templates and keeping it in draft (created) status. 1356 This method makes a synchronous HTTP request by default. To make an 1357 asynchronous HTTP request, please define a `callback` function 1358 to be invoked when receiving the response. 1359 >>> def callback_function(response): 1360 >>> pprint(response) 1361 >>> 1362 >>> thread = api.create_envelope_with_http_info(account_id, callback=callback_function) 1363 1364 :param callback function: The callback function 1365 for asynchronous request. (optional) 1366 :param str account_id: The external account number (int) or account ID Guid. (required) 1367 :param str cdse_mode: 1368 :param str change_routing_order: 1369 :param str completed_documents_only: If set to true then we want to set the sourceEnvelopeId to indicate that this is a\"forward\" envelope action 1370 :param str merge_roles_on_draft: When set to **true**, merges template roles and remove empty recipients when you create an envelope with multiple templates. 1371 :param str tab_label_exact_matches: 1372 :param EnvelopeDefinition envelope_definition: 1373 :return: EnvelopeSummary 1374 If the method is called asynchronously, 1375 returns the request thread. 1376 """ 1377 1378 all_params = ['account_id', 'cdse_mode', 'change_routing_order', 'completed_documents_only', 'merge_roles_on_draft', 'tab_label_exact_matches', 'envelope_definition'] 1379 all_params.append('callback') 1380 all_params.append('_return_http_data_only') 1381 all_params.append('_preload_content') 1382 all_params.append('_request_timeout') 1383 1384 params = locals() 1385 for key, val in iteritems(params['kwargs']): 1386 if key not in all_params: 1387 raise TypeError( 1388 "Got an unexpected keyword argument '%s'" 1389 " to method create_envelope" % key 1390 ) 1391 params[key] = val 1392 del params['kwargs'] 1393 # verify the required parameter 'account_id' is set 1394 if ('account_id' not in params) or (params['account_id'] is None): 1395 raise ValueError("Missing the required parameter `account_id` when calling `create_envelope`") 1396 1397 1398 collection_formats = {} 1399 1400 resource_path = '/v2.1/accounts/{accountId}/envelopes'.replace('{format}', 'json') 1401 path_params = {} 1402 if 'account_id' in params: 1403 path_params['accountId'] = params['account_id'] 1404 1405 query_params = {} 1406 if 'cdse_mode' in params: 1407 query_params['cdse_mode'] = params['cdse_mode'] 1408 if 'change_routing_order' in params: 1409 query_params['change_routing_order'] = params['change_routing_order'] 1410 if 'completed_documents_only' in params: 1411 query_params['completed_documents_only'] = params['completed_documents_only'] 1412 if 'merge_roles_on_draft' in params: 1413 query_params['merge_roles_on_draft'] = params['merge_roles_on_draft'] 1414 if 'tab_label_exact_matches' in params: 1415 query_params['tab_label_exact_matches'] = params['tab_label_exact_matches'] 1416 1417 header_params = {} 1418 1419 form_params = [] 1420 local_var_files = {} 1421 1422 body_params = None 1423 if 'envelope_definition' in params: 1424 body_params = params['envelope_definition'] 1425 # HTTP header `Accept` 1426 header_params['Accept'] = self.api_client.\ 1427 select_header_accept(['application/json']) 1428 1429 # Authentication setting 1430 auth_settings = [] 1431 1432 return self.api_client.call_api(resource_path, 'POST', 1433 path_params, 1434 query_params, 1435 header_params, 1436 body=body_params, 1437 post_params=form_params, 1438 files=local_var_files, 1439 response_type='EnvelopeSummary', 1440 auth_settings=auth_settings, 1441 callback=params.get('callback'), 1442 _return_http_data_only=params.get('_return_http_data_only'), 1443 _preload_content=params.get('_preload_content', True), 1444 _request_timeout=params.get('_request_timeout'), 1445 collection_formats=collection_formats) 1446 1447 def create_envelope_comments(self, account_id, envelope_id, **kwargs): 1448 """ 1449 Posts a list of comments for authorized user 1450 1451 This method makes a synchronous HTTP request by default. To make an 1452 asynchronous HTTP request, please define a `callback` function 1453 to be invoked when receiving the response. 1454 >>> def callback_function(response): 1455 >>> pprint(response) 1456 >>> 1457 >>> thread = api.create_envelope_comments(account_id, envelope_id, callback=callback_function) 1458 1459 :param callback function: The callback function 1460 for asynchronous request. (optional) 1461 :param str account_id: The external account number (int) or account ID Guid. (required) 1462 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1463 :param CommentsPublish comments_publish: 1464 :return: CommentHistoryResult 1465 If the method is called asynchronously, 1466 returns the request thread. 1467 """ 1468 kwargs['_return_http_data_only'] = True 1469 if kwargs.get('callback'): 1470 return self.create_envelope_comments_with_http_info(account_id, envelope_id, **kwargs) 1471 else: 1472 (data) = self.create_envelope_comments_with_http_info(account_id, envelope_id, **kwargs) 1473 return data 1474 1475 def create_envelope_comments_with_http_info(self, account_id, envelope_id, **kwargs): 1476 """ 1477 Posts a list of comments for authorized user 1478 1479 This method makes a synchronous HTTP request by default. To make an 1480 asynchronous HTTP request, please define a `callback` function 1481 to be invoked when receiving the response. 1482 >>> def callback_function(response): 1483 >>> pprint(response) 1484 >>> 1485 >>> thread = api.create_envelope_comments_with_http_info(account_id, envelope_id, callback=callback_function) 1486 1487 :param callback function: The callback function 1488 for asynchronous request. (optional) 1489 :param str account_id: The external account number (int) or account ID Guid. (required) 1490 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1491 :param CommentsPublish comments_publish: 1492 :return: CommentHistoryResult 1493 If the method is called asynchronously, 1494 returns the request thread. 1495 """ 1496 1497 all_params = ['account_id', 'envelope_id', 'comments_publish'] 1498 all_params.append('callback') 1499 all_params.append('_return_http_data_only') 1500 all_params.append('_preload_content') 1501 all_params.append('_request_timeout') 1502 1503 params = locals() 1504 for key, val in iteritems(params['kwargs']): 1505 if key not in all_params: 1506 raise TypeError( 1507 "Got an unexpected keyword argument '%s'" 1508 " to method create_envelope_comments" % key 1509 ) 1510 params[key] = val 1511 del params['kwargs'] 1512 # verify the required parameter 'account_id' is set 1513 if ('account_id' not in params) or (params['account_id'] is None): 1514 raise ValueError("Missing the required parameter `account_id` when calling `create_envelope_comments`") 1515 # verify the required parameter 'envelope_id' is set 1516 if ('envelope_id' not in params) or (params['envelope_id'] is None): 1517 raise ValueError("Missing the required parameter `envelope_id` when calling `create_envelope_comments`") 1518 1519 1520 collection_formats = {} 1521 1522 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/comments'.replace('{format}', 'json') 1523 path_params = {} 1524 if 'account_id' in params: 1525 path_params['accountId'] = params['account_id'] 1526 if 'envelope_id' in params: 1527 path_params['envelopeId'] = params['envelope_id'] 1528 1529 query_params = {} 1530 1531 header_params = {} 1532 1533 form_params = [] 1534 local_var_files = {} 1535 1536 body_params = None 1537 if 'comments_publish' in params: 1538 body_params = params['comments_publish'] 1539 # HTTP header `Accept` 1540 header_params['Accept'] = self.api_client.\ 1541 select_header_accept(['application/json']) 1542 1543 # Authentication setting 1544 auth_settings = [] 1545 1546 return self.api_client.call_api(resource_path, 'POST', 1547 path_params, 1548 query_params, 1549 header_params, 1550 body=body_params, 1551 post_params=form_params, 1552 files=local_var_files, 1553 response_type='CommentHistoryResult', 1554 auth_settings=auth_settings, 1555 callback=params.get('callback'), 1556 _return_http_data_only=params.get('_return_http_data_only'), 1557 _preload_content=params.get('_preload_content', True), 1558 _request_timeout=params.get('_request_timeout'), 1559 collection_formats=collection_formats) 1560 1561 def create_envelope_recipient_preview(self, account_id, envelope_id, **kwargs): 1562 """ 1563 Provides a URL to start a recipient view of the Envelope UI 1564 This method returns a URL for an envelope recipient preview in the DocuSign UI that you can embed in your application. You use this method to enable the sender to preview the recipients' experience. For more information, see [Preview and Send](https://support.docusign.com/en/guides/ndse-user-guide-send-your-documents). 1565 This method makes a synchronous HTTP request by default. To make an 1566 asynchronous HTTP request, please define a `callback` function 1567 to be invoked when receiving the response. 1568 >>> def callback_function(response): 1569 >>> pprint(response) 1570 >>> 1571 >>> thread = api.create_envelope_recipient_preview(account_id, envelope_id, callback=callback_function) 1572 1573 :param callback function: The callback function 1574 for asynchronous request. (optional) 1575 :param str account_id: The external account number (int) or account ID Guid. (required) 1576 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1577 :param RecipientPreviewRequest recipient_preview_request: 1578 :return: ViewUrl 1579 If the method is called asynchronously, 1580 returns the request thread. 1581 """ 1582 kwargs['_return_http_data_only'] = True 1583 if kwargs.get('callback'): 1584 return self.create_envelope_recipient_preview_with_http_info(account_id, envelope_id, **kwargs) 1585 else: 1586 (data) = self.create_envelope_recipient_preview_with_http_info(account_id, envelope_id, **kwargs) 1587 return data 1588 1589 def create_envelope_recipient_preview_with_http_info(self, account_id, envelope_id, **kwargs): 1590 """ 1591 Provides a URL to start a recipient view of the Envelope UI 1592 This method returns a URL for an envelope recipient preview in the DocuSign UI that you can embed in your application. You use this method to enable the sender to preview the recipients' experience. For more information, see [Preview and Send](https://support.docusign.com/en/guides/ndse-user-guide-send-your-documents). 1593 This method makes a synchronous HTTP request by default. To make an 1594 asynchronous HTTP request, please define a `callback` function 1595 to be invoked when receiving the response. 1596 >>> def callback_function(response): 1597 >>> pprint(response) 1598 >>> 1599 >>> thread = api.create_envelope_recipient_preview_with_http_info(account_id, envelope_id, callback=callback_function) 1600 1601 :param callback function: The callback function 1602 for asynchronous request. (optional) 1603 :param str account_id: The external account number (int) or account ID Guid. (required) 1604 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1605 :param RecipientPreviewRequest recipient_preview_request: 1606 :return: ViewUrl 1607 If the method is called asynchronously, 1608 returns the request thread. 1609 """ 1610 1611 all_params = ['account_id', 'envelope_id', 'recipient_preview_request'] 1612 all_params.append('callback') 1613 all_params.append('_return_http_data_only') 1614 all_params.append('_preload_content') 1615 all_params.append('_request_timeout') 1616 1617 params = locals() 1618 for key, val in iteritems(params['kwargs']): 1619 if key not in all_params: 1620 raise TypeError( 1621 "Got an unexpected keyword argument '%s'" 1622 " to method create_envelope_recipient_preview" % key 1623 ) 1624 params[key] = val 1625 del params['kwargs'] 1626 # verify the required parameter 'account_id' is set 1627 if ('account_id' not in params) or (params['account_id'] is None): 1628 raise ValueError("Missing the required parameter `account_id` when calling `create_envelope_recipient_preview`") 1629 # verify the required parameter 'envelope_id' is set 1630 if ('envelope_id' not in params) or (params['envelope_id'] is None): 1631 raise ValueError("Missing the required parameter `envelope_id` when calling `create_envelope_recipient_preview`") 1632 1633 1634 collection_formats = {} 1635 1636 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/recipient_preview'.replace('{format}', 'json') 1637 path_params = {} 1638 if 'account_id' in params: 1639 path_params['accountId'] = params['account_id'] 1640 if 'envelope_id' in params: 1641 path_params['envelopeId'] = params['envelope_id'] 1642 1643 query_params = {} 1644 1645 header_params = {} 1646 1647 form_params = [] 1648 local_var_files = {} 1649 1650 body_params = None 1651 if 'recipient_preview_request' in params: 1652 body_params = params['recipient_preview_request'] 1653 # HTTP header `Accept` 1654 header_params['Accept'] = self.api_client.\ 1655 select_header_accept(['application/json']) 1656 1657 # Authentication setting 1658 auth_settings = [] 1659 1660 return self.api_client.call_api(resource_path, 'POST', 1661 path_params, 1662 query_params, 1663 header_params, 1664 body=body_params, 1665 post_params=form_params, 1666 files=local_var_files, 1667 response_type='ViewUrl', 1668 auth_settings=auth_settings, 1669 callback=params.get('callback'), 1670 _return_http_data_only=params.get('_return_http_data_only'), 1671 _preload_content=params.get('_preload_content', True), 1672 _request_timeout=params.get('_request_timeout'), 1673 collection_formats=collection_formats) 1674 1675 def create_envelope_recipient_shared_view(self, account_id, envelope_id, **kwargs): 1676 """ 1677 Provides a URL to start a shared recipient view of the Envelope UI 1678 Returns a URL that enables you to embed the DocuSign UI recipient view of a [shared envelope](https://support.docusign.com/en/guides/ndse-admin-guide-share-envelopes) in your applications. This is the view that a user sees of an envelope that a recipient on the same account has shared with them. Due to screen space issues, do not use an `<iframe>` for embedded operations on mobile devices. For iOS devices, DocuSign recommends using a WebView. ### Revoking the URL You can revoke this URL by making a DELETE HTTP request to the URL with no request body. ### Related topics - [Embedded signing and sending](/docs/esign-rest-api/esign101/concepts/embedding/) - [How to send an envelope via your app](/docs/esign-rest-api/how-to/embedded-sending/) - [How to embed the DocuSign UI in your app](/docs/esign-rest-api/how-to/embed-ui/) 1679 This method makes a synchronous HTTP request by default. To make an 1680 asynchronous HTTP request, please define a `callback` function 1681 to be invoked when receiving the response. 1682 >>> def callback_function(response): 1683 >>> pprint(response) 1684 >>> 1685 >>> thread = api.create_envelope_recipient_shared_view(account_id, envelope_id, callback=callback_function) 1686 1687 :param callback function: The callback function 1688 for asynchronous request. (optional) 1689 :param str account_id: The external account number (int) or account ID Guid. (required) 1690 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1691 :param RecipientViewRequest recipient_view_request: 1692 :return: ViewUrl 1693 If the method is called asynchronously, 1694 returns the request thread. 1695 """ 1696 kwargs['_return_http_data_only'] = True 1697 if kwargs.get('callback'): 1698 return self.create_envelope_recipient_shared_view_with_http_info(account_id, envelope_id, **kwargs) 1699 else: 1700 (data) = self.create_envelope_recipient_shared_view_with_http_info(account_id, envelope_id, **kwargs) 1701 return data 1702 1703 def create_envelope_recipient_shared_view_with_http_info(self, account_id, envelope_id, **kwargs): 1704 """ 1705 Provides a URL to start a shared recipient view of the Envelope UI 1706 Returns a URL that enables you to embed the DocuSign UI recipient view of a [shared envelope](https://support.docusign.com/en/guides/ndse-admin-guide-share-envelopes) in your applications. This is the view that a user sees of an envelope that a recipient on the same account has shared with them. Due to screen space issues, do not use an `<iframe>` for embedded operations on mobile devices. For iOS devices, DocuSign recommends using a WebView. ### Revoking the URL You can revoke this URL by making a DELETE HTTP request to the URL with no request body. ### Related topics - [Embedded signing and sending](/docs/esign-rest-api/esign101/concepts/embedding/) - [How to send an envelope via your app](/docs/esign-rest-api/how-to/embedded-sending/) - [How to embed the DocuSign UI in your app](/docs/esign-rest-api/how-to/embed-ui/) 1707 This method makes a synchronous HTTP request by default. To make an 1708 asynchronous HTTP request, please define a `callback` function 1709 to be invoked when receiving the response. 1710 >>> def callback_function(response): 1711 >>> pprint(response) 1712 >>> 1713 >>> thread = api.create_envelope_recipient_shared_view_with_http_info(account_id, envelope_id, callback=callback_function) 1714 1715 :param callback function: The callback function 1716 for asynchronous request. (optional) 1717 :param str account_id: The external account number (int) or account ID Guid. (required) 1718 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1719 :param RecipientViewRequest recipient_view_request: 1720 :return: ViewUrl 1721 If the method is called asynchronously, 1722 returns the request thread. 1723 """ 1724 1725 all_params = ['account_id', 'envelope_id', 'recipient_view_request'] 1726 all_params.append('callback') 1727 all_params.append('_return_http_data_only') 1728 all_params.append('_preload_content') 1729 all_params.append('_request_timeout') 1730 1731 params = locals() 1732 for key, val in iteritems(params['kwargs']): 1733 if key not in all_params: 1734 raise TypeError( 1735 "Got an unexpected keyword argument '%s'" 1736 " to method create_envelope_recipient_shared_view" % key 1737 ) 1738 params[key] = val 1739 del params['kwargs'] 1740 # verify the required parameter 'account_id' is set 1741 if ('account_id' not in params) or (params['account_id'] is None): 1742 raise ValueError("Missing the required parameter `account_id` when calling `create_envelope_recipient_shared_view`") 1743 # verify the required parameter 'envelope_id' is set 1744 if ('envelope_id' not in params) or (params['envelope_id'] is None): 1745 raise ValueError("Missing the required parameter `envelope_id` when calling `create_envelope_recipient_shared_view`") 1746 1747 1748 collection_formats = {} 1749 1750 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/shared'.replace('{format}', 'json') 1751 path_params = {} 1752 if 'account_id' in params: 1753 path_params['accountId'] = params['account_id'] 1754 if 'envelope_id' in params: 1755 path_params['envelopeId'] = params['envelope_id'] 1756 1757 query_params = {} 1758 1759 header_params = {} 1760 1761 form_params = [] 1762 local_var_files = {} 1763 1764 body_params = None 1765 if 'recipient_view_request' in params: 1766 body_params = params['recipient_view_request'] 1767 # HTTP header `Accept` 1768 header_params['Accept'] = self.api_client.\ 1769 select_header_accept(['application/json']) 1770 1771 # Authentication setting 1772 auth_settings = [] 1773 1774 return self.api_client.call_api(resource_path, 'POST', 1775 path_params, 1776 query_params, 1777 header_params, 1778 body=body_params, 1779 post_params=form_params, 1780 files=local_var_files, 1781 response_type='ViewUrl', 1782 auth_settings=auth_settings, 1783 callback=params.get('callback'), 1784 _return_http_data_only=params.get('_return_http_data_only'), 1785 _preload_content=params.get('_preload_content', True), 1786 _request_timeout=params.get('_request_timeout'), 1787 collection_formats=collection_formats) 1788 1789 def create_envelope_transfer_rules(self, account_id, **kwargs): 1790 """ 1791 Add envelope transfer rules to an account. 1792 This method creates an envelope transfer rule. When you create an envelope transfer rule, you specify the following properties: - `eventType` - `fromGroups` - `toUser` - `toFolder` - `carbonCopyOriginalOwner` - `enabled` **Note:** Only Administrators can create envelope transfer rules. In addition, to use envelope transfer rules, the **Transfer Custody** feature must be enabled for your account. 1793 This method makes a synchronous HTTP request by default. To make an 1794 asynchronous HTTP request, please define a `callback` function 1795 to be invoked when receiving the response. 1796 >>> def callback_function(response): 1797 >>> pprint(response) 1798 >>> 1799 >>> thread = api.create_envelope_transfer_rules(account_id, callback=callback_function) 1800 1801 :param callback function: The callback function 1802 for asynchronous request. (optional) 1803 :param str account_id: The external account number (int) or account ID Guid. (required) 1804 :param EnvelopeTransferRuleRequest envelope_transfer_rule_request: 1805 :return: EnvelopeTransferRuleInformation 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.create_envelope_transfer_rules_with_http_info(account_id, **kwargs) 1812 else: 1813 (data) = self.create_envelope_transfer_rules_with_http_info(account_id, **kwargs) 1814 return data 1815 1816 def create_envelope_transfer_rules_with_http_info(self, account_id, **kwargs): 1817 """ 1818 Add envelope transfer rules to an account. 1819 This method creates an envelope transfer rule. When you create an envelope transfer rule, you specify the following properties: - `eventType` - `fromGroups` - `toUser` - `toFolder` - `carbonCopyOriginalOwner` - `enabled` **Note:** Only Administrators can create envelope transfer rules. In addition, to use envelope transfer rules, the **Transfer Custody** feature must be enabled for your account. 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.create_envelope_transfer_rules_with_http_info(account_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 EnvelopeTransferRuleRequest envelope_transfer_rule_request: 1832 :return: EnvelopeTransferRuleInformation 1833 If the method is called asynchronously, 1834 returns the request thread. 1835 """ 1836 1837 all_params = ['account_id', 'envelope_transfer_rule_request'] 1838 all_params.append('callback') 1839 all_params.append('_return_http_data_only') 1840 all_params.append('_preload_content') 1841 all_params.append('_request_timeout') 1842 1843 params = locals() 1844 for key, val in iteritems(params['kwargs']): 1845 if key not in all_params: 1846 raise TypeError( 1847 "Got an unexpected keyword argument '%s'" 1848 " to method create_envelope_transfer_rules" % key 1849 ) 1850 params[key] = val 1851 del params['kwargs'] 1852 # verify the required parameter 'account_id' is set 1853 if ('account_id' not in params) or (params['account_id'] is None): 1854 raise ValueError("Missing the required parameter `account_id` when calling `create_envelope_transfer_rules`") 1855 1856 1857 collection_formats = {} 1858 1859 resource_path = '/v2.1/accounts/{accountId}/envelopes/transfer_rules'.replace('{format}', 'json') 1860 path_params = {} 1861 if 'account_id' in params: 1862 path_params['accountId'] = params['account_id'] 1863 1864 query_params = {} 1865 1866 header_params = {} 1867 1868 form_params = [] 1869 local_var_files = {} 1870 1871 body_params = None 1872 if 'envelope_transfer_rule_request' in params: 1873 body_params = params['envelope_transfer_rule_request'] 1874 # HTTP header `Accept` 1875 header_params['Accept'] = self.api_client.\ 1876 select_header_accept(['application/json']) 1877 1878 # Authentication setting 1879 auth_settings = [] 1880 1881 return self.api_client.call_api(resource_path, 'POST', 1882 path_params, 1883 query_params, 1884 header_params, 1885 body=body_params, 1886 post_params=form_params, 1887 files=local_var_files, 1888 response_type='EnvelopeTransferRuleInformation', 1889 auth_settings=auth_settings, 1890 callback=params.get('callback'), 1891 _return_http_data_only=params.get('_return_http_data_only'), 1892 _preload_content=params.get('_preload_content', True), 1893 _request_timeout=params.get('_request_timeout'), 1894 collection_formats=collection_formats) 1895 1896 def create_envelope_workflow_step_definition(self, account_id, envelope_id, **kwargs): 1897 """ 1898 Creates and adds a new workflow step definition for an envelope's workflow 1899 This method makes a synchronous HTTP request by default. To make an 1900 asynchronous HTTP request, please define a `callback` function 1901 to be invoked when receiving the response. 1902 >>> def callback_function(response): 1903 >>> pprint(response) 1904 >>> 1905 >>> thread = api.create_envelope_workflow_step_definition(account_id, envelope_id, callback=callback_function) 1906 1907 :param callback function: The callback function 1908 for asynchronous request. (optional) 1909 :param str account_id: The external account number (int) or account ID Guid. (required) 1910 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1911 :param WorkflowStep workflow_step: 1912 :return: WorkflowStep 1913 If the method is called asynchronously, 1914 returns the request thread. 1915 """ 1916 kwargs['_return_http_data_only'] = True 1917 if kwargs.get('callback'): 1918 return self.create_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, **kwargs) 1919 else: 1920 (data) = self.create_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, **kwargs) 1921 return data 1922 1923 def create_envelope_workflow_step_definition_with_http_info(self, account_id, envelope_id, **kwargs): 1924 """ 1925 Creates and adds a new workflow step definition for an envelope's workflow 1926 This method makes a synchronous HTTP request by default. To make an 1927 asynchronous HTTP request, please define a `callback` function 1928 to be invoked when receiving the response. 1929 >>> def callback_function(response): 1930 >>> pprint(response) 1931 >>> 1932 >>> thread = api.create_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, callback=callback_function) 1933 1934 :param callback function: The callback function 1935 for asynchronous request. (optional) 1936 :param str account_id: The external account number (int) or account ID Guid. (required) 1937 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1938 :param WorkflowStep workflow_step: 1939 :return: WorkflowStep 1940 If the method is called asynchronously, 1941 returns the request thread. 1942 """ 1943 1944 all_params = ['account_id', 'envelope_id', 'workflow_step'] 1945 all_params.append('callback') 1946 all_params.append('_return_http_data_only') 1947 all_params.append('_preload_content') 1948 all_params.append('_request_timeout') 1949 1950 params = locals() 1951 for key, val in iteritems(params['kwargs']): 1952 if key not in all_params: 1953 raise TypeError( 1954 "Got an unexpected keyword argument '%s'" 1955 " to method create_envelope_workflow_step_definition" % key 1956 ) 1957 params[key] = val 1958 del params['kwargs'] 1959 # verify the required parameter 'account_id' is set 1960 if ('account_id' not in params) or (params['account_id'] is None): 1961 raise ValueError("Missing the required parameter `account_id` when calling `create_envelope_workflow_step_definition`") 1962 # verify the required parameter 'envelope_id' is set 1963 if ('envelope_id' not in params) or (params['envelope_id'] is None): 1964 raise ValueError("Missing the required parameter `envelope_id` when calling `create_envelope_workflow_step_definition`") 1965 1966 1967 collection_formats = {} 1968 1969 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps'.replace('{format}', 'json') 1970 path_params = {} 1971 if 'account_id' in params: 1972 path_params['accountId'] = params['account_id'] 1973 if 'envelope_id' in params: 1974 path_params['envelopeId'] = params['envelope_id'] 1975 1976 query_params = {} 1977 1978 header_params = {} 1979 1980 form_params = [] 1981 local_var_files = {} 1982 1983 body_params = None 1984 if 'workflow_step' in params: 1985 body_params = params['workflow_step'] 1986 # HTTP header `Accept` 1987 header_params['Accept'] = self.api_client.\ 1988 select_header_accept(['application/json']) 1989 1990 # Authentication setting 1991 auth_settings = [] 1992 1993 return self.api_client.call_api(resource_path, 'POST', 1994 path_params, 1995 query_params, 1996 header_params, 1997 body=body_params, 1998 post_params=form_params, 1999 files=local_var_files, 2000 response_type='WorkflowStep', 2001 auth_settings=auth_settings, 2002 callback=params.get('callback'), 2003 _return_http_data_only=params.get('_return_http_data_only'), 2004 _preload_content=params.get('_preload_content', True), 2005 _request_timeout=params.get('_request_timeout'), 2006 collection_formats=collection_formats) 2007 2008 def create_historical_envelope_publish_transaction(self, account_id, **kwargs): 2009 """ 2010 Submits a batch of historical envelopes for republish to an adhoc config. 2011 This method makes a synchronous HTTP request by default. To make an 2012 asynchronous HTTP request, please define a `callback` function 2013 to be invoked when receiving the response. 2014 >>> def callback_function(response): 2015 >>> pprint(response) 2016 >>> 2017 >>> thread = api.create_historical_envelope_publish_transaction(account_id, callback=callback_function) 2018 2019 :param callback function: The callback function 2020 for asynchronous request. (optional) 2021 :param str account_id: The external account number (int) or account ID Guid. (required) 2022 :param ConnectHistoricalEnvelopeRepublish connect_historical_envelope_republish: 2023 :return: EnvelopePublishTransaction 2024 If the method is called asynchronously, 2025 returns the request thread. 2026 """ 2027 kwargs['_return_http_data_only'] = True 2028 if kwargs.get('callback'): 2029 return self.create_historical_envelope_publish_transaction_with_http_info(account_id, **kwargs) 2030 else: 2031 (data) = self.create_historical_envelope_publish_transaction_with_http_info(account_id, **kwargs) 2032 return data 2033 2034 def create_historical_envelope_publish_transaction_with_http_info(self, account_id, **kwargs): 2035 """ 2036 Submits a batch of historical envelopes for republish to an adhoc config. 2037 This method makes a synchronous HTTP request by default. To make an 2038 asynchronous HTTP request, please define a `callback` function 2039 to be invoked when receiving the response. 2040 >>> def callback_function(response): 2041 >>> pprint(response) 2042 >>> 2043 >>> thread = api.create_historical_envelope_publish_transaction_with_http_info(account_id, callback=callback_function) 2044 2045 :param callback function: The callback function 2046 for asynchronous request. (optional) 2047 :param str account_id: The external account number (int) or account ID Guid. (required) 2048 :param ConnectHistoricalEnvelopeRepublish connect_historical_envelope_republish: 2049 :return: EnvelopePublishTransaction 2050 If the method is called asynchronously, 2051 returns the request thread. 2052 """ 2053 2054 all_params = ['account_id', 'connect_historical_envelope_republish'] 2055 all_params.append('callback') 2056 all_params.append('_return_http_data_only') 2057 all_params.append('_preload_content') 2058 all_params.append('_request_timeout') 2059 2060 params = locals() 2061 for key, val in iteritems(params['kwargs']): 2062 if key not in all_params: 2063 raise TypeError( 2064 "Got an unexpected keyword argument '%s'" 2065 " to method create_historical_envelope_publish_transaction" % key 2066 ) 2067 params[key] = val 2068 del params['kwargs'] 2069 # verify the required parameter 'account_id' is set 2070 if ('account_id' not in params) or (params['account_id'] is None): 2071 raise ValueError("Missing the required parameter `account_id` when calling `create_historical_envelope_publish_transaction`") 2072 2073 2074 collection_formats = {} 2075 2076 resource_path = '/v2.1/accounts/{accountId}/connect/envelopes/publish/historical'.replace('{format}', 'json') 2077 path_params = {} 2078 if 'account_id' in params: 2079 path_params['accountId'] = params['account_id'] 2080 2081 query_params = {} 2082 2083 header_params = {} 2084 2085 form_params = [] 2086 local_var_files = {} 2087 2088 body_params = None 2089 if 'connect_historical_envelope_republish' in params: 2090 body_params = params['connect_historical_envelope_republish'] 2091 # HTTP header `Accept` 2092 header_params['Accept'] = self.api_client.\ 2093 select_header_accept(['application/json']) 2094 2095 # Authentication setting 2096 auth_settings = [] 2097 2098 return self.api_client.call_api(resource_path, 'POST', 2099 path_params, 2100 query_params, 2101 header_params, 2102 body=body_params, 2103 post_params=form_params, 2104 files=local_var_files, 2105 response_type='EnvelopePublishTransaction', 2106 auth_settings=auth_settings, 2107 callback=params.get('callback'), 2108 _return_http_data_only=params.get('_return_http_data_only'), 2109 _preload_content=params.get('_preload_content', True), 2110 _request_timeout=params.get('_request_timeout'), 2111 collection_formats=collection_formats) 2112 2113 def create_lock(self, account_id, envelope_id, **kwargs): 2114 """ 2115 Lock an envelope. 2116 Locks the specified envelope, and sets the time until the lock expires, to prevent other users or recipients from accessing and changing the envelope. ###### Note: Users must have envelope locking capability enabled to use this function (userSetting `canLockEnvelopes` must be set to true for the user). 2117 This method makes a synchronous HTTP request by default. To make an 2118 asynchronous HTTP request, please define a `callback` function 2119 to be invoked when receiving the response. 2120 >>> def callback_function(response): 2121 >>> pprint(response) 2122 >>> 2123 >>> thread = api.create_lock(account_id, envelope_id, callback=callback_function) 2124 2125 :param callback function: The callback function 2126 for asynchronous request. (optional) 2127 :param str account_id: The external account number (int) or account ID Guid. (required) 2128 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2129 :param LockRequest lock_request: 2130 :return: LockInformation 2131 If the method is called asynchronously, 2132 returns the request thread. 2133 """ 2134 kwargs['_return_http_data_only'] = True 2135 if kwargs.get('callback'): 2136 return self.create_lock_with_http_info(account_id, envelope_id, **kwargs) 2137 else: 2138 (data) = self.create_lock_with_http_info(account_id, envelope_id, **kwargs) 2139 return data 2140 2141 def create_lock_with_http_info(self, account_id, envelope_id, **kwargs): 2142 """ 2143 Lock an envelope. 2144 Locks the specified envelope, and sets the time until the lock expires, to prevent other users or recipients from accessing and changing the envelope. ###### Note: Users must have envelope locking capability enabled to use this function (userSetting `canLockEnvelopes` must be set to true for the user). 2145 This method makes a synchronous HTTP request by default. To make an 2146 asynchronous HTTP request, please define a `callback` function 2147 to be invoked when receiving the response. 2148 >>> def callback_function(response): 2149 >>> pprint(response) 2150 >>> 2151 >>> thread = api.create_lock_with_http_info(account_id, envelope_id, callback=callback_function) 2152 2153 :param callback function: The callback function 2154 for asynchronous request. (optional) 2155 :param str account_id: The external account number (int) or account ID Guid. (required) 2156 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2157 :param LockRequest lock_request: 2158 :return: LockInformation 2159 If the method is called asynchronously, 2160 returns the request thread. 2161 """ 2162 2163 all_params = ['account_id', 'envelope_id', 'lock_request'] 2164 all_params.append('callback') 2165 all_params.append('_return_http_data_only') 2166 all_params.append('_preload_content') 2167 all_params.append('_request_timeout') 2168 2169 params = locals() 2170 for key, val in iteritems(params['kwargs']): 2171 if key not in all_params: 2172 raise TypeError( 2173 "Got an unexpected keyword argument '%s'" 2174 " to method create_lock" % key 2175 ) 2176 params[key] = val 2177 del params['kwargs'] 2178 # verify the required parameter 'account_id' is set 2179 if ('account_id' not in params) or (params['account_id'] is None): 2180 raise ValueError("Missing the required parameter `account_id` when calling `create_lock`") 2181 # verify the required parameter 'envelope_id' is set 2182 if ('envelope_id' not in params) or (params['envelope_id'] is None): 2183 raise ValueError("Missing the required parameter `envelope_id` when calling `create_lock`") 2184 2185 2186 collection_formats = {} 2187 2188 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/lock'.replace('{format}', 'json') 2189 path_params = {} 2190 if 'account_id' in params: 2191 path_params['accountId'] = params['account_id'] 2192 if 'envelope_id' in params: 2193 path_params['envelopeId'] = params['envelope_id'] 2194 2195 query_params = {} 2196 2197 header_params = {} 2198 2199 form_params = [] 2200 local_var_files = {} 2201 2202 body_params = None 2203 if 'lock_request' in params: 2204 body_params = params['lock_request'] 2205 # HTTP header `Accept` 2206 header_params['Accept'] = self.api_client.\ 2207 select_header_accept(['application/json']) 2208 2209 # Authentication setting 2210 auth_settings = [] 2211 2212 return self.api_client.call_api(resource_path, 'POST', 2213 path_params, 2214 query_params, 2215 header_params, 2216 body=body_params, 2217 post_params=form_params, 2218 files=local_var_files, 2219 response_type='LockInformation', 2220 auth_settings=auth_settings, 2221 callback=params.get('callback'), 2222 _return_http_data_only=params.get('_return_http_data_only'), 2223 _preload_content=params.get('_preload_content', True), 2224 _request_timeout=params.get('_request_timeout'), 2225 collection_formats=collection_formats) 2226 2227 def create_recipient(self, account_id, envelope_id, **kwargs): 2228 """ 2229 Adds one or more recipients to an envelope. 2230 Adds one or more recipients to an envelope. For an in process envelope, one that has been sent and has not been completed or voided, an email is sent to a new recipient when they are reached in the routing order. If the new recipient's routing order is before or the same as the envelope's next recipient, an email is only sent if the optional `resend_envelope` query string is set to **true**. 2231 This method makes a synchronous HTTP request by default. To make an 2232 asynchronous HTTP request, please define a `callback` function 2233 to be invoked when receiving the response. 2234 >>> def callback_function(response): 2235 >>> pprint(response) 2236 >>> 2237 >>> thread = api.create_recipient(account_id, envelope_id, callback=callback_function) 2238 2239 :param callback function: The callback function 2240 for asynchronous request. (optional) 2241 :param str account_id: The external account number (int) or account ID Guid. (required) 2242 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2243 :param str resend_envelope: When set to **true**, resends the envelope if the new recipient's routing order is before or the same as the envelope's next recipient. 2244 :param Recipients recipients: 2245 :return: Recipients 2246 If the method is called asynchronously, 2247 returns the request thread. 2248 """ 2249 kwargs['_return_http_data_only'] = True 2250 if kwargs.get('callback'): 2251 return self.create_recipient_with_http_info(account_id, envelope_id, **kwargs) 2252 else: 2253 (data) = self.create_recipient_with_http_info(account_id, envelope_id, **kwargs) 2254 return data 2255 2256 def create_recipient_with_http_info(self, account_id, envelope_id, **kwargs): 2257 """ 2258 Adds one or more recipients to an envelope. 2259 Adds one or more recipients to an envelope. For an in process envelope, one that has been sent and has not been completed or voided, an email is sent to a new recipient when they are reached in the routing order. If the new recipient's routing order is before or the same as the envelope's next recipient, an email is only sent if the optional `resend_envelope` query string is set to **true**. 2260 This method makes a synchronous HTTP request by default. To make an 2261 asynchronous HTTP request, please define a `callback` function 2262 to be invoked when receiving the response. 2263 >>> def callback_function(response): 2264 >>> pprint(response) 2265 >>> 2266 >>> thread = api.create_recipient_with_http_info(account_id, envelope_id, callback=callback_function) 2267 2268 :param callback function: The callback function 2269 for asynchronous request. (optional) 2270 :param str account_id: The external account number (int) or account ID Guid. (required) 2271 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2272 :param str resend_envelope: When set to **true**, resends the envelope if the new recipient's routing order is before or the same as the envelope's next recipient. 2273 :param Recipients recipients: 2274 :return: Recipients 2275 If the method is called asynchronously, 2276 returns the request thread. 2277 """ 2278 2279 all_params = ['account_id', 'envelope_id', 'resend_envelope', 'recipients'] 2280 all_params.append('callback') 2281 all_params.append('_return_http_data_only') 2282 all_params.append('_preload_content') 2283 all_params.append('_request_timeout') 2284 2285 params = locals() 2286 for key, val in iteritems(params['kwargs']): 2287 if key not in all_params: 2288 raise TypeError( 2289 "Got an unexpected keyword argument '%s'" 2290 " to method create_recipient" % key 2291 ) 2292 params[key] = val 2293 del params['kwargs'] 2294 # verify the required parameter 'account_id' is set 2295 if ('account_id' not in params) or (params['account_id'] is None): 2296 raise ValueError("Missing the required parameter `account_id` when calling `create_recipient`") 2297 # verify the required parameter 'envelope_id' is set 2298 if ('envelope_id' not in params) or (params['envelope_id'] is None): 2299 raise ValueError("Missing the required parameter `envelope_id` when calling `create_recipient`") 2300 2301 2302 collection_formats = {} 2303 2304 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients'.replace('{format}', 'json') 2305 path_params = {} 2306 if 'account_id' in params: 2307 path_params['accountId'] = params['account_id'] 2308 if 'envelope_id' in params: 2309 path_params['envelopeId'] = params['envelope_id'] 2310 2311 query_params = {} 2312 if 'resend_envelope' in params: 2313 query_params['resend_envelope'] = params['resend_envelope'] 2314 2315 header_params = {} 2316 2317 form_params = [] 2318 local_var_files = {} 2319 2320 body_params = None 2321 if 'recipients' in params: 2322 body_params = params['recipients'] 2323 # HTTP header `Accept` 2324 header_params['Accept'] = self.api_client.\ 2325 select_header_accept(['application/json']) 2326 2327 # Authentication setting 2328 auth_settings = [] 2329 2330 return self.api_client.call_api(resource_path, 'POST', 2331 path_params, 2332 query_params, 2333 header_params, 2334 body=body_params, 2335 post_params=form_params, 2336 files=local_var_files, 2337 response_type='Recipients', 2338 auth_settings=auth_settings, 2339 callback=params.get('callback'), 2340 _return_http_data_only=params.get('_return_http_data_only'), 2341 _preload_content=params.get('_preload_content', True), 2342 _request_timeout=params.get('_request_timeout'), 2343 collection_formats=collection_formats) 2344 2345 def create_recipient_manual_review_view(self, account_id, envelope_id, recipient_id, **kwargs): 2346 """ 2347 Provides a link to access the Identity manual review related to a recipient. 2348 This method returns the URL of the page that allows a sender to [manually review](https://support.docusign.com/en/guides/ndse-user-guide-send-documents-with-id-verification) the ID of a recipient. 2349 This method makes a synchronous HTTP request by default. To make an 2350 asynchronous HTTP request, please define a `callback` function 2351 to be invoked when receiving the response. 2352 >>> def callback_function(response): 2353 >>> pprint(response) 2354 >>> 2355 >>> thread = api.create_recipient_manual_review_view(account_id, envelope_id, recipient_id, callback=callback_function) 2356 2357 :param callback function: The callback function 2358 for asynchronous request. (optional) 2359 :param str account_id: The external account number (int) or account ID Guid. (required) 2360 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2361 :param str recipient_id: The ID of the recipient being accessed. (required) 2362 :return: ViewUrl 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.create_recipient_manual_review_view_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 2369 else: 2370 (data) = self.create_recipient_manual_review_view_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 2371 return data 2372 2373 def create_recipient_manual_review_view_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 2374 """ 2375 Provides a link to access the Identity manual review related to a recipient. 2376 This method returns the URL of the page that allows a sender to [manually review](https://support.docusign.com/en/guides/ndse-user-guide-send-documents-with-id-verification) the ID of a recipient. 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.create_recipient_manual_review_view_with_http_info(account_id, envelope_id, recipient_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 str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2389 :param str recipient_id: The ID of the recipient being accessed. (required) 2390 :return: ViewUrl 2391 If the method is called asynchronously, 2392 returns the request thread. 2393 """ 2394 2395 all_params = ['account_id', 'envelope_id', 'recipient_id'] 2396 all_params.append('callback') 2397 all_params.append('_return_http_data_only') 2398 all_params.append('_preload_content') 2399 all_params.append('_request_timeout') 2400 2401 params = locals() 2402 for key, val in iteritems(params['kwargs']): 2403 if key not in all_params: 2404 raise TypeError( 2405 "Got an unexpected keyword argument '%s'" 2406 " to method create_recipient_manual_review_view" % key 2407 ) 2408 params[key] = val 2409 del params['kwargs'] 2410 # verify the required parameter 'account_id' is set 2411 if ('account_id' not in params) or (params['account_id'] is None): 2412 raise ValueError("Missing the required parameter `account_id` when calling `create_recipient_manual_review_view`") 2413 # verify the required parameter 'envelope_id' is set 2414 if ('envelope_id' not in params) or (params['envelope_id'] is None): 2415 raise ValueError("Missing the required parameter `envelope_id` when calling `create_recipient_manual_review_view`") 2416 # verify the required parameter 'recipient_id' is set 2417 if ('recipient_id' not in params) or (params['recipient_id'] is None): 2418 raise ValueError("Missing the required parameter `recipient_id` when calling `create_recipient_manual_review_view`") 2419 2420 2421 collection_formats = {} 2422 2423 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/views/identity_manual_review'.replace('{format}', 'json') 2424 path_params = {} 2425 if 'account_id' in params: 2426 path_params['accountId'] = params['account_id'] 2427 if 'envelope_id' in params: 2428 path_params['envelopeId'] = params['envelope_id'] 2429 if 'recipient_id' in params: 2430 path_params['recipientId'] = params['recipient_id'] 2431 2432 query_params = {} 2433 2434 header_params = {} 2435 2436 form_params = [] 2437 local_var_files = {} 2438 2439 body_params = None 2440 # HTTP header `Accept` 2441 header_params['Accept'] = self.api_client.\ 2442 select_header_accept(['application/json']) 2443 2444 # Authentication setting 2445 auth_settings = [] 2446 2447 return self.api_client.call_api(resource_path, 'POST', 2448 path_params, 2449 query_params, 2450 header_params, 2451 body=body_params, 2452 post_params=form_params, 2453 files=local_var_files, 2454 response_type='ViewUrl', 2455 auth_settings=auth_settings, 2456 callback=params.get('callback'), 2457 _return_http_data_only=params.get('_return_http_data_only'), 2458 _preload_content=params.get('_preload_content', True), 2459 _request_timeout=params.get('_request_timeout'), 2460 collection_formats=collection_formats) 2461 2462 def create_recipient_proof_file_link(self, account_id, envelope_id, recipient_id, **kwargs): 2463 """ 2464 Returns a link to access to the identity events stored in the proof service related to this recipient. 2465 2466 This method makes a synchronous HTTP request by default. To make an 2467 asynchronous HTTP request, please define a `callback` function 2468 to be invoked when receiving the response. 2469 >>> def callback_function(response): 2470 >>> pprint(response) 2471 >>> 2472 >>> thread = api.create_recipient_proof_file_link(account_id, envelope_id, recipient_id, callback=callback_function) 2473 2474 :param callback function: The callback function 2475 for asynchronous request. (optional) 2476 :param str account_id: The external account number (int) or account ID Guid. (required) 2477 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2478 :param str recipient_id: The ID of the recipient being accessed. (required) 2479 :return: IdEvidenceViewLink 2480 If the method is called asynchronously, 2481 returns the request thread. 2482 """ 2483 kwargs['_return_http_data_only'] = True 2484 if kwargs.get('callback'): 2485 return self.create_recipient_proof_file_link_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 2486 else: 2487 (data) = self.create_recipient_proof_file_link_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 2488 return data 2489 2490 def create_recipient_proof_file_link_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 2491 """ 2492 Returns a link to access to the identity events stored in the proof service related to this recipient. 2493 2494 This method makes a synchronous HTTP request by default. To make an 2495 asynchronous HTTP request, please define a `callback` function 2496 to be invoked when receiving the response. 2497 >>> def callback_function(response): 2498 >>> pprint(response) 2499 >>> 2500 >>> thread = api.create_recipient_proof_file_link_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 2501 2502 :param callback function: The callback function 2503 for asynchronous request. (optional) 2504 :param str account_id: The external account number (int) or account ID Guid. (required) 2505 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2506 :param str recipient_id: The ID of the recipient being accessed. (required) 2507 :return: IdEvidenceViewLink 2508 If the method is called asynchronously, 2509 returns the request thread. 2510 """ 2511 2512 all_params = ['account_id', 'envelope_id', 'recipient_id'] 2513 all_params.append('callback') 2514 all_params.append('_return_http_data_only') 2515 all_params.append('_preload_content') 2516 all_params.append('_request_timeout') 2517 2518 params = locals() 2519 for key, val in iteritems(params['kwargs']): 2520 if key not in all_params: 2521 raise TypeError( 2522 "Got an unexpected keyword argument '%s'" 2523 " to method create_recipient_proof_file_link" % key 2524 ) 2525 params[key] = val 2526 del params['kwargs'] 2527 # verify the required parameter 'account_id' is set 2528 if ('account_id' not in params) or (params['account_id'] is None): 2529 raise ValueError("Missing the required parameter `account_id` when calling `create_recipient_proof_file_link`") 2530 # verify the required parameter 'envelope_id' is set 2531 if ('envelope_id' not in params) or (params['envelope_id'] is None): 2532 raise ValueError("Missing the required parameter `envelope_id` when calling `create_recipient_proof_file_link`") 2533 # verify the required parameter 'recipient_id' is set 2534 if ('recipient_id' not in params) or (params['recipient_id'] is None): 2535 raise ValueError("Missing the required parameter `recipient_id` when calling `create_recipient_proof_file_link`") 2536 2537 2538 collection_formats = {} 2539 2540 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/identity_proof'.replace('{format}', 'json') 2541 path_params = {} 2542 if 'account_id' in params: 2543 path_params['accountId'] = params['account_id'] 2544 if 'envelope_id' in params: 2545 path_params['envelopeId'] = params['envelope_id'] 2546 if 'recipient_id' in params: 2547 path_params['recipientId'] = params['recipient_id'] 2548 2549 query_params = {} 2550 2551 header_params = {} 2552 2553 form_params = [] 2554 local_var_files = {} 2555 2556 body_params = None 2557 # HTTP header `Accept` 2558 header_params['Accept'] = self.api_client.\ 2559 select_header_accept(['application/json']) 2560 2561 # Authentication setting 2562 auth_settings = [] 2563 2564 return self.api_client.call_api(resource_path, 'POST', 2565 path_params, 2566 query_params, 2567 header_params, 2568 body=body_params, 2569 post_params=form_params, 2570 files=local_var_files, 2571 response_type='IdEvidenceViewLink', 2572 auth_settings=auth_settings, 2573 callback=params.get('callback'), 2574 _return_http_data_only=params.get('_return_http_data_only'), 2575 _preload_content=params.get('_preload_content', True), 2576 _request_timeout=params.get('_request_timeout'), 2577 collection_formats=collection_formats) 2578 2579 def create_recipient_proof_file_resource_token(self, account_id, envelope_id, recipient_id, **kwargs): 2580 """ 2581 Returns a resource token to get access to the identity events stored in the proof service related to this recipient. 2582 Creates a resource token for a sender. This token allows a sender to return identification data for a recipient using the [ID Evidence API](/docs/idevidence-api/). 2583 This method makes a synchronous HTTP request by default. To make an 2584 asynchronous HTTP request, please define a `callback` function 2585 to be invoked when receiving the response. 2586 >>> def callback_function(response): 2587 >>> pprint(response) 2588 >>> 2589 >>> thread = api.create_recipient_proof_file_resource_token(account_id, envelope_id, recipient_id, callback=callback_function) 2590 2591 :param callback function: The callback function 2592 for asynchronous request. (optional) 2593 :param str account_id: The external account number (int) or account ID Guid. (required) 2594 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2595 :param str recipient_id: The ID of the recipient being accessed. (required) 2596 :param str token_scopes: 2597 :return: IdEvidenceResourceToken 2598 If the method is called asynchronously, 2599 returns the request thread. 2600 """ 2601 kwargs['_return_http_data_only'] = True 2602 if kwargs.get('callback'): 2603 return self.create_recipient_proof_file_resource_token_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 2604 else: 2605 (data) = self.create_recipient_proof_file_resource_token_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 2606 return data 2607 2608 def create_recipient_proof_file_resource_token_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 2609 """ 2610 Returns a resource token to get access to the identity events stored in the proof service related to this recipient. 2611 Creates a resource token for a sender. This token allows a sender to return identification data for a recipient using the [ID Evidence API](/docs/idevidence-api/). 2612 This method makes a synchronous HTTP request by default. To make an 2613 asynchronous HTTP request, please define a `callback` function 2614 to be invoked when receiving the response. 2615 >>> def callback_function(response): 2616 >>> pprint(response) 2617 >>> 2618 >>> thread = api.create_recipient_proof_file_resource_token_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 2619 2620 :param callback function: The callback function 2621 for asynchronous request. (optional) 2622 :param str account_id: The external account number (int) or account ID Guid. (required) 2623 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2624 :param str recipient_id: The ID of the recipient being accessed. (required) 2625 :param str token_scopes: 2626 :return: IdEvidenceResourceToken 2627 If the method is called asynchronously, 2628 returns the request thread. 2629 """ 2630 2631 all_params = ['account_id', 'envelope_id', 'recipient_id', 'token_scopes'] 2632 all_params.append('callback') 2633 all_params.append('_return_http_data_only') 2634 all_params.append('_preload_content') 2635 all_params.append('_request_timeout') 2636 2637 params = locals() 2638 for key, val in iteritems(params['kwargs']): 2639 if key not in all_params: 2640 raise TypeError( 2641 "Got an unexpected keyword argument '%s'" 2642 " to method create_recipient_proof_file_resource_token" % key 2643 ) 2644 params[key] = val 2645 del params['kwargs'] 2646 # verify the required parameter 'account_id' is set 2647 if ('account_id' not in params) or (params['account_id'] is None): 2648 raise ValueError("Missing the required parameter `account_id` when calling `create_recipient_proof_file_resource_token`") 2649 # verify the required parameter 'envelope_id' is set 2650 if ('envelope_id' not in params) or (params['envelope_id'] is None): 2651 raise ValueError("Missing the required parameter `envelope_id` when calling `create_recipient_proof_file_resource_token`") 2652 # verify the required parameter 'recipient_id' is set 2653 if ('recipient_id' not in params) or (params['recipient_id'] is None): 2654 raise ValueError("Missing the required parameter `recipient_id` when calling `create_recipient_proof_file_resource_token`") 2655 2656 2657 collection_formats = {} 2658 2659 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/identity_proof_token'.replace('{format}', 'json') 2660 path_params = {} 2661 if 'account_id' in params: 2662 path_params['accountId'] = params['account_id'] 2663 if 'envelope_id' in params: 2664 path_params['envelopeId'] = params['envelope_id'] 2665 if 'recipient_id' in params: 2666 path_params['recipientId'] = params['recipient_id'] 2667 2668 query_params = {} 2669 if 'token_scopes' in params: 2670 query_params['token_scopes'] = params['token_scopes'] 2671 2672 header_params = {} 2673 2674 form_params = [] 2675 local_var_files = {} 2676 2677 body_params = None 2678 # HTTP header `Accept` 2679 header_params['Accept'] = self.api_client.\ 2680 select_header_accept(['application/json']) 2681 2682 # Authentication setting 2683 auth_settings = [] 2684 2685 return self.api_client.call_api(resource_path, 'POST', 2686 path_params, 2687 query_params, 2688 header_params, 2689 body=body_params, 2690 post_params=form_params, 2691 files=local_var_files, 2692 response_type='IdEvidenceResourceToken', 2693 auth_settings=auth_settings, 2694 callback=params.get('callback'), 2695 _return_http_data_only=params.get('_return_http_data_only'), 2696 _preload_content=params.get('_preload_content', True), 2697 _request_timeout=params.get('_request_timeout'), 2698 collection_formats=collection_formats) 2699 2700 def create_recipient_view(self, account_id, envelope_id, **kwargs): 2701 """ 2702 Returns a URL to the recipient view UI. 2703 Returns a URL that allows you to embed the recipient view of the DocuSign UI in your applications. This call cannot be used to view draft envelopes, since those envelopes have not been sent. Important: iFrames should not be used for embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends using a WebView. An entry is added into the Security Level section of the DocuSign Certificate of Completion that reflects the `securityDomain` and `authenticationMethod` properties used to verify the user identity. 2704 This method makes a synchronous HTTP request by default. To make an 2705 asynchronous HTTP request, please define a `callback` function 2706 to be invoked when receiving the response. 2707 >>> def callback_function(response): 2708 >>> pprint(response) 2709 >>> 2710 >>> thread = api.create_recipient_view(account_id, envelope_id, callback=callback_function) 2711 2712 :param callback function: The callback function 2713 for asynchronous request. (optional) 2714 :param str account_id: The external account number (int) or account ID Guid. (required) 2715 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2716 :param RecipientViewRequest recipient_view_request: 2717 :return: ViewUrl 2718 If the method is called asynchronously, 2719 returns the request thread. 2720 """ 2721 kwargs['_return_http_data_only'] = True 2722 if kwargs.get('callback'): 2723 return self.create_recipient_view_with_http_info(account_id, envelope_id, **kwargs) 2724 else: 2725 (data) = self.create_recipient_view_with_http_info(account_id, envelope_id, **kwargs) 2726 return data 2727 2728 def create_recipient_view_with_http_info(self, account_id, envelope_id, **kwargs): 2729 """ 2730 Returns a URL to the recipient view UI. 2731 Returns a URL that allows you to embed the recipient view of the DocuSign UI in your applications. This call cannot be used to view draft envelopes, since those envelopes have not been sent. Important: iFrames should not be used for embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends using a WebView. An entry is added into the Security Level section of the DocuSign Certificate of Completion that reflects the `securityDomain` and `authenticationMethod` properties used to verify the user identity. 2732 This method makes a synchronous HTTP request by default. To make an 2733 asynchronous HTTP request, please define a `callback` function 2734 to be invoked when receiving the response. 2735 >>> def callback_function(response): 2736 >>> pprint(response) 2737 >>> 2738 >>> thread = api.create_recipient_view_with_http_info(account_id, envelope_id, callback=callback_function) 2739 2740 :param callback function: The callback function 2741 for asynchronous request. (optional) 2742 :param str account_id: The external account number (int) or account ID Guid. (required) 2743 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2744 :param RecipientViewRequest recipient_view_request: 2745 :return: ViewUrl 2746 If the method is called asynchronously, 2747 returns the request thread. 2748 """ 2749 2750 all_params = ['account_id', 'envelope_id', 'recipient_view_request'] 2751 all_params.append('callback') 2752 all_params.append('_return_http_data_only') 2753 all_params.append('_preload_content') 2754 all_params.append('_request_timeout') 2755 2756 params = locals() 2757 for key, val in iteritems(params['kwargs']): 2758 if key not in all_params: 2759 raise TypeError( 2760 "Got an unexpected keyword argument '%s'" 2761 " to method create_recipient_view" % key 2762 ) 2763 params[key] = val 2764 del params['kwargs'] 2765 # verify the required parameter 'account_id' is set 2766 if ('account_id' not in params) or (params['account_id'] is None): 2767 raise ValueError("Missing the required parameter `account_id` when calling `create_recipient_view`") 2768 # verify the required parameter 'envelope_id' is set 2769 if ('envelope_id' not in params) or (params['envelope_id'] is None): 2770 raise ValueError("Missing the required parameter `envelope_id` when calling `create_recipient_view`") 2771 2772 2773 collection_formats = {} 2774 2775 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/recipient'.replace('{format}', 'json') 2776 path_params = {} 2777 if 'account_id' in params: 2778 path_params['accountId'] = params['account_id'] 2779 if 'envelope_id' in params: 2780 path_params['envelopeId'] = params['envelope_id'] 2781 2782 query_params = {} 2783 2784 header_params = {} 2785 2786 form_params = [] 2787 local_var_files = {} 2788 2789 body_params = None 2790 if 'recipient_view_request' in params: 2791 body_params = params['recipient_view_request'] 2792 # HTTP header `Accept` 2793 header_params['Accept'] = self.api_client.\ 2794 select_header_accept(['application/json']) 2795 2796 # Authentication setting 2797 auth_settings = [] 2798 2799 return self.api_client.call_api(resource_path, 'POST', 2800 path_params, 2801 query_params, 2802 header_params, 2803 body=body_params, 2804 post_params=form_params, 2805 files=local_var_files, 2806 response_type='ViewUrl', 2807 auth_settings=auth_settings, 2808 callback=params.get('callback'), 2809 _return_http_data_only=params.get('_return_http_data_only'), 2810 _preload_content=params.get('_preload_content', True), 2811 _request_timeout=params.get('_request_timeout'), 2812 collection_formats=collection_formats) 2813 2814 def create_responsive_html_preview(self, account_id, envelope_id, **kwargs): 2815 """ 2816 Get Responsive HTML Preview for all documents in an envelope. 2817 Creates a preview of the [responsive](/docs/esign-rest-api/esign101/concepts/responsive/), HTML versions of all of the documents in an envelope. This method enables you to preview the PDF document conversions to responsive HTML across device types prior to sending. The request body is a `documentHtmlDefinition` object, which holds the responsive signing parameters that define how to generate the HTML version of the documents. 2818 This method makes a synchronous HTTP request by default. To make an 2819 asynchronous HTTP request, please define a `callback` function 2820 to be invoked when receiving the response. 2821 >>> def callback_function(response): 2822 >>> pprint(response) 2823 >>> 2824 >>> thread = api.create_responsive_html_preview(account_id, envelope_id, callback=callback_function) 2825 2826 :param callback function: The callback function 2827 for asynchronous request. (optional) 2828 :param str account_id: The external account number (int) or account ID Guid. (required) 2829 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2830 :param DocumentHtmlDefinition document_html_definition: 2831 :return: DocumentHtmlDefinitions 2832 If the method is called asynchronously, 2833 returns the request thread. 2834 """ 2835 kwargs['_return_http_data_only'] = True 2836 if kwargs.get('callback'): 2837 return self.create_responsive_html_preview_with_http_info(account_id, envelope_id, **kwargs) 2838 else: 2839 (data) = self.create_responsive_html_preview_with_http_info(account_id, envelope_id, **kwargs) 2840 return data 2841 2842 def create_responsive_html_preview_with_http_info(self, account_id, envelope_id, **kwargs): 2843 """ 2844 Get Responsive HTML Preview for all documents in an envelope. 2845 Creates a preview of the [responsive](/docs/esign-rest-api/esign101/concepts/responsive/), HTML versions of all of the documents in an envelope. This method enables you to preview the PDF document conversions to responsive HTML across device types prior to sending. The request body is a `documentHtmlDefinition` object, which holds the responsive signing parameters that define how to generate the HTML version of the documents. 2846 This method makes a synchronous HTTP request by default. To make an 2847 asynchronous HTTP request, please define a `callback` function 2848 to be invoked when receiving the response. 2849 >>> def callback_function(response): 2850 >>> pprint(response) 2851 >>> 2852 >>> thread = api.create_responsive_html_preview_with_http_info(account_id, envelope_id, callback=callback_function) 2853 2854 :param callback function: The callback function 2855 for asynchronous request. (optional) 2856 :param str account_id: The external account number (int) or account ID Guid. (required) 2857 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2858 :param DocumentHtmlDefinition document_html_definition: 2859 :return: DocumentHtmlDefinitions 2860 If the method is called asynchronously, 2861 returns the request thread. 2862 """ 2863 2864 all_params = ['account_id', 'envelope_id', 'document_html_definition'] 2865 all_params.append('callback') 2866 all_params.append('_return_http_data_only') 2867 all_params.append('_preload_content') 2868 all_params.append('_request_timeout') 2869 2870 params = locals() 2871 for key, val in iteritems(params['kwargs']): 2872 if key not in all_params: 2873 raise TypeError( 2874 "Got an unexpected keyword argument '%s'" 2875 " to method create_responsive_html_preview" % key 2876 ) 2877 params[key] = val 2878 del params['kwargs'] 2879 # verify the required parameter 'account_id' is set 2880 if ('account_id' not in params) or (params['account_id'] is None): 2881 raise ValueError("Missing the required parameter `account_id` when calling `create_responsive_html_preview`") 2882 # verify the required parameter 'envelope_id' is set 2883 if ('envelope_id' not in params) or (params['envelope_id'] is None): 2884 raise ValueError("Missing the required parameter `envelope_id` when calling `create_responsive_html_preview`") 2885 2886 2887 collection_formats = {} 2888 2889 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/responsive_html_preview'.replace('{format}', 'json') 2890 path_params = {} 2891 if 'account_id' in params: 2892 path_params['accountId'] = params['account_id'] 2893 if 'envelope_id' in params: 2894 path_params['envelopeId'] = params['envelope_id'] 2895 2896 query_params = {} 2897 2898 header_params = {} 2899 2900 form_params = [] 2901 local_var_files = {} 2902 2903 body_params = None 2904 if 'document_html_definition' in params: 2905 body_params = params['document_html_definition'] 2906 # HTTP header `Accept` 2907 header_params['Accept'] = self.api_client.\ 2908 select_header_accept(['application/json']) 2909 2910 # Authentication setting 2911 auth_settings = [] 2912 2913 return self.api_client.call_api(resource_path, 'POST', 2914 path_params, 2915 query_params, 2916 header_params, 2917 body=body_params, 2918 post_params=form_params, 2919 files=local_var_files, 2920 response_type='DocumentHtmlDefinitions', 2921 auth_settings=auth_settings, 2922 callback=params.get('callback'), 2923 _return_http_data_only=params.get('_return_http_data_only'), 2924 _preload_content=params.get('_preload_content', True), 2925 _request_timeout=params.get('_request_timeout'), 2926 collection_formats=collection_formats) 2927 2928 def create_sender_view(self, account_id, envelope_id, **kwargs): 2929 """ 2930 Returns a URL to the sender view UI. 2931 Returns a URL that allows you to embed the sender view of the DocuSign UI in your applications. This is a one-time use login token that allows the user to be placed into the DocuSign sending view. Upon sending completion, the user is returned to the return URL provided by the API application. Important: iFrames should not be used for embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends using a WebView. 2932 This method makes a synchronous HTTP request by default. To make an 2933 asynchronous HTTP request, please define a `callback` function 2934 to be invoked when receiving the response. 2935 >>> def callback_function(response): 2936 >>> pprint(response) 2937 >>> 2938 >>> thread = api.create_sender_view(account_id, envelope_id, callback=callback_function) 2939 2940 :param callback function: The callback function 2941 for asynchronous request. (optional) 2942 :param str account_id: The external account number (int) or account ID Guid. (required) 2943 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2944 :param EnvelopeViewRequest envelope_view_request: 2945 :return: ViewUrl 2946 If the method is called asynchronously, 2947 returns the request thread. 2948 """ 2949 kwargs['_return_http_data_only'] = True 2950 if kwargs.get('callback'): 2951 return self.create_sender_view_with_http_info(account_id, envelope_id, **kwargs) 2952 else: 2953 (data) = self.create_sender_view_with_http_info(account_id, envelope_id, **kwargs) 2954 return data 2955 2956 def create_sender_view_with_http_info(self, account_id, envelope_id, **kwargs): 2957 """ 2958 Returns a URL to the sender view UI. 2959 Returns a URL that allows you to embed the sender view of the DocuSign UI in your applications. This is a one-time use login token that allows the user to be placed into the DocuSign sending view. Upon sending completion, the user is returned to the return URL provided by the API application. Important: iFrames should not be used for embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends using a WebView. 2960 This method makes a synchronous HTTP request by default. To make an 2961 asynchronous HTTP request, please define a `callback` function 2962 to be invoked when receiving the response. 2963 >>> def callback_function(response): 2964 >>> pprint(response) 2965 >>> 2966 >>> thread = api.create_sender_view_with_http_info(account_id, envelope_id, callback=callback_function) 2967 2968 :param callback function: The callback function 2969 for asynchronous request. (optional) 2970 :param str account_id: The external account number (int) or account ID Guid. (required) 2971 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2972 :param EnvelopeViewRequest envelope_view_request: 2973 :return: ViewUrl 2974 If the method is called asynchronously, 2975 returns the request thread. 2976 """ 2977 2978 all_params = ['account_id', 'envelope_id', 'envelope_view_request'] 2979 all_params.append('callback') 2980 all_params.append('_return_http_data_only') 2981 all_params.append('_preload_content') 2982 all_params.append('_request_timeout') 2983 2984 params = locals() 2985 for key, val in iteritems(params['kwargs']): 2986 if key not in all_params: 2987 raise TypeError( 2988 "Got an unexpected keyword argument '%s'" 2989 " to method create_sender_view" % key 2990 ) 2991 params[key] = val 2992 del params['kwargs'] 2993 # verify the required parameter 'account_id' is set 2994 if ('account_id' not in params) or (params['account_id'] is None): 2995 raise ValueError("Missing the required parameter `account_id` when calling `create_sender_view`") 2996 # verify the required parameter 'envelope_id' is set 2997 if ('envelope_id' not in params) or (params['envelope_id'] is None): 2998 raise ValueError("Missing the required parameter `envelope_id` when calling `create_sender_view`") 2999 3000 3001 collection_formats = {} 3002 3003 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/sender'.replace('{format}', 'json') 3004 path_params = {} 3005 if 'account_id' in params: 3006 path_params['accountId'] = params['account_id'] 3007 if 'envelope_id' in params: 3008 path_params['envelopeId'] = params['envelope_id'] 3009 3010 query_params = {} 3011 3012 header_params = {} 3013 3014 form_params = [] 3015 local_var_files = {} 3016 3017 body_params = None 3018 if 'envelope_view_request' in params: 3019 body_params = params['envelope_view_request'] 3020 # HTTP header `Accept` 3021 header_params['Accept'] = self.api_client.\ 3022 select_header_accept(['application/json']) 3023 3024 # Authentication setting 3025 auth_settings = [] 3026 3027 return self.api_client.call_api(resource_path, 'POST', 3028 path_params, 3029 query_params, 3030 header_params, 3031 body=body_params, 3032 post_params=form_params, 3033 files=local_var_files, 3034 response_type='ViewUrl', 3035 auth_settings=auth_settings, 3036 callback=params.get('callback'), 3037 _return_http_data_only=params.get('_return_http_data_only'), 3038 _preload_content=params.get('_preload_content', True), 3039 _request_timeout=params.get('_request_timeout'), 3040 collection_formats=collection_formats) 3041 3042 def create_tabs(self, account_id, envelope_id, recipient_id, **kwargs): 3043 """ 3044 Adds tabs for a recipient. 3045 Adds one or more tabs for a recipient. 3046 This method makes a synchronous HTTP request by default. To make an 3047 asynchronous HTTP request, please define a `callback` function 3048 to be invoked when receiving the response. 3049 >>> def callback_function(response): 3050 >>> pprint(response) 3051 >>> 3052 >>> thread = api.create_tabs(account_id, envelope_id, recipient_id, callback=callback_function) 3053 3054 :param callback function: The callback function 3055 for asynchronous request. (optional) 3056 :param str account_id: The external account number (int) or account ID Guid. (required) 3057 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3058 :param str recipient_id: The ID of the recipient being accessed. (required) 3059 :param Tabs tabs: 3060 :return: Tabs 3061 If the method is called asynchronously, 3062 returns the request thread. 3063 """ 3064 kwargs['_return_http_data_only'] = True 3065 if kwargs.get('callback'): 3066 return self.create_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 3067 else: 3068 (data) = self.create_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 3069 return data 3070 3071 def create_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 3072 """ 3073 Adds tabs for a recipient. 3074 Adds one or more tabs for a recipient. 3075 This method makes a synchronous HTTP request by default. To make an 3076 asynchronous HTTP request, please define a `callback` function 3077 to be invoked when receiving the response. 3078 >>> def callback_function(response): 3079 >>> pprint(response) 3080 >>> 3081 >>> thread = api.create_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 3082 3083 :param callback function: The callback function 3084 for asynchronous request. (optional) 3085 :param str account_id: The external account number (int) or account ID Guid. (required) 3086 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3087 :param str recipient_id: The ID of the recipient being accessed. (required) 3088 :param Tabs tabs: 3089 :return: Tabs 3090 If the method is called asynchronously, 3091 returns the request thread. 3092 """ 3093 3094 all_params = ['account_id', 'envelope_id', 'recipient_id', 'tabs'] 3095 all_params.append('callback') 3096 all_params.append('_return_http_data_only') 3097 all_params.append('_preload_content') 3098 all_params.append('_request_timeout') 3099 3100 params = locals() 3101 for key, val in iteritems(params['kwargs']): 3102 if key not in all_params: 3103 raise TypeError( 3104 "Got an unexpected keyword argument '%s'" 3105 " to method create_tabs" % key 3106 ) 3107 params[key] = val 3108 del params['kwargs'] 3109 # verify the required parameter 'account_id' is set 3110 if ('account_id' not in params) or (params['account_id'] is None): 3111 raise ValueError("Missing the required parameter `account_id` when calling `create_tabs`") 3112 # verify the required parameter 'envelope_id' is set 3113 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3114 raise ValueError("Missing the required parameter `envelope_id` when calling `create_tabs`") 3115 # verify the required parameter 'recipient_id' is set 3116 if ('recipient_id' not in params) or (params['recipient_id'] is None): 3117 raise ValueError("Missing the required parameter `recipient_id` when calling `create_tabs`") 3118 3119 3120 collection_formats = {} 3121 3122 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/tabs'.replace('{format}', 'json') 3123 path_params = {} 3124 if 'account_id' in params: 3125 path_params['accountId'] = params['account_id'] 3126 if 'envelope_id' in params: 3127 path_params['envelopeId'] = params['envelope_id'] 3128 if 'recipient_id' in params: 3129 path_params['recipientId'] = params['recipient_id'] 3130 3131 query_params = {} 3132 3133 header_params = {} 3134 3135 form_params = [] 3136 local_var_files = {} 3137 3138 body_params = None 3139 if 'tabs' in params: 3140 body_params = params['tabs'] 3141 # HTTP header `Accept` 3142 header_params['Accept'] = self.api_client.\ 3143 select_header_accept(['application/json']) 3144 3145 # Authentication setting 3146 auth_settings = [] 3147 3148 return self.api_client.call_api(resource_path, 'POST', 3149 path_params, 3150 query_params, 3151 header_params, 3152 body=body_params, 3153 post_params=form_params, 3154 files=local_var_files, 3155 response_type='Tabs', 3156 auth_settings=auth_settings, 3157 callback=params.get('callback'), 3158 _return_http_data_only=params.get('_return_http_data_only'), 3159 _preload_content=params.get('_preload_content', True), 3160 _request_timeout=params.get('_request_timeout'), 3161 collection_formats=collection_formats) 3162 3163 def create_template_workflow_step_definition(self, account_id, template_id, **kwargs): 3164 """ 3165 Creates and adds a new workflow step definition for a template's workflow 3166 This method makes a synchronous HTTP request by default. To make an 3167 asynchronous HTTP request, please define a `callback` function 3168 to be invoked when receiving the response. 3169 >>> def callback_function(response): 3170 >>> pprint(response) 3171 >>> 3172 >>> thread = api.create_template_workflow_step_definition(account_id, template_id, callback=callback_function) 3173 3174 :param callback function: The callback function 3175 for asynchronous request. (optional) 3176 :param str account_id: The external account number (int) or account ID Guid. (required) 3177 :param str template_id: The ID of the template being accessed. (required) 3178 :param WorkflowStep workflow_step: 3179 :return: WorkflowStep 3180 If the method is called asynchronously, 3181 returns the request thread. 3182 """ 3183 kwargs['_return_http_data_only'] = True 3184 if kwargs.get('callback'): 3185 return self.create_template_workflow_step_definition_with_http_info(account_id, template_id, **kwargs) 3186 else: 3187 (data) = self.create_template_workflow_step_definition_with_http_info(account_id, template_id, **kwargs) 3188 return data 3189 3190 def create_template_workflow_step_definition_with_http_info(self, account_id, template_id, **kwargs): 3191 """ 3192 Creates and adds a new workflow step definition for a template's workflow 3193 This method makes a synchronous HTTP request by default. To make an 3194 asynchronous HTTP request, please define a `callback` function 3195 to be invoked when receiving the response. 3196 >>> def callback_function(response): 3197 >>> pprint(response) 3198 >>> 3199 >>> thread = api.create_template_workflow_step_definition_with_http_info(account_id, template_id, callback=callback_function) 3200 3201 :param callback function: The callback function 3202 for asynchronous request. (optional) 3203 :param str account_id: The external account number (int) or account ID Guid. (required) 3204 :param str template_id: The ID of the template being accessed. (required) 3205 :param WorkflowStep workflow_step: 3206 :return: WorkflowStep 3207 If the method is called asynchronously, 3208 returns the request thread. 3209 """ 3210 3211 all_params = ['account_id', 'template_id', 'workflow_step'] 3212 all_params.append('callback') 3213 all_params.append('_return_http_data_only') 3214 all_params.append('_preload_content') 3215 all_params.append('_request_timeout') 3216 3217 params = locals() 3218 for key, val in iteritems(params['kwargs']): 3219 if key not in all_params: 3220 raise TypeError( 3221 "Got an unexpected keyword argument '%s'" 3222 " to method create_template_workflow_step_definition" % key 3223 ) 3224 params[key] = val 3225 del params['kwargs'] 3226 # verify the required parameter 'account_id' is set 3227 if ('account_id' not in params) or (params['account_id'] is None): 3228 raise ValueError("Missing the required parameter `account_id` when calling `create_template_workflow_step_definition`") 3229 # verify the required parameter 'template_id' is set 3230 if ('template_id' not in params) or (params['template_id'] is None): 3231 raise ValueError("Missing the required parameter `template_id` when calling `create_template_workflow_step_definition`") 3232 3233 3234 collection_formats = {} 3235 3236 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps'.replace('{format}', 'json') 3237 path_params = {} 3238 if 'account_id' in params: 3239 path_params['accountId'] = params['account_id'] 3240 if 'template_id' in params: 3241 path_params['templateId'] = params['template_id'] 3242 3243 query_params = {} 3244 3245 header_params = {} 3246 3247 form_params = [] 3248 local_var_files = {} 3249 3250 body_params = None 3251 if 'workflow_step' in params: 3252 body_params = params['workflow_step'] 3253 # HTTP header `Accept` 3254 header_params['Accept'] = self.api_client.\ 3255 select_header_accept(['application/json']) 3256 3257 # Authentication setting 3258 auth_settings = [] 3259 3260 return self.api_client.call_api(resource_path, 'POST', 3261 path_params, 3262 query_params, 3263 header_params, 3264 body=body_params, 3265 post_params=form_params, 3266 files=local_var_files, 3267 response_type='WorkflowStep', 3268 auth_settings=auth_settings, 3269 callback=params.get('callback'), 3270 _return_http_data_only=params.get('_return_http_data_only'), 3271 _preload_content=params.get('_preload_content', True), 3272 _request_timeout=params.get('_request_timeout'), 3273 collection_formats=collection_formats) 3274 3275 def delete_attachments(self, account_id, envelope_id, **kwargs): 3276 """ 3277 Delete one or more attachments from a DRAFT envelope. 3278 Deletes one or more attachments from a draft envelope. 3279 This method makes a synchronous HTTP request by default. To make an 3280 asynchronous HTTP request, please define a `callback` function 3281 to be invoked when receiving the response. 3282 >>> def callback_function(response): 3283 >>> pprint(response) 3284 >>> 3285 >>> thread = api.delete_attachments(account_id, envelope_id, callback=callback_function) 3286 3287 :param callback function: The callback function 3288 for asynchronous request. (optional) 3289 :param str account_id: The external account number (int) or account ID Guid. (required) 3290 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3291 :param EnvelopeAttachmentsRequest envelope_attachments_request: 3292 :return: EnvelopeAttachmentsResult 3293 If the method is called asynchronously, 3294 returns the request thread. 3295 """ 3296 kwargs['_return_http_data_only'] = True 3297 if kwargs.get('callback'): 3298 return self.delete_attachments_with_http_info(account_id, envelope_id, **kwargs) 3299 else: 3300 (data) = self.delete_attachments_with_http_info(account_id, envelope_id, **kwargs) 3301 return data 3302 3303 def delete_attachments_with_http_info(self, account_id, envelope_id, **kwargs): 3304 """ 3305 Delete one or more attachments from a DRAFT envelope. 3306 Deletes one or more attachments from a draft envelope. 3307 This method makes a synchronous HTTP request by default. To make an 3308 asynchronous HTTP request, please define a `callback` function 3309 to be invoked when receiving the response. 3310 >>> def callback_function(response): 3311 >>> pprint(response) 3312 >>> 3313 >>> thread = api.delete_attachments_with_http_info(account_id, envelope_id, callback=callback_function) 3314 3315 :param callback function: The callback function 3316 for asynchronous request. (optional) 3317 :param str account_id: The external account number (int) or account ID Guid. (required) 3318 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3319 :param EnvelopeAttachmentsRequest envelope_attachments_request: 3320 :return: EnvelopeAttachmentsResult 3321 If the method is called asynchronously, 3322 returns the request thread. 3323 """ 3324 3325 all_params = ['account_id', 'envelope_id', 'envelope_attachments_request'] 3326 all_params.append('callback') 3327 all_params.append('_return_http_data_only') 3328 all_params.append('_preload_content') 3329 all_params.append('_request_timeout') 3330 3331 params = locals() 3332 for key, val in iteritems(params['kwargs']): 3333 if key not in all_params: 3334 raise TypeError( 3335 "Got an unexpected keyword argument '%s'" 3336 " to method delete_attachments" % key 3337 ) 3338 params[key] = val 3339 del params['kwargs'] 3340 # verify the required parameter 'account_id' is set 3341 if ('account_id' not in params) or (params['account_id'] is None): 3342 raise ValueError("Missing the required parameter `account_id` when calling `delete_attachments`") 3343 # verify the required parameter 'envelope_id' is set 3344 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3345 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_attachments`") 3346 3347 3348 collection_formats = {} 3349 3350 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments'.replace('{format}', 'json') 3351 path_params = {} 3352 if 'account_id' in params: 3353 path_params['accountId'] = params['account_id'] 3354 if 'envelope_id' in params: 3355 path_params['envelopeId'] = params['envelope_id'] 3356 3357 query_params = {} 3358 3359 header_params = {} 3360 3361 form_params = [] 3362 local_var_files = {} 3363 3364 body_params = None 3365 if 'envelope_attachments_request' in params: 3366 body_params = params['envelope_attachments_request'] 3367 # HTTP header `Accept` 3368 header_params['Accept'] = self.api_client.\ 3369 select_header_accept(['application/json']) 3370 3371 # Authentication setting 3372 auth_settings = [] 3373 3374 return self.api_client.call_api(resource_path, 'DELETE', 3375 path_params, 3376 query_params, 3377 header_params, 3378 body=body_params, 3379 post_params=form_params, 3380 files=local_var_files, 3381 response_type='EnvelopeAttachmentsResult', 3382 auth_settings=auth_settings, 3383 callback=params.get('callback'), 3384 _return_http_data_only=params.get('_return_http_data_only'), 3385 _preload_content=params.get('_preload_content', True), 3386 _request_timeout=params.get('_request_timeout'), 3387 collection_formats=collection_formats) 3388 3389 def delete_chunked_upload(self, account_id, chunked_upload_id, **kwargs): 3390 """ 3391 Delete an existing ChunkedUpload. 3392 Deletes a chunked upload that has been committed but not yet consumed. This method cannot be used to delete the following types of chunked uploads, which the system deletes automatically: - Chunked uploads that have been consumed by use in another API call. - Expired chunked uploads. **Note:** If you are aware of a chunked upload that can be discarded, the best practice is to explicitly delete it. If you wait for the system to automatically delete it after it expires, the chunked upload will continue to count against your quota. 3393 This method makes a synchronous HTTP request by default. To make an 3394 asynchronous HTTP request, please define a `callback` function 3395 to be invoked when receiving the response. 3396 >>> def callback_function(response): 3397 >>> pprint(response) 3398 >>> 3399 >>> thread = api.delete_chunked_upload(account_id, chunked_upload_id, callback=callback_function) 3400 3401 :param callback function: The callback function 3402 for asynchronous request. (optional) 3403 :param str account_id: The external account number (int) or account ID Guid. (required) 3404 :param str chunked_upload_id: (required) 3405 :return: ChunkedUploadResponse 3406 If the method is called asynchronously, 3407 returns the request thread. 3408 """ 3409 kwargs['_return_http_data_only'] = True 3410 if kwargs.get('callback'): 3411 return self.delete_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 3412 else: 3413 (data) = self.delete_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 3414 return data 3415 3416 def delete_chunked_upload_with_http_info(self, account_id, chunked_upload_id, **kwargs): 3417 """ 3418 Delete an existing ChunkedUpload. 3419 Deletes a chunked upload that has been committed but not yet consumed. This method cannot be used to delete the following types of chunked uploads, which the system deletes automatically: - Chunked uploads that have been consumed by use in another API call. - Expired chunked uploads. **Note:** If you are aware of a chunked upload that can be discarded, the best practice is to explicitly delete it. If you wait for the system to automatically delete it after it expires, the chunked upload will continue to count against your quota. 3420 This method makes a synchronous HTTP request by default. To make an 3421 asynchronous HTTP request, please define a `callback` function 3422 to be invoked when receiving the response. 3423 >>> def callback_function(response): 3424 >>> pprint(response) 3425 >>> 3426 >>> thread = api.delete_chunked_upload_with_http_info(account_id, chunked_upload_id, callback=callback_function) 3427 3428 :param callback function: The callback function 3429 for asynchronous request. (optional) 3430 :param str account_id: The external account number (int) or account ID Guid. (required) 3431 :param str chunked_upload_id: (required) 3432 :return: ChunkedUploadResponse 3433 If the method is called asynchronously, 3434 returns the request thread. 3435 """ 3436 3437 all_params = ['account_id', 'chunked_upload_id'] 3438 all_params.append('callback') 3439 all_params.append('_return_http_data_only') 3440 all_params.append('_preload_content') 3441 all_params.append('_request_timeout') 3442 3443 params = locals() 3444 for key, val in iteritems(params['kwargs']): 3445 if key not in all_params: 3446 raise TypeError( 3447 "Got an unexpected keyword argument '%s'" 3448 " to method delete_chunked_upload" % key 3449 ) 3450 params[key] = val 3451 del params['kwargs'] 3452 # verify the required parameter 'account_id' is set 3453 if ('account_id' not in params) or (params['account_id'] is None): 3454 raise ValueError("Missing the required parameter `account_id` when calling `delete_chunked_upload`") 3455 # verify the required parameter 'chunked_upload_id' is set 3456 if ('chunked_upload_id' not in params) or (params['chunked_upload_id'] is None): 3457 raise ValueError("Missing the required parameter `chunked_upload_id` when calling `delete_chunked_upload`") 3458 3459 3460 collection_formats = {} 3461 3462 resource_path = '/v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}'.replace('{format}', 'json') 3463 path_params = {} 3464 if 'account_id' in params: 3465 path_params['accountId'] = params['account_id'] 3466 if 'chunked_upload_id' in params: 3467 path_params['chunkedUploadId'] = params['chunked_upload_id'] 3468 3469 query_params = {} 3470 3471 header_params = {} 3472 3473 form_params = [] 3474 local_var_files = {} 3475 3476 body_params = None 3477 # HTTP header `Accept` 3478 header_params['Accept'] = self.api_client.\ 3479 select_header_accept(['application/json']) 3480 3481 # Authentication setting 3482 auth_settings = [] 3483 3484 return self.api_client.call_api(resource_path, 'DELETE', 3485 path_params, 3486 query_params, 3487 header_params, 3488 body=body_params, 3489 post_params=form_params, 3490 files=local_var_files, 3491 response_type='ChunkedUploadResponse', 3492 auth_settings=auth_settings, 3493 callback=params.get('callback'), 3494 _return_http_data_only=params.get('_return_http_data_only'), 3495 _preload_content=params.get('_preload_content', True), 3496 _request_timeout=params.get('_request_timeout'), 3497 collection_formats=collection_formats) 3498 3499 def delete_custom_fields(self, account_id, envelope_id, **kwargs): 3500 """ 3501 Deletes envelope custom fields for draft and in-process envelopes. 3502 Deletes envelope custom fields for draft and in-process envelopes. 3503 This method makes a synchronous HTTP request by default. To make an 3504 asynchronous HTTP request, please define a `callback` function 3505 to be invoked when receiving the response. 3506 >>> def callback_function(response): 3507 >>> pprint(response) 3508 >>> 3509 >>> thread = api.delete_custom_fields(account_id, envelope_id, callback=callback_function) 3510 3511 :param callback function: The callback function 3512 for asynchronous request. (optional) 3513 :param str account_id: The external account number (int) or account ID Guid. (required) 3514 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3515 :param CustomFields custom_fields: 3516 :return: CustomFields 3517 If the method is called asynchronously, 3518 returns the request thread. 3519 """ 3520 kwargs['_return_http_data_only'] = True 3521 if kwargs.get('callback'): 3522 return self.delete_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 3523 else: 3524 (data) = self.delete_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 3525 return data 3526 3527 def delete_custom_fields_with_http_info(self, account_id, envelope_id, **kwargs): 3528 """ 3529 Deletes envelope custom fields for draft and in-process envelopes. 3530 Deletes envelope custom fields for draft and in-process envelopes. 3531 This method makes a synchronous HTTP request by default. To make an 3532 asynchronous HTTP request, please define a `callback` function 3533 to be invoked when receiving the response. 3534 >>> def callback_function(response): 3535 >>> pprint(response) 3536 >>> 3537 >>> thread = api.delete_custom_fields_with_http_info(account_id, envelope_id, callback=callback_function) 3538 3539 :param callback function: The callback function 3540 for asynchronous request. (optional) 3541 :param str account_id: The external account number (int) or account ID Guid. (required) 3542 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3543 :param CustomFields custom_fields: 3544 :return: CustomFields 3545 If the method is called asynchronously, 3546 returns the request thread. 3547 """ 3548 3549 all_params = ['account_id', 'envelope_id', 'custom_fields'] 3550 all_params.append('callback') 3551 all_params.append('_return_http_data_only') 3552 all_params.append('_preload_content') 3553 all_params.append('_request_timeout') 3554 3555 params = locals() 3556 for key, val in iteritems(params['kwargs']): 3557 if key not in all_params: 3558 raise TypeError( 3559 "Got an unexpected keyword argument '%s'" 3560 " to method delete_custom_fields" % key 3561 ) 3562 params[key] = val 3563 del params['kwargs'] 3564 # verify the required parameter 'account_id' is set 3565 if ('account_id' not in params) or (params['account_id'] is None): 3566 raise ValueError("Missing the required parameter `account_id` when calling `delete_custom_fields`") 3567 # verify the required parameter 'envelope_id' is set 3568 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3569 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_custom_fields`") 3570 3571 3572 collection_formats = {} 3573 3574 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/custom_fields'.replace('{format}', 'json') 3575 path_params = {} 3576 if 'account_id' in params: 3577 path_params['accountId'] = params['account_id'] 3578 if 'envelope_id' in params: 3579 path_params['envelopeId'] = params['envelope_id'] 3580 3581 query_params = {} 3582 3583 header_params = {} 3584 3585 form_params = [] 3586 local_var_files = {} 3587 3588 body_params = None 3589 if 'custom_fields' in params: 3590 body_params = params['custom_fields'] 3591 # HTTP header `Accept` 3592 header_params['Accept'] = self.api_client.\ 3593 select_header_accept(['application/json']) 3594 3595 # Authentication setting 3596 auth_settings = [] 3597 3598 return self.api_client.call_api(resource_path, 'DELETE', 3599 path_params, 3600 query_params, 3601 header_params, 3602 body=body_params, 3603 post_params=form_params, 3604 files=local_var_files, 3605 response_type='CustomFields', 3606 auth_settings=auth_settings, 3607 callback=params.get('callback'), 3608 _return_http_data_only=params.get('_return_http_data_only'), 3609 _preload_content=params.get('_preload_content', True), 3610 _request_timeout=params.get('_request_timeout'), 3611 collection_formats=collection_formats) 3612 3613 def delete_document_fields(self, account_id, document_id, envelope_id, **kwargs): 3614 """ 3615 Deletes custom document fields from an existing envelope document. 3616 Deletes custom document fields from an existing envelope document. 3617 This method makes a synchronous HTTP request by default. To make an 3618 asynchronous HTTP request, please define a `callback` function 3619 to be invoked when receiving the response. 3620 >>> def callback_function(response): 3621 >>> pprint(response) 3622 >>> 3623 >>> thread = api.delete_document_fields(account_id, document_id, envelope_id, callback=callback_function) 3624 3625 :param callback function: The callback function 3626 for asynchronous request. (optional) 3627 :param str account_id: The external account number (int) or account ID Guid. (required) 3628 :param str document_id: The ID of the document being accessed. (required) 3629 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3630 :param DocumentFieldsInformation document_fields_information: 3631 :return: DocumentFieldsInformation 3632 If the method is called asynchronously, 3633 returns the request thread. 3634 """ 3635 kwargs['_return_http_data_only'] = True 3636 if kwargs.get('callback'): 3637 return self.delete_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 3638 else: 3639 (data) = self.delete_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 3640 return data 3641 3642 def delete_document_fields_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 3643 """ 3644 Deletes custom document fields from an existing envelope document. 3645 Deletes custom document fields from an existing envelope document. 3646 This method makes a synchronous HTTP request by default. To make an 3647 asynchronous HTTP request, please define a `callback` function 3648 to be invoked when receiving the response. 3649 >>> def callback_function(response): 3650 >>> pprint(response) 3651 >>> 3652 >>> thread = api.delete_document_fields_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 3653 3654 :param callback function: The callback function 3655 for asynchronous request. (optional) 3656 :param str account_id: The external account number (int) or account ID Guid. (required) 3657 :param str document_id: The ID of the document being accessed. (required) 3658 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3659 :param DocumentFieldsInformation document_fields_information: 3660 :return: DocumentFieldsInformation 3661 If the method is called asynchronously, 3662 returns the request thread. 3663 """ 3664 3665 all_params = ['account_id', 'document_id', 'envelope_id', 'document_fields_information'] 3666 all_params.append('callback') 3667 all_params.append('_return_http_data_only') 3668 all_params.append('_preload_content') 3669 all_params.append('_request_timeout') 3670 3671 params = locals() 3672 for key, val in iteritems(params['kwargs']): 3673 if key not in all_params: 3674 raise TypeError( 3675 "Got an unexpected keyword argument '%s'" 3676 " to method delete_document_fields" % key 3677 ) 3678 params[key] = val 3679 del params['kwargs'] 3680 # verify the required parameter 'account_id' is set 3681 if ('account_id' not in params) or (params['account_id'] is None): 3682 raise ValueError("Missing the required parameter `account_id` when calling `delete_document_fields`") 3683 # verify the required parameter 'document_id' is set 3684 if ('document_id' not in params) or (params['document_id'] is None): 3685 raise ValueError("Missing the required parameter `document_id` when calling `delete_document_fields`") 3686 # verify the required parameter 'envelope_id' is set 3687 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3688 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_document_fields`") 3689 3690 3691 collection_formats = {} 3692 3693 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/fields'.replace('{format}', 'json') 3694 path_params = {} 3695 if 'account_id' in params: 3696 path_params['accountId'] = params['account_id'] 3697 if 'document_id' in params: 3698 path_params['documentId'] = params['document_id'] 3699 if 'envelope_id' in params: 3700 path_params['envelopeId'] = params['envelope_id'] 3701 3702 query_params = {} 3703 3704 header_params = {} 3705 3706 form_params = [] 3707 local_var_files = {} 3708 3709 body_params = None 3710 if 'document_fields_information' in params: 3711 body_params = params['document_fields_information'] 3712 # HTTP header `Accept` 3713 header_params['Accept'] = self.api_client.\ 3714 select_header_accept(['application/json']) 3715 3716 # Authentication setting 3717 auth_settings = [] 3718 3719 return self.api_client.call_api(resource_path, 'DELETE', 3720 path_params, 3721 query_params, 3722 header_params, 3723 body=body_params, 3724 post_params=form_params, 3725 files=local_var_files, 3726 response_type='DocumentFieldsInformation', 3727 auth_settings=auth_settings, 3728 callback=params.get('callback'), 3729 _return_http_data_only=params.get('_return_http_data_only'), 3730 _preload_content=params.get('_preload_content', True), 3731 _request_timeout=params.get('_request_timeout'), 3732 collection_formats=collection_formats) 3733 3734 def delete_document_page(self, account_id, document_id, envelope_id, page_number, **kwargs): 3735 """ 3736 Deletes a page from a document in an envelope. 3737 Deletes a page from a document in an envelope based on the page number. 3738 This method makes a synchronous HTTP request by default. To make an 3739 asynchronous HTTP request, please define a `callback` function 3740 to be invoked when receiving the response. 3741 >>> def callback_function(response): 3742 >>> pprint(response) 3743 >>> 3744 >>> thread = api.delete_document_page(account_id, document_id, envelope_id, page_number, callback=callback_function) 3745 3746 :param callback function: The callback function 3747 for asynchronous request. (optional) 3748 :param str account_id: The external account number (int) or account ID Guid. (required) 3749 :param str document_id: The ID of the document being accessed. (required) 3750 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3751 :param str page_number: The page number being accessed. (required) 3752 :return: None 3753 If the method is called asynchronously, 3754 returns the request thread. 3755 """ 3756 kwargs['_return_http_data_only'] = True 3757 if kwargs.get('callback'): 3758 return self.delete_document_page_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 3759 else: 3760 (data) = self.delete_document_page_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 3761 return data 3762 3763 def delete_document_page_with_http_info(self, account_id, document_id, envelope_id, page_number, **kwargs): 3764 """ 3765 Deletes a page from a document in an envelope. 3766 Deletes a page from a document in an envelope based on the page number. 3767 This method makes a synchronous HTTP request by default. To make an 3768 asynchronous HTTP request, please define a `callback` function 3769 to be invoked when receiving the response. 3770 >>> def callback_function(response): 3771 >>> pprint(response) 3772 >>> 3773 >>> thread = api.delete_document_page_with_http_info(account_id, document_id, envelope_id, page_number, callback=callback_function) 3774 3775 :param callback function: The callback function 3776 for asynchronous request. (optional) 3777 :param str account_id: The external account number (int) or account ID Guid. (required) 3778 :param str document_id: The ID of the document being accessed. (required) 3779 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3780 :param str page_number: The page number being accessed. (required) 3781 :return: None 3782 If the method is called asynchronously, 3783 returns the request thread. 3784 """ 3785 3786 all_params = ['account_id', 'document_id', 'envelope_id', 'page_number'] 3787 all_params.append('callback') 3788 all_params.append('_return_http_data_only') 3789 all_params.append('_preload_content') 3790 all_params.append('_request_timeout') 3791 3792 params = locals() 3793 for key, val in iteritems(params['kwargs']): 3794 if key not in all_params: 3795 raise TypeError( 3796 "Got an unexpected keyword argument '%s'" 3797 " to method delete_document_page" % key 3798 ) 3799 params[key] = val 3800 del params['kwargs'] 3801 # verify the required parameter 'account_id' is set 3802 if ('account_id' not in params) or (params['account_id'] is None): 3803 raise ValueError("Missing the required parameter `account_id` when calling `delete_document_page`") 3804 # verify the required parameter 'document_id' is set 3805 if ('document_id' not in params) or (params['document_id'] is None): 3806 raise ValueError("Missing the required parameter `document_id` when calling `delete_document_page`") 3807 # verify the required parameter 'envelope_id' is set 3808 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3809 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_document_page`") 3810 # verify the required parameter 'page_number' is set 3811 if ('page_number' not in params) or (params['page_number'] is None): 3812 raise ValueError("Missing the required parameter `page_number` when calling `delete_document_page`") 3813 3814 3815 collection_formats = {} 3816 3817 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/pages/{pageNumber}'.replace('{format}', 'json') 3818 path_params = {} 3819 if 'account_id' in params: 3820 path_params['accountId'] = params['account_id'] 3821 if 'document_id' in params: 3822 path_params['documentId'] = params['document_id'] 3823 if 'envelope_id' in params: 3824 path_params['envelopeId'] = params['envelope_id'] 3825 if 'page_number' in params: 3826 path_params['pageNumber'] = params['page_number'] 3827 3828 query_params = {} 3829 3830 header_params = {} 3831 3832 form_params = [] 3833 local_var_files = {} 3834 3835 body_params = None 3836 # HTTP header `Accept` 3837 header_params['Accept'] = self.api_client.\ 3838 select_header_accept(['application/json']) 3839 3840 # Authentication setting 3841 auth_settings = [] 3842 3843 return self.api_client.call_api(resource_path, 'DELETE', 3844 path_params, 3845 query_params, 3846 header_params, 3847 body=body_params, 3848 post_params=form_params, 3849 files=local_var_files, 3850 response_type=None, 3851 auth_settings=auth_settings, 3852 callback=params.get('callback'), 3853 _return_http_data_only=params.get('_return_http_data_only'), 3854 _preload_content=params.get('_preload_content', True), 3855 _request_timeout=params.get('_request_timeout'), 3856 collection_formats=collection_formats) 3857 3858 def delete_document_tabs(self, account_id, document_id, envelope_id, **kwargs): 3859 """ 3860 Deletes tabs from an envelope document 3861 Deletes tabs from the document specified by `documentId` in the envelope specified by `envelopeId`. 3862 This method makes a synchronous HTTP request by default. To make an 3863 asynchronous HTTP request, please define a `callback` function 3864 to be invoked when receiving the response. 3865 >>> def callback_function(response): 3866 >>> pprint(response) 3867 >>> 3868 >>> thread = api.delete_document_tabs(account_id, document_id, envelope_id, callback=callback_function) 3869 3870 :param callback function: The callback function 3871 for asynchronous request. (optional) 3872 :param str account_id: The external account number (int) or account ID Guid. (required) 3873 :param str document_id: The ID of the document being accessed. (required) 3874 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3875 :param Tabs tabs: 3876 :return: Tabs 3877 If the method is called asynchronously, 3878 returns the request thread. 3879 """ 3880 kwargs['_return_http_data_only'] = True 3881 if kwargs.get('callback'): 3882 return self.delete_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 3883 else: 3884 (data) = self.delete_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 3885 return data 3886 3887 def delete_document_tabs_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 3888 """ 3889 Deletes tabs from an envelope document 3890 Deletes tabs from the document specified by `documentId` in the envelope specified by `envelopeId`. 3891 This method makes a synchronous HTTP request by default. To make an 3892 asynchronous HTTP request, please define a `callback` function 3893 to be invoked when receiving the response. 3894 >>> def callback_function(response): 3895 >>> pprint(response) 3896 >>> 3897 >>> thread = api.delete_document_tabs_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 3898 3899 :param callback function: The callback function 3900 for asynchronous request. (optional) 3901 :param str account_id: The external account number (int) or account ID Guid. (required) 3902 :param str document_id: The ID of the document being accessed. (required) 3903 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3904 :param Tabs tabs: 3905 :return: Tabs 3906 If the method is called asynchronously, 3907 returns the request thread. 3908 """ 3909 3910 all_params = ['account_id', 'document_id', 'envelope_id', 'tabs'] 3911 all_params.append('callback') 3912 all_params.append('_return_http_data_only') 3913 all_params.append('_preload_content') 3914 all_params.append('_request_timeout') 3915 3916 params = locals() 3917 for key, val in iteritems(params['kwargs']): 3918 if key not in all_params: 3919 raise TypeError( 3920 "Got an unexpected keyword argument '%s'" 3921 " to method delete_document_tabs" % key 3922 ) 3923 params[key] = val 3924 del params['kwargs'] 3925 # verify the required parameter 'account_id' is set 3926 if ('account_id' not in params) or (params['account_id'] is None): 3927 raise ValueError("Missing the required parameter `account_id` when calling `delete_document_tabs`") 3928 # verify the required parameter 'document_id' is set 3929 if ('document_id' not in params) or (params['document_id'] is None): 3930 raise ValueError("Missing the required parameter `document_id` when calling `delete_document_tabs`") 3931 # verify the required parameter 'envelope_id' is set 3932 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3933 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_document_tabs`") 3934 3935 3936 collection_formats = {} 3937 3938 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/tabs'.replace('{format}', 'json') 3939 path_params = {} 3940 if 'account_id' in params: 3941 path_params['accountId'] = params['account_id'] 3942 if 'document_id' in params: 3943 path_params['documentId'] = params['document_id'] 3944 if 'envelope_id' in params: 3945 path_params['envelopeId'] = params['envelope_id'] 3946 3947 query_params = {} 3948 3949 header_params = {} 3950 3951 form_params = [] 3952 local_var_files = {} 3953 3954 body_params = None 3955 if 'tabs' in params: 3956 body_params = params['tabs'] 3957 # HTTP header `Accept` 3958 header_params['Accept'] = self.api_client.\ 3959 select_header_accept(['application/json']) 3960 3961 # Authentication setting 3962 auth_settings = [] 3963 3964 return self.api_client.call_api(resource_path, 'DELETE', 3965 path_params, 3966 query_params, 3967 header_params, 3968 body=body_params, 3969 post_params=form_params, 3970 files=local_var_files, 3971 response_type='Tabs', 3972 auth_settings=auth_settings, 3973 callback=params.get('callback'), 3974 _return_http_data_only=params.get('_return_http_data_only'), 3975 _preload_content=params.get('_preload_content', True), 3976 _request_timeout=params.get('_request_timeout'), 3977 collection_formats=collection_formats) 3978 3979 def delete_documents(self, account_id, envelope_id, **kwargs): 3980 """ 3981 Deletes documents from a draft envelope. 3982 Deletes one or more documents from an existing draft envelope. 3983 This method makes a synchronous HTTP request by default. To make an 3984 asynchronous HTTP request, please define a `callback` function 3985 to be invoked when receiving the response. 3986 >>> def callback_function(response): 3987 >>> pprint(response) 3988 >>> 3989 >>> thread = api.delete_documents(account_id, envelope_id, callback=callback_function) 3990 3991 :param callback function: The callback function 3992 for asynchronous request. (optional) 3993 :param str account_id: The external account number (int) or account ID Guid. (required) 3994 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3995 :param EnvelopeDefinition envelope_definition: 3996 :return: EnvelopeDocumentsResult 3997 If the method is called asynchronously, 3998 returns the request thread. 3999 """ 4000 kwargs['_return_http_data_only'] = True 4001 if kwargs.get('callback'): 4002 return self.delete_documents_with_http_info(account_id, envelope_id, **kwargs) 4003 else: 4004 (data) = self.delete_documents_with_http_info(account_id, envelope_id, **kwargs) 4005 return data 4006 4007 def delete_documents_with_http_info(self, account_id, envelope_id, **kwargs): 4008 """ 4009 Deletes documents from a draft envelope. 4010 Deletes one or more documents from an existing draft envelope. 4011 This method makes a synchronous HTTP request by default. To make an 4012 asynchronous HTTP request, please define a `callback` function 4013 to be invoked when receiving the response. 4014 >>> def callback_function(response): 4015 >>> pprint(response) 4016 >>> 4017 >>> thread = api.delete_documents_with_http_info(account_id, envelope_id, callback=callback_function) 4018 4019 :param callback function: The callback function 4020 for asynchronous request. (optional) 4021 :param str account_id: The external account number (int) or account ID Guid. (required) 4022 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4023 :param EnvelopeDefinition envelope_definition: 4024 :return: EnvelopeDocumentsResult 4025 If the method is called asynchronously, 4026 returns the request thread. 4027 """ 4028 4029 all_params = ['account_id', 'envelope_id', 'envelope_definition'] 4030 all_params.append('callback') 4031 all_params.append('_return_http_data_only') 4032 all_params.append('_preload_content') 4033 all_params.append('_request_timeout') 4034 4035 params = locals() 4036 for key, val in iteritems(params['kwargs']): 4037 if key not in all_params: 4038 raise TypeError( 4039 "Got an unexpected keyword argument '%s'" 4040 " to method delete_documents" % key 4041 ) 4042 params[key] = val 4043 del params['kwargs'] 4044 # verify the required parameter 'account_id' is set 4045 if ('account_id' not in params) or (params['account_id'] is None): 4046 raise ValueError("Missing the required parameter `account_id` when calling `delete_documents`") 4047 # verify the required parameter 'envelope_id' is set 4048 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4049 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_documents`") 4050 4051 4052 collection_formats = {} 4053 4054 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents'.replace('{format}', 'json') 4055 path_params = {} 4056 if 'account_id' in params: 4057 path_params['accountId'] = params['account_id'] 4058 if 'envelope_id' in params: 4059 path_params['envelopeId'] = params['envelope_id'] 4060 4061 query_params = {} 4062 4063 header_params = {} 4064 4065 form_params = [] 4066 local_var_files = {} 4067 4068 body_params = None 4069 if 'envelope_definition' in params: 4070 body_params = params['envelope_definition'] 4071 # HTTP header `Accept` 4072 header_params['Accept'] = self.api_client.\ 4073 select_header_accept(['application/json']) 4074 4075 # Authentication setting 4076 auth_settings = [] 4077 4078 return self.api_client.call_api(resource_path, 'DELETE', 4079 path_params, 4080 query_params, 4081 header_params, 4082 body=body_params, 4083 post_params=form_params, 4084 files=local_var_files, 4085 response_type='EnvelopeDocumentsResult', 4086 auth_settings=auth_settings, 4087 callback=params.get('callback'), 4088 _return_http_data_only=params.get('_return_http_data_only'), 4089 _preload_content=params.get('_preload_content', True), 4090 _request_timeout=params.get('_request_timeout'), 4091 collection_formats=collection_formats) 4092 4093 def delete_email_settings(self, account_id, envelope_id, **kwargs): 4094 """ 4095 Deletes the email setting overrides for an envelope. 4096 Deletes all existing email override settings for the envelope. If you want to delete an individual email override setting, use the PUT and set the value to an empty string. Note that deleting email settings will only affect email communications that occur after the deletion and the normal account email settings are used for future email communications. 4097 This method makes a synchronous HTTP request by default. To make an 4098 asynchronous HTTP request, please define a `callback` function 4099 to be invoked when receiving the response. 4100 >>> def callback_function(response): 4101 >>> pprint(response) 4102 >>> 4103 >>> thread = api.delete_email_settings(account_id, envelope_id, callback=callback_function) 4104 4105 :param callback function: The callback function 4106 for asynchronous request. (optional) 4107 :param str account_id: The external account number (int) or account ID Guid. (required) 4108 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4109 :return: EmailSettings 4110 If the method is called asynchronously, 4111 returns the request thread. 4112 """ 4113 kwargs['_return_http_data_only'] = True 4114 if kwargs.get('callback'): 4115 return self.delete_email_settings_with_http_info(account_id, envelope_id, **kwargs) 4116 else: 4117 (data) = self.delete_email_settings_with_http_info(account_id, envelope_id, **kwargs) 4118 return data 4119 4120 def delete_email_settings_with_http_info(self, account_id, envelope_id, **kwargs): 4121 """ 4122 Deletes the email setting overrides for an envelope. 4123 Deletes all existing email override settings for the envelope. If you want to delete an individual email override setting, use the PUT and set the value to an empty string. Note that deleting email settings will only affect email communications that occur after the deletion and the normal account email settings are used for future email communications. 4124 This method makes a synchronous HTTP request by default. To make an 4125 asynchronous HTTP request, please define a `callback` function 4126 to be invoked when receiving the response. 4127 >>> def callback_function(response): 4128 >>> pprint(response) 4129 >>> 4130 >>> thread = api.delete_email_settings_with_http_info(account_id, envelope_id, callback=callback_function) 4131 4132 :param callback function: The callback function 4133 for asynchronous request. (optional) 4134 :param str account_id: The external account number (int) or account ID Guid. (required) 4135 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4136 :return: EmailSettings 4137 If the method is called asynchronously, 4138 returns the request thread. 4139 """ 4140 4141 all_params = ['account_id', 'envelope_id'] 4142 all_params.append('callback') 4143 all_params.append('_return_http_data_only') 4144 all_params.append('_preload_content') 4145 all_params.append('_request_timeout') 4146 4147 params = locals() 4148 for key, val in iteritems(params['kwargs']): 4149 if key not in all_params: 4150 raise TypeError( 4151 "Got an unexpected keyword argument '%s'" 4152 " to method delete_email_settings" % key 4153 ) 4154 params[key] = val 4155 del params['kwargs'] 4156 # verify the required parameter 'account_id' is set 4157 if ('account_id' not in params) or (params['account_id'] is None): 4158 raise ValueError("Missing the required parameter `account_id` when calling `delete_email_settings`") 4159 # verify the required parameter 'envelope_id' is set 4160 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4161 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_email_settings`") 4162 4163 4164 collection_formats = {} 4165 4166 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/email_settings'.replace('{format}', 'json') 4167 path_params = {} 4168 if 'account_id' in params: 4169 path_params['accountId'] = params['account_id'] 4170 if 'envelope_id' in params: 4171 path_params['envelopeId'] = params['envelope_id'] 4172 4173 query_params = {} 4174 4175 header_params = {} 4176 4177 form_params = [] 4178 local_var_files = {} 4179 4180 body_params = None 4181 # HTTP header `Accept` 4182 header_params['Accept'] = self.api_client.\ 4183 select_header_accept(['application/json']) 4184 4185 # Authentication setting 4186 auth_settings = [] 4187 4188 return self.api_client.call_api(resource_path, 'DELETE', 4189 path_params, 4190 query_params, 4191 header_params, 4192 body=body_params, 4193 post_params=form_params, 4194 files=local_var_files, 4195 response_type='EmailSettings', 4196 auth_settings=auth_settings, 4197 callback=params.get('callback'), 4198 _return_http_data_only=params.get('_return_http_data_only'), 4199 _preload_content=params.get('_preload_content', True), 4200 _request_timeout=params.get('_request_timeout'), 4201 collection_formats=collection_formats) 4202 4203 def delete_envelope_correct_view(self, account_id, envelope_id, **kwargs): 4204 """ 4205 Revokes the correction view URL to the Envelope UI 4206 Revokes the correction view URL to the Envelope UI. 4207 This method makes a synchronous HTTP request by default. To make an 4208 asynchronous HTTP request, please define a `callback` function 4209 to be invoked when receiving the response. 4210 >>> def callback_function(response): 4211 >>> pprint(response) 4212 >>> 4213 >>> thread = api.delete_envelope_correct_view(account_id, envelope_id, callback=callback_function) 4214 4215 :param callback function: The callback function 4216 for asynchronous request. (optional) 4217 :param str account_id: The external account number (int) or account ID Guid. (required) 4218 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4219 :param CorrectViewRequest correct_view_request: 4220 :return: None 4221 If the method is called asynchronously, 4222 returns the request thread. 4223 """ 4224 kwargs['_return_http_data_only'] = True 4225 if kwargs.get('callback'): 4226 return self.delete_envelope_correct_view_with_http_info(account_id, envelope_id, **kwargs) 4227 else: 4228 (data) = self.delete_envelope_correct_view_with_http_info(account_id, envelope_id, **kwargs) 4229 return data 4230 4231 def delete_envelope_correct_view_with_http_info(self, account_id, envelope_id, **kwargs): 4232 """ 4233 Revokes the correction view URL to the Envelope UI 4234 Revokes the correction view URL to the Envelope UI. 4235 This method makes a synchronous HTTP request by default. To make an 4236 asynchronous HTTP request, please define a `callback` function 4237 to be invoked when receiving the response. 4238 >>> def callback_function(response): 4239 >>> pprint(response) 4240 >>> 4241 >>> thread = api.delete_envelope_correct_view_with_http_info(account_id, envelope_id, callback=callback_function) 4242 4243 :param callback function: The callback function 4244 for asynchronous request. (optional) 4245 :param str account_id: The external account number (int) or account ID Guid. (required) 4246 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4247 :param CorrectViewRequest correct_view_request: 4248 :return: None 4249 If the method is called asynchronously, 4250 returns the request thread. 4251 """ 4252 4253 all_params = ['account_id', 'envelope_id', 'correct_view_request'] 4254 all_params.append('callback') 4255 all_params.append('_return_http_data_only') 4256 all_params.append('_preload_content') 4257 all_params.append('_request_timeout') 4258 4259 params = locals() 4260 for key, val in iteritems(params['kwargs']): 4261 if key not in all_params: 4262 raise TypeError( 4263 "Got an unexpected keyword argument '%s'" 4264 " to method delete_envelope_correct_view" % key 4265 ) 4266 params[key] = val 4267 del params['kwargs'] 4268 # verify the required parameter 'account_id' is set 4269 if ('account_id' not in params) or (params['account_id'] is None): 4270 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_correct_view`") 4271 # verify the required parameter 'envelope_id' is set 4272 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4273 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_envelope_correct_view`") 4274 4275 4276 collection_formats = {} 4277 4278 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/correct'.replace('{format}', 'json') 4279 path_params = {} 4280 if 'account_id' in params: 4281 path_params['accountId'] = params['account_id'] 4282 if 'envelope_id' in params: 4283 path_params['envelopeId'] = params['envelope_id'] 4284 4285 query_params = {} 4286 4287 header_params = {} 4288 4289 form_params = [] 4290 local_var_files = {} 4291 4292 body_params = None 4293 if 'correct_view_request' in params: 4294 body_params = params['correct_view_request'] 4295 # HTTP header `Accept` 4296 header_params['Accept'] = self.api_client.\ 4297 select_header_accept(['application/json']) 4298 4299 # Authentication setting 4300 auth_settings = [] 4301 4302 return self.api_client.call_api(resource_path, 'DELETE', 4303 path_params, 4304 query_params, 4305 header_params, 4306 body=body_params, 4307 post_params=form_params, 4308 files=local_var_files, 4309 response_type=None, 4310 auth_settings=auth_settings, 4311 callback=params.get('callback'), 4312 _return_http_data_only=params.get('_return_http_data_only'), 4313 _preload_content=params.get('_preload_content', True), 4314 _request_timeout=params.get('_request_timeout'), 4315 collection_formats=collection_formats) 4316 4317 def delete_envelope_delayed_routing_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 4318 """ 4319 Deletes the delayed routing rules for the specified envelope workflow step. 4320 This method makes a synchronous HTTP request by default. To make an 4321 asynchronous HTTP request, please define a `callback` function 4322 to be invoked when receiving the response. 4323 >>> def callback_function(response): 4324 >>> pprint(response) 4325 >>> 4326 >>> thread = api.delete_envelope_delayed_routing_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 4327 4328 :param callback function: The callback function 4329 for asynchronous request. (optional) 4330 :param str account_id: The external account number (int) or account ID Guid. (required) 4331 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4332 :param str workflow_step_id: (required) 4333 :return: None 4334 If the method is called asynchronously, 4335 returns the request thread. 4336 """ 4337 kwargs['_return_http_data_only'] = True 4338 if kwargs.get('callback'): 4339 return self.delete_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 4340 else: 4341 (data) = self.delete_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 4342 return data 4343 4344 def delete_envelope_delayed_routing_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 4345 """ 4346 Deletes the delayed routing rules for the specified envelope workflow step. 4347 This method makes a synchronous HTTP request by default. To make an 4348 asynchronous HTTP request, please define a `callback` function 4349 to be invoked when receiving the response. 4350 >>> def callback_function(response): 4351 >>> pprint(response) 4352 >>> 4353 >>> thread = api.delete_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 4354 4355 :param callback function: The callback function 4356 for asynchronous request. (optional) 4357 :param str account_id: The external account number (int) or account ID Guid. (required) 4358 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4359 :param str workflow_step_id: (required) 4360 :return: None 4361 If the method is called asynchronously, 4362 returns the request thread. 4363 """ 4364 4365 all_params = ['account_id', 'envelope_id', 'workflow_step_id'] 4366 all_params.append('callback') 4367 all_params.append('_return_http_data_only') 4368 all_params.append('_preload_content') 4369 all_params.append('_request_timeout') 4370 4371 params = locals() 4372 for key, val in iteritems(params['kwargs']): 4373 if key not in all_params: 4374 raise TypeError( 4375 "Got an unexpected keyword argument '%s'" 4376 " to method delete_envelope_delayed_routing_definition" % key 4377 ) 4378 params[key] = val 4379 del params['kwargs'] 4380 # verify the required parameter 'account_id' is set 4381 if ('account_id' not in params) or (params['account_id'] is None): 4382 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_delayed_routing_definition`") 4383 # verify the required parameter 'envelope_id' is set 4384 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4385 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_envelope_delayed_routing_definition`") 4386 # verify the required parameter 'workflow_step_id' is set 4387 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 4388 raise ValueError("Missing the required parameter `workflow_step_id` when calling `delete_envelope_delayed_routing_definition`") 4389 4390 4391 collection_formats = {} 4392 4393 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 4394 path_params = {} 4395 if 'account_id' in params: 4396 path_params['accountId'] = params['account_id'] 4397 if 'envelope_id' in params: 4398 path_params['envelopeId'] = params['envelope_id'] 4399 if 'workflow_step_id' in params: 4400 path_params['workflowStepId'] = params['workflow_step_id'] 4401 4402 query_params = {} 4403 4404 header_params = {} 4405 4406 form_params = [] 4407 local_var_files = {} 4408 4409 body_params = None 4410 # HTTP header `Accept` 4411 header_params['Accept'] = self.api_client.\ 4412 select_header_accept(['application/json']) 4413 4414 # Authentication setting 4415 auth_settings = [] 4416 4417 return self.api_client.call_api(resource_path, 'DELETE', 4418 path_params, 4419 query_params, 4420 header_params, 4421 body=body_params, 4422 post_params=form_params, 4423 files=local_var_files, 4424 response_type=None, 4425 auth_settings=auth_settings, 4426 callback=params.get('callback'), 4427 _return_http_data_only=params.get('_return_http_data_only'), 4428 _preload_content=params.get('_preload_content', True), 4429 _request_timeout=params.get('_request_timeout'), 4430 collection_formats=collection_formats) 4431 4432 def delete_envelope_scheduled_sending_definition(self, account_id, envelope_id, **kwargs): 4433 """ 4434 Deletes the scheduled sending rules for the envelope's workflow. 4435 This method makes a synchronous HTTP request by default. To make an 4436 asynchronous HTTP request, please define a `callback` function 4437 to be invoked when receiving the response. 4438 >>> def callback_function(response): 4439 >>> pprint(response) 4440 >>> 4441 >>> thread = api.delete_envelope_scheduled_sending_definition(account_id, envelope_id, callback=callback_function) 4442 4443 :param callback function: The callback function 4444 for asynchronous request. (optional) 4445 :param str account_id: The external account number (int) or account ID Guid. (required) 4446 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4447 :return: None 4448 If the method is called asynchronously, 4449 returns the request thread. 4450 """ 4451 kwargs['_return_http_data_only'] = True 4452 if kwargs.get('callback'): 4453 return self.delete_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 4454 else: 4455 (data) = self.delete_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 4456 return data 4457 4458 def delete_envelope_scheduled_sending_definition_with_http_info(self, account_id, envelope_id, **kwargs): 4459 """ 4460 Deletes the scheduled sending rules for the envelope's workflow. 4461 This method makes a synchronous HTTP request by default. To make an 4462 asynchronous HTTP request, please define a `callback` function 4463 to be invoked when receiving the response. 4464 >>> def callback_function(response): 4465 >>> pprint(response) 4466 >>> 4467 >>> thread = api.delete_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, callback=callback_function) 4468 4469 :param callback function: The callback function 4470 for asynchronous request. (optional) 4471 :param str account_id: The external account number (int) or account ID Guid. (required) 4472 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4473 :return: None 4474 If the method is called asynchronously, 4475 returns the request thread. 4476 """ 4477 4478 all_params = ['account_id', 'envelope_id'] 4479 all_params.append('callback') 4480 all_params.append('_return_http_data_only') 4481 all_params.append('_preload_content') 4482 all_params.append('_request_timeout') 4483 4484 params = locals() 4485 for key, val in iteritems(params['kwargs']): 4486 if key not in all_params: 4487 raise TypeError( 4488 "Got an unexpected keyword argument '%s'" 4489 " to method delete_envelope_scheduled_sending_definition" % key 4490 ) 4491 params[key] = val 4492 del params['kwargs'] 4493 # verify the required parameter 'account_id' is set 4494 if ('account_id' not in params) or (params['account_id'] is None): 4495 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_scheduled_sending_definition`") 4496 # verify the required parameter 'envelope_id' is set 4497 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4498 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_envelope_scheduled_sending_definition`") 4499 4500 4501 collection_formats = {} 4502 4503 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/scheduledSending'.replace('{format}', 'json') 4504 path_params = {} 4505 if 'account_id' in params: 4506 path_params['accountId'] = params['account_id'] 4507 if 'envelope_id' in params: 4508 path_params['envelopeId'] = params['envelope_id'] 4509 4510 query_params = {} 4511 4512 header_params = {} 4513 4514 form_params = [] 4515 local_var_files = {} 4516 4517 body_params = None 4518 # HTTP header `Accept` 4519 header_params['Accept'] = self.api_client.\ 4520 select_header_accept(['application/json']) 4521 4522 # Authentication setting 4523 auth_settings = [] 4524 4525 return self.api_client.call_api(resource_path, 'DELETE', 4526 path_params, 4527 query_params, 4528 header_params, 4529 body=body_params, 4530 post_params=form_params, 4531 files=local_var_files, 4532 response_type=None, 4533 auth_settings=auth_settings, 4534 callback=params.get('callback'), 4535 _return_http_data_only=params.get('_return_http_data_only'), 4536 _preload_content=params.get('_preload_content', True), 4537 _request_timeout=params.get('_request_timeout'), 4538 collection_formats=collection_formats) 4539 4540 def delete_envelope_transfer_rules(self, account_id, envelope_transfer_rule_id, **kwargs): 4541 """ 4542 Delete envelope transfer rules for an account. 4543 This method deletes an envelope transfer rule. **Note:** Only Administrators can delete envelope transfer rules. In addition, to use envelope transfer rules, the **Transfer Custody** feature must be enabled for your account. 4544 This method makes a synchronous HTTP request by default. To make an 4545 asynchronous HTTP request, please define a `callback` function 4546 to be invoked when receiving the response. 4547 >>> def callback_function(response): 4548 >>> pprint(response) 4549 >>> 4550 >>> thread = api.delete_envelope_transfer_rules(account_id, envelope_transfer_rule_id, callback=callback_function) 4551 4552 :param callback function: The callback function 4553 for asynchronous request. (optional) 4554 :param str account_id: The external account number (int) or account ID Guid. (required) 4555 :param str envelope_transfer_rule_id: (required) 4556 :return: None 4557 If the method is called asynchronously, 4558 returns the request thread. 4559 """ 4560 kwargs['_return_http_data_only'] = True 4561 if kwargs.get('callback'): 4562 return self.delete_envelope_transfer_rules_with_http_info(account_id, envelope_transfer_rule_id, **kwargs) 4563 else: 4564 (data) = self.delete_envelope_transfer_rules_with_http_info(account_id, envelope_transfer_rule_id, **kwargs) 4565 return data 4566 4567 def delete_envelope_transfer_rules_with_http_info(self, account_id, envelope_transfer_rule_id, **kwargs): 4568 """ 4569 Delete envelope transfer rules for an account. 4570 This method deletes an envelope transfer rule. **Note:** Only Administrators can delete envelope transfer rules. In addition, to use envelope transfer rules, the **Transfer Custody** feature must be enabled for your account. 4571 This method makes a synchronous HTTP request by default. To make an 4572 asynchronous HTTP request, please define a `callback` function 4573 to be invoked when receiving the response. 4574 >>> def callback_function(response): 4575 >>> pprint(response) 4576 >>> 4577 >>> thread = api.delete_envelope_transfer_rules_with_http_info(account_id, envelope_transfer_rule_id, callback=callback_function) 4578 4579 :param callback function: The callback function 4580 for asynchronous request. (optional) 4581 :param str account_id: The external account number (int) or account ID Guid. (required) 4582 :param str envelope_transfer_rule_id: (required) 4583 :return: None 4584 If the method is called asynchronously, 4585 returns the request thread. 4586 """ 4587 4588 all_params = ['account_id', 'envelope_transfer_rule_id'] 4589 all_params.append('callback') 4590 all_params.append('_return_http_data_only') 4591 all_params.append('_preload_content') 4592 all_params.append('_request_timeout') 4593 4594 params = locals() 4595 for key, val in iteritems(params['kwargs']): 4596 if key not in all_params: 4597 raise TypeError( 4598 "Got an unexpected keyword argument '%s'" 4599 " to method delete_envelope_transfer_rules" % key 4600 ) 4601 params[key] = val 4602 del params['kwargs'] 4603 # verify the required parameter 'account_id' is set 4604 if ('account_id' not in params) or (params['account_id'] is None): 4605 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_transfer_rules`") 4606 # verify the required parameter 'envelope_transfer_rule_id' is set 4607 if ('envelope_transfer_rule_id' not in params) or (params['envelope_transfer_rule_id'] is None): 4608 raise ValueError("Missing the required parameter `envelope_transfer_rule_id` when calling `delete_envelope_transfer_rules`") 4609 4610 4611 collection_formats = {} 4612 4613 resource_path = '/v2.1/accounts/{accountId}/envelopes/transfer_rules/{envelopeTransferRuleId}'.replace('{format}', 'json') 4614 path_params = {} 4615 if 'account_id' in params: 4616 path_params['accountId'] = params['account_id'] 4617 if 'envelope_transfer_rule_id' in params: 4618 path_params['envelopeTransferRuleId'] = params['envelope_transfer_rule_id'] 4619 4620 query_params = {} 4621 4622 header_params = {} 4623 4624 form_params = [] 4625 local_var_files = {} 4626 4627 body_params = None 4628 # HTTP header `Accept` 4629 header_params['Accept'] = self.api_client.\ 4630 select_header_accept(['application/json']) 4631 4632 # Authentication setting 4633 auth_settings = [] 4634 4635 return self.api_client.call_api(resource_path, 'DELETE', 4636 path_params, 4637 query_params, 4638 header_params, 4639 body=body_params, 4640 post_params=form_params, 4641 files=local_var_files, 4642 response_type=None, 4643 auth_settings=auth_settings, 4644 callback=params.get('callback'), 4645 _return_http_data_only=params.get('_return_http_data_only'), 4646 _preload_content=params.get('_preload_content', True), 4647 _request_timeout=params.get('_request_timeout'), 4648 collection_formats=collection_formats) 4649 4650 def delete_envelope_workflow_definition(self, account_id, envelope_id, **kwargs): 4651 """ 4652 Delete the workflow definition for an envelope. 4653 Deletes the specified envelope's workflow definition if it has one. 4654 This method makes a synchronous HTTP request by default. To make an 4655 asynchronous HTTP request, please define a `callback` function 4656 to be invoked when receiving the response. 4657 >>> def callback_function(response): 4658 >>> pprint(response) 4659 >>> 4660 >>> thread = api.delete_envelope_workflow_definition(account_id, envelope_id, callback=callback_function) 4661 4662 :param callback function: The callback function 4663 for asynchronous request. (optional) 4664 :param str account_id: The external account number (int) or account ID Guid. (required) 4665 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4666 :return: None 4667 If the method is called asynchronously, 4668 returns the request thread. 4669 """ 4670 kwargs['_return_http_data_only'] = True 4671 if kwargs.get('callback'): 4672 return self.delete_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 4673 else: 4674 (data) = self.delete_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 4675 return data 4676 4677 def delete_envelope_workflow_definition_with_http_info(self, account_id, envelope_id, **kwargs): 4678 """ 4679 Delete the workflow definition for an envelope. 4680 Deletes the specified envelope's workflow definition if it has one. 4681 This method makes a synchronous HTTP request by default. To make an 4682 asynchronous HTTP request, please define a `callback` function 4683 to be invoked when receiving the response. 4684 >>> def callback_function(response): 4685 >>> pprint(response) 4686 >>> 4687 >>> thread = api.delete_envelope_workflow_definition_with_http_info(account_id, envelope_id, callback=callback_function) 4688 4689 :param callback function: The callback function 4690 for asynchronous request. (optional) 4691 :param str account_id: The external account number (int) or account ID Guid. (required) 4692 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4693 :return: None 4694 If the method is called asynchronously, 4695 returns the request thread. 4696 """ 4697 4698 all_params = ['account_id', 'envelope_id'] 4699 all_params.append('callback') 4700 all_params.append('_return_http_data_only') 4701 all_params.append('_preload_content') 4702 all_params.append('_request_timeout') 4703 4704 params = locals() 4705 for key, val in iteritems(params['kwargs']): 4706 if key not in all_params: 4707 raise TypeError( 4708 "Got an unexpected keyword argument '%s'" 4709 " to method delete_envelope_workflow_definition" % key 4710 ) 4711 params[key] = val 4712 del params['kwargs'] 4713 # verify the required parameter 'account_id' is set 4714 if ('account_id' not in params) or (params['account_id'] is None): 4715 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_workflow_definition`") 4716 # verify the required parameter 'envelope_id' is set 4717 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4718 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_envelope_workflow_definition`") 4719 4720 4721 collection_formats = {} 4722 4723 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow'.replace('{format}', 'json') 4724 path_params = {} 4725 if 'account_id' in params: 4726 path_params['accountId'] = params['account_id'] 4727 if 'envelope_id' in params: 4728 path_params['envelopeId'] = params['envelope_id'] 4729 4730 query_params = {} 4731 4732 header_params = {} 4733 4734 form_params = [] 4735 local_var_files = {} 4736 4737 body_params = None 4738 # HTTP header `Accept` 4739 header_params['Accept'] = self.api_client.\ 4740 select_header_accept(['application/json']) 4741 4742 # Authentication setting 4743 auth_settings = [] 4744 4745 return self.api_client.call_api(resource_path, 'DELETE', 4746 path_params, 4747 query_params, 4748 header_params, 4749 body=body_params, 4750 post_params=form_params, 4751 files=local_var_files, 4752 response_type=None, 4753 auth_settings=auth_settings, 4754 callback=params.get('callback'), 4755 _return_http_data_only=params.get('_return_http_data_only'), 4756 _preload_content=params.get('_preload_content', True), 4757 _request_timeout=params.get('_request_timeout'), 4758 collection_formats=collection_formats) 4759 4760 def delete_envelope_workflow_step_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 4761 """ 4762 Deletes the envelope workflow step definition for an envelope's workflow by step id. 4763 This method makes a synchronous HTTP request by default. To make an 4764 asynchronous HTTP request, please define a `callback` function 4765 to be invoked when receiving the response. 4766 >>> def callback_function(response): 4767 >>> pprint(response) 4768 >>> 4769 >>> thread = api.delete_envelope_workflow_step_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 4770 4771 :param callback function: The callback function 4772 for asynchronous request. (optional) 4773 :param str account_id: The external account number (int) or account ID Guid. (required) 4774 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4775 :param str workflow_step_id: (required) 4776 :return: None 4777 If the method is called asynchronously, 4778 returns the request thread. 4779 """ 4780 kwargs['_return_http_data_only'] = True 4781 if kwargs.get('callback'): 4782 return self.delete_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 4783 else: 4784 (data) = self.delete_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 4785 return data 4786 4787 def delete_envelope_workflow_step_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 4788 """ 4789 Deletes the envelope workflow step definition for an envelope's workflow by step id. 4790 This method makes a synchronous HTTP request by default. To make an 4791 asynchronous HTTP request, please define a `callback` function 4792 to be invoked when receiving the response. 4793 >>> def callback_function(response): 4794 >>> pprint(response) 4795 >>> 4796 >>> thread = api.delete_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 4797 4798 :param callback function: The callback function 4799 for asynchronous request. (optional) 4800 :param str account_id: The external account number (int) or account ID Guid. (required) 4801 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4802 :param str workflow_step_id: (required) 4803 :return: None 4804 If the method is called asynchronously, 4805 returns the request thread. 4806 """ 4807 4808 all_params = ['account_id', 'envelope_id', 'workflow_step_id'] 4809 all_params.append('callback') 4810 all_params.append('_return_http_data_only') 4811 all_params.append('_preload_content') 4812 all_params.append('_request_timeout') 4813 4814 params = locals() 4815 for key, val in iteritems(params['kwargs']): 4816 if key not in all_params: 4817 raise TypeError( 4818 "Got an unexpected keyword argument '%s'" 4819 " to method delete_envelope_workflow_step_definition" % key 4820 ) 4821 params[key] = val 4822 del params['kwargs'] 4823 # verify the required parameter 'account_id' is set 4824 if ('account_id' not in params) or (params['account_id'] is None): 4825 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_workflow_step_definition`") 4826 # verify the required parameter 'envelope_id' is set 4827 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4828 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_envelope_workflow_step_definition`") 4829 # verify the required parameter 'workflow_step_id' is set 4830 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 4831 raise ValueError("Missing the required parameter `workflow_step_id` when calling `delete_envelope_workflow_step_definition`") 4832 4833 4834 collection_formats = {} 4835 4836 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 4837 path_params = {} 4838 if 'account_id' in params: 4839 path_params['accountId'] = params['account_id'] 4840 if 'envelope_id' in params: 4841 path_params['envelopeId'] = params['envelope_id'] 4842 if 'workflow_step_id' in params: 4843 path_params['workflowStepId'] = params['workflow_step_id'] 4844 4845 query_params = {} 4846 4847 header_params = {} 4848 4849 form_params = [] 4850 local_var_files = {} 4851 4852 body_params = None 4853 # HTTP header `Accept` 4854 header_params['Accept'] = self.api_client.\ 4855 select_header_accept(['application/json']) 4856 4857 # Authentication setting 4858 auth_settings = [] 4859 4860 return self.api_client.call_api(resource_path, 'DELETE', 4861 path_params, 4862 query_params, 4863 header_params, 4864 body=body_params, 4865 post_params=form_params, 4866 files=local_var_files, 4867 response_type=None, 4868 auth_settings=auth_settings, 4869 callback=params.get('callback'), 4870 _return_http_data_only=params.get('_return_http_data_only'), 4871 _preload_content=params.get('_preload_content', True), 4872 _request_timeout=params.get('_request_timeout'), 4873 collection_formats=collection_formats) 4874 4875 def delete_lock(self, account_id, envelope_id, **kwargs): 4876 """ 4877 Deletes an envelope lock. 4878 Deletes the lock from the specified envelope. The `X-DocuSign-Edit` header must be included in the request. 4879 This method makes a synchronous HTTP request by default. To make an 4880 asynchronous HTTP request, please define a `callback` function 4881 to be invoked when receiving the response. 4882 >>> def callback_function(response): 4883 >>> pprint(response) 4884 >>> 4885 >>> thread = api.delete_lock(account_id, envelope_id, callback=callback_function) 4886 4887 :param callback function: The callback function 4888 for asynchronous request. (optional) 4889 :param str account_id: The external account number (int) or account ID Guid. (required) 4890 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4891 :return: LockInformation 4892 If the method is called asynchronously, 4893 returns the request thread. 4894 """ 4895 kwargs['_return_http_data_only'] = True 4896 if kwargs.get('callback'): 4897 return self.delete_lock_with_http_info(account_id, envelope_id, **kwargs) 4898 else: 4899 (data) = self.delete_lock_with_http_info(account_id, envelope_id, **kwargs) 4900 return data 4901 4902 def delete_lock_with_http_info(self, account_id, envelope_id, **kwargs): 4903 """ 4904 Deletes an envelope lock. 4905 Deletes the lock from the specified envelope. The `X-DocuSign-Edit` header must be included in the request. 4906 This method makes a synchronous HTTP request by default. To make an 4907 asynchronous HTTP request, please define a `callback` function 4908 to be invoked when receiving the response. 4909 >>> def callback_function(response): 4910 >>> pprint(response) 4911 >>> 4912 >>> thread = api.delete_lock_with_http_info(account_id, envelope_id, callback=callback_function) 4913 4914 :param callback function: The callback function 4915 for asynchronous request. (optional) 4916 :param str account_id: The external account number (int) or account ID Guid. (required) 4917 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4918 :return: LockInformation 4919 If the method is called asynchronously, 4920 returns the request thread. 4921 """ 4922 4923 all_params = ['account_id', 'envelope_id'] 4924 all_params.append('callback') 4925 all_params.append('_return_http_data_only') 4926 all_params.append('_preload_content') 4927 all_params.append('_request_timeout') 4928 4929 params = locals() 4930 for key, val in iteritems(params['kwargs']): 4931 if key not in all_params: 4932 raise TypeError( 4933 "Got an unexpected keyword argument '%s'" 4934 " to method delete_lock" % key 4935 ) 4936 params[key] = val 4937 del params['kwargs'] 4938 # verify the required parameter 'account_id' is set 4939 if ('account_id' not in params) or (params['account_id'] is None): 4940 raise ValueError("Missing the required parameter `account_id` when calling `delete_lock`") 4941 # verify the required parameter 'envelope_id' is set 4942 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4943 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_lock`") 4944 4945 4946 collection_formats = {} 4947 4948 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/lock'.replace('{format}', 'json') 4949 path_params = {} 4950 if 'account_id' in params: 4951 path_params['accountId'] = params['account_id'] 4952 if 'envelope_id' in params: 4953 path_params['envelopeId'] = params['envelope_id'] 4954 4955 query_params = {} 4956 4957 header_params = {} 4958 4959 form_params = [] 4960 local_var_files = {} 4961 4962 body_params = None 4963 # HTTP header `Accept` 4964 header_params['Accept'] = self.api_client.\ 4965 select_header_accept(['application/json']) 4966 4967 # Authentication setting 4968 auth_settings = [] 4969 4970 return self.api_client.call_api(resource_path, 'DELETE', 4971 path_params, 4972 query_params, 4973 header_params, 4974 body=body_params, 4975 post_params=form_params, 4976 files=local_var_files, 4977 response_type='LockInformation', 4978 auth_settings=auth_settings, 4979 callback=params.get('callback'), 4980 _return_http_data_only=params.get('_return_http_data_only'), 4981 _preload_content=params.get('_preload_content', True), 4982 _request_timeout=params.get('_request_timeout'), 4983 collection_formats=collection_formats) 4984 4985 def delete_recipient(self, account_id, envelope_id, recipient_id, **kwargs): 4986 """ 4987 Deletes a recipient from an envelope. 4988 Deletes the specified recipient file from the specified envelope. This cannot be used if the envelope has been sent. 4989 This method makes a synchronous HTTP request by default. To make an 4990 asynchronous HTTP request, please define a `callback` function 4991 to be invoked when receiving the response. 4992 >>> def callback_function(response): 4993 >>> pprint(response) 4994 >>> 4995 >>> thread = api.delete_recipient(account_id, envelope_id, recipient_id, callback=callback_function) 4996 4997 :param callback function: The callback function 4998 for asynchronous request. (optional) 4999 :param str account_id: The external account number (int) or account ID Guid. (required) 5000 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5001 :param str recipient_id: The ID of the recipient being accessed. (required) 5002 :return: Recipients 5003 If the method is called asynchronously, 5004 returns the request thread. 5005 """ 5006 kwargs['_return_http_data_only'] = True 5007 if kwargs.get('callback'): 5008 return self.delete_recipient_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 5009 else: 5010 (data) = self.delete_recipient_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 5011 return data 5012 5013 def delete_recipient_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 5014 """ 5015 Deletes a recipient from an envelope. 5016 Deletes the specified recipient file from the specified envelope. This cannot be used if the envelope has been sent. 5017 This method makes a synchronous HTTP request by default. To make an 5018 asynchronous HTTP request, please define a `callback` function 5019 to be invoked when receiving the response. 5020 >>> def callback_function(response): 5021 >>> pprint(response) 5022 >>> 5023 >>> thread = api.delete_recipient_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 5024 5025 :param callback function: The callback function 5026 for asynchronous request. (optional) 5027 :param str account_id: The external account number (int) or account ID Guid. (required) 5028 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5029 :param str recipient_id: The ID of the recipient being accessed. (required) 5030 :return: Recipients 5031 If the method is called asynchronously, 5032 returns the request thread. 5033 """ 5034 5035 all_params = ['account_id', 'envelope_id', 'recipient_id'] 5036 all_params.append('callback') 5037 all_params.append('_return_http_data_only') 5038 all_params.append('_preload_content') 5039 all_params.append('_request_timeout') 5040 5041 params = locals() 5042 for key, val in iteritems(params['kwargs']): 5043 if key not in all_params: 5044 raise TypeError( 5045 "Got an unexpected keyword argument '%s'" 5046 " to method delete_recipient" % key 5047 ) 5048 params[key] = val 5049 del params['kwargs'] 5050 # verify the required parameter 'account_id' is set 5051 if ('account_id' not in params) or (params['account_id'] is None): 5052 raise ValueError("Missing the required parameter `account_id` when calling `delete_recipient`") 5053 # verify the required parameter 'envelope_id' is set 5054 if ('envelope_id' not in params) or (params['envelope_id'] is None): 5055 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_recipient`") 5056 # verify the required parameter 'recipient_id' is set 5057 if ('recipient_id' not in params) or (params['recipient_id'] is None): 5058 raise ValueError("Missing the required parameter `recipient_id` when calling `delete_recipient`") 5059 5060 5061 collection_formats = {} 5062 5063 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}'.replace('{format}', 'json') 5064 path_params = {} 5065 if 'account_id' in params: 5066 path_params['accountId'] = params['account_id'] 5067 if 'envelope_id' in params: 5068 path_params['envelopeId'] = params['envelope_id'] 5069 if 'recipient_id' in params: 5070 path_params['recipientId'] = params['recipient_id'] 5071 5072 query_params = {} 5073 5074 header_params = {} 5075 5076 form_params = [] 5077 local_var_files = {} 5078 5079 body_params = None 5080 # HTTP header `Accept` 5081 header_params['Accept'] = self.api_client.\ 5082 select_header_accept(['application/json']) 5083 5084 # Authentication setting 5085 auth_settings = [] 5086 5087 return self.api_client.call_api(resource_path, 'DELETE', 5088 path_params, 5089 query_params, 5090 header_params, 5091 body=body_params, 5092 post_params=form_params, 5093 files=local_var_files, 5094 response_type='Recipients', 5095 auth_settings=auth_settings, 5096 callback=params.get('callback'), 5097 _return_http_data_only=params.get('_return_http_data_only'), 5098 _preload_content=params.get('_preload_content', True), 5099 _request_timeout=params.get('_request_timeout'), 5100 collection_formats=collection_formats) 5101 5102 def delete_recipients(self, account_id, envelope_id, **kwargs): 5103 """ 5104 Deletes recipients from an envelope. 5105 Deletes one or more recipients from a draft or sent envelope. Recipients to be deleted are listed in the request, with the `recipientId` being used as the key for deleting recipients. If the envelope is `In Process`, meaning that it has been sent and has not been completed or voided, recipients that have completed their actions cannot be deleted. 5106 This method makes a synchronous HTTP request by default. To make an 5107 asynchronous HTTP request, please define a `callback` function 5108 to be invoked when receiving the response. 5109 >>> def callback_function(response): 5110 >>> pprint(response) 5111 >>> 5112 >>> thread = api.delete_recipients(account_id, envelope_id, callback=callback_function) 5113 5114 :param callback function: The callback function 5115 for asynchronous request. (optional) 5116 :param str account_id: The external account number (int) or account ID Guid. (required) 5117 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5118 :param Recipients recipients: 5119 :return: Recipients 5120 If the method is called asynchronously, 5121 returns the request thread. 5122 """ 5123 kwargs['_return_http_data_only'] = True 5124 if kwargs.get('callback'): 5125 return self.delete_recipients_with_http_info(account_id, envelope_id, **kwargs) 5126 else: 5127 (data) = self.delete_recipients_with_http_info(account_id, envelope_id, **kwargs) 5128 return data 5129 5130 def delete_recipients_with_http_info(self, account_id, envelope_id, **kwargs): 5131 """ 5132 Deletes recipients from an envelope. 5133 Deletes one or more recipients from a draft or sent envelope. Recipients to be deleted are listed in the request, with the `recipientId` being used as the key for deleting recipients. If the envelope is `In Process`, meaning that it has been sent and has not been completed or voided, recipients that have completed their actions cannot be deleted. 5134 This method makes a synchronous HTTP request by default. To make an 5135 asynchronous HTTP request, please define a `callback` function 5136 to be invoked when receiving the response. 5137 >>> def callback_function(response): 5138 >>> pprint(response) 5139 >>> 5140 >>> thread = api.delete_recipients_with_http_info(account_id, envelope_id, callback=callback_function) 5141 5142 :param callback function: The callback function 5143 for asynchronous request. (optional) 5144 :param str account_id: The external account number (int) or account ID Guid. (required) 5145 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5146 :param Recipients recipients: 5147 :return: Recipients 5148 If the method is called asynchronously, 5149 returns the request thread. 5150 """ 5151 5152 all_params = ['account_id', 'envelope_id', 'recipients'] 5153 all_params.append('callback') 5154 all_params.append('_return_http_data_only') 5155 all_params.append('_preload_content') 5156 all_params.append('_request_timeout') 5157 5158 params = locals() 5159 for key, val in iteritems(params['kwargs']): 5160 if key not in all_params: 5161 raise TypeError( 5162 "Got an unexpected keyword argument '%s'" 5163 " to method delete_recipients" % key 5164 ) 5165 params[key] = val 5166 del params['kwargs'] 5167 # verify the required parameter 'account_id' is set 5168 if ('account_id' not in params) or (params['account_id'] is None): 5169 raise ValueError("Missing the required parameter `account_id` when calling `delete_recipients`") 5170 # verify the required parameter 'envelope_id' is set 5171 if ('envelope_id' not in params) or (params['envelope_id'] is None): 5172 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_recipients`") 5173 5174 5175 collection_formats = {} 5176 5177 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients'.replace('{format}', 'json') 5178 path_params = {} 5179 if 'account_id' in params: 5180 path_params['accountId'] = params['account_id'] 5181 if 'envelope_id' in params: 5182 path_params['envelopeId'] = params['envelope_id'] 5183 5184 query_params = {} 5185 5186 header_params = {} 5187 5188 form_params = [] 5189 local_var_files = {} 5190 5191 body_params = None 5192 if 'recipients' in params: 5193 body_params = params['recipients'] 5194 # HTTP header `Accept` 5195 header_params['Accept'] = self.api_client.\ 5196 select_header_accept(['application/json']) 5197 5198 # Authentication setting 5199 auth_settings = [] 5200 5201 return self.api_client.call_api(resource_path, 'DELETE', 5202 path_params, 5203 query_params, 5204 header_params, 5205 body=body_params, 5206 post_params=form_params, 5207 files=local_var_files, 5208 response_type='Recipients', 5209 auth_settings=auth_settings, 5210 callback=params.get('callback'), 5211 _return_http_data_only=params.get('_return_http_data_only'), 5212 _preload_content=params.get('_preload_content', True), 5213 _request_timeout=params.get('_request_timeout'), 5214 collection_formats=collection_formats) 5215 5216 def delete_tabs(self, account_id, envelope_id, recipient_id, **kwargs): 5217 """ 5218 Deletes the tabs associated with a recipient. 5219 Deletes one or more tabs associated with a recipient in a draft envelope. 5220 This method makes a synchronous HTTP request by default. To make an 5221 asynchronous HTTP request, please define a `callback` function 5222 to be invoked when receiving the response. 5223 >>> def callback_function(response): 5224 >>> pprint(response) 5225 >>> 5226 >>> thread = api.delete_tabs(account_id, envelope_id, recipient_id, callback=callback_function) 5227 5228 :param callback function: The callback function 5229 for asynchronous request. (optional) 5230 :param str account_id: The external account number (int) or account ID Guid. (required) 5231 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5232 :param str recipient_id: The ID of the recipient being accessed. (required) 5233 :param Tabs tabs: 5234 :return: Tabs 5235 If the method is called asynchronously, 5236 returns the request thread. 5237 """ 5238 kwargs['_return_http_data_only'] = True 5239 if kwargs.get('callback'): 5240 return self.delete_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 5241 else: 5242 (data) = self.delete_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 5243 return data 5244 5245 def delete_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 5246 """ 5247 Deletes the tabs associated with a recipient. 5248 Deletes one or more tabs associated with a recipient in a draft envelope. 5249 This method makes a synchronous HTTP request by default. To make an 5250 asynchronous HTTP request, please define a `callback` function 5251 to be invoked when receiving the response. 5252 >>> def callback_function(response): 5253 >>> pprint(response) 5254 >>> 5255 >>> thread = api.delete_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 5256 5257 :param callback function: The callback function 5258 for asynchronous request. (optional) 5259 :param str account_id: The external account number (int) or account ID Guid. (required) 5260 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5261 :param str recipient_id: The ID of the recipient being accessed. (required) 5262 :param Tabs tabs: 5263 :return: Tabs 5264 If the method is called asynchronously, 5265 returns the request thread. 5266 """ 5267 5268 all_params = ['account_id', 'envelope_id', 'recipient_id', 'tabs'] 5269 all_params.append('callback') 5270 all_params.append('_return_http_data_only') 5271 all_params.append('_preload_content') 5272 all_params.append('_request_timeout') 5273 5274 params = locals() 5275 for key, val in iteritems(params['kwargs']): 5276 if key not in all_params: 5277 raise TypeError( 5278 "Got an unexpected keyword argument '%s'" 5279 " to method delete_tabs" % key 5280 ) 5281 params[key] = val 5282 del params['kwargs'] 5283 # verify the required parameter 'account_id' is set 5284 if ('account_id' not in params) or (params['account_id'] is None): 5285 raise ValueError("Missing the required parameter `account_id` when calling `delete_tabs`") 5286 # verify the required parameter 'envelope_id' is set 5287 if ('envelope_id' not in params) or (params['envelope_id'] is None): 5288 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_tabs`") 5289 # verify the required parameter 'recipient_id' is set 5290 if ('recipient_id' not in params) or (params['recipient_id'] is None): 5291 raise ValueError("Missing the required parameter `recipient_id` when calling `delete_tabs`") 5292 5293 5294 collection_formats = {} 5295 5296 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/tabs'.replace('{format}', 'json') 5297 path_params = {} 5298 if 'account_id' in params: 5299 path_params['accountId'] = params['account_id'] 5300 if 'envelope_id' in params: 5301 path_params['envelopeId'] = params['envelope_id'] 5302 if 'recipient_id' in params: 5303 path_params['recipientId'] = params['recipient_id'] 5304 5305 query_params = {} 5306 5307 header_params = {} 5308 5309 form_params = [] 5310 local_var_files = {} 5311 5312 body_params = None 5313 if 'tabs' in params: 5314 body_params = params['tabs'] 5315 # HTTP header `Accept` 5316 header_params['Accept'] = self.api_client.\ 5317 select_header_accept(['application/json']) 5318 5319 # Authentication setting 5320 auth_settings = [] 5321 5322 return self.api_client.call_api(resource_path, 'DELETE', 5323 path_params, 5324 query_params, 5325 header_params, 5326 body=body_params, 5327 post_params=form_params, 5328 files=local_var_files, 5329 response_type='Tabs', 5330 auth_settings=auth_settings, 5331 callback=params.get('callback'), 5332 _return_http_data_only=params.get('_return_http_data_only'), 5333 _preload_content=params.get('_preload_content', True), 5334 _request_timeout=params.get('_request_timeout'), 5335 collection_formats=collection_formats) 5336 5337 def delete_template_delayed_routing_definition(self, account_id, template_id, workflow_step_id, **kwargs): 5338 """ 5339 Deletes the delayed routing rules for the specified template workflow step. 5340 This method makes a synchronous HTTP request by default. To make an 5341 asynchronous HTTP request, please define a `callback` function 5342 to be invoked when receiving the response. 5343 >>> def callback_function(response): 5344 >>> pprint(response) 5345 >>> 5346 >>> thread = api.delete_template_delayed_routing_definition(account_id, template_id, workflow_step_id, callback=callback_function) 5347 5348 :param callback function: The callback function 5349 for asynchronous request. (optional) 5350 :param str account_id: The external account number (int) or account ID Guid. (required) 5351 :param str template_id: The ID of the template being accessed. (required) 5352 :param str workflow_step_id: (required) 5353 :return: None 5354 If the method is called asynchronously, 5355 returns the request thread. 5356 """ 5357 kwargs['_return_http_data_only'] = True 5358 if kwargs.get('callback'): 5359 return self.delete_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 5360 else: 5361 (data) = self.delete_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 5362 return data 5363 5364 def delete_template_delayed_routing_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 5365 """ 5366 Deletes the delayed routing rules for the specified template workflow step. 5367 This method makes a synchronous HTTP request by default. To make an 5368 asynchronous HTTP request, please define a `callback` function 5369 to be invoked when receiving the response. 5370 >>> def callback_function(response): 5371 >>> pprint(response) 5372 >>> 5373 >>> thread = api.delete_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 5374 5375 :param callback function: The callback function 5376 for asynchronous request. (optional) 5377 :param str account_id: The external account number (int) or account ID Guid. (required) 5378 :param str template_id: The ID of the template being accessed. (required) 5379 :param str workflow_step_id: (required) 5380 :return: None 5381 If the method is called asynchronously, 5382 returns the request thread. 5383 """ 5384 5385 all_params = ['account_id', 'template_id', 'workflow_step_id'] 5386 all_params.append('callback') 5387 all_params.append('_return_http_data_only') 5388 all_params.append('_preload_content') 5389 all_params.append('_request_timeout') 5390 5391 params = locals() 5392 for key, val in iteritems(params['kwargs']): 5393 if key not in all_params: 5394 raise TypeError( 5395 "Got an unexpected keyword argument '%s'" 5396 " to method delete_template_delayed_routing_definition" % key 5397 ) 5398 params[key] = val 5399 del params['kwargs'] 5400 # verify the required parameter 'account_id' is set 5401 if ('account_id' not in params) or (params['account_id'] is None): 5402 raise ValueError("Missing the required parameter `account_id` when calling `delete_template_delayed_routing_definition`") 5403 # verify the required parameter 'template_id' is set 5404 if ('template_id' not in params) or (params['template_id'] is None): 5405 raise ValueError("Missing the required parameter `template_id` when calling `delete_template_delayed_routing_definition`") 5406 # verify the required parameter 'workflow_step_id' is set 5407 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 5408 raise ValueError("Missing the required parameter `workflow_step_id` when calling `delete_template_delayed_routing_definition`") 5409 5410 5411 collection_formats = {} 5412 5413 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 5414 path_params = {} 5415 if 'account_id' in params: 5416 path_params['accountId'] = params['account_id'] 5417 if 'template_id' in params: 5418 path_params['templateId'] = params['template_id'] 5419 if 'workflow_step_id' in params: 5420 path_params['workflowStepId'] = params['workflow_step_id'] 5421 5422 query_params = {} 5423 5424 header_params = {} 5425 5426 form_params = [] 5427 local_var_files = {} 5428 5429 body_params = None 5430 # HTTP header `Accept` 5431 header_params['Accept'] = self.api_client.\ 5432 select_header_accept(['application/json']) 5433 5434 # Authentication setting 5435 auth_settings = [] 5436 5437 return self.api_client.call_api(resource_path, 'DELETE', 5438 path_params, 5439 query_params, 5440 header_params, 5441 body=body_params, 5442 post_params=form_params, 5443 files=local_var_files, 5444 response_type=None, 5445 auth_settings=auth_settings, 5446 callback=params.get('callback'), 5447 _return_http_data_only=params.get('_return_http_data_only'), 5448 _preload_content=params.get('_preload_content', True), 5449 _request_timeout=params.get('_request_timeout'), 5450 collection_formats=collection_formats) 5451 5452 def delete_template_scheduled_sending_definition(self, account_id, template_id, **kwargs): 5453 """ 5454 Deletes the scheduled sending rules for the template's workflow. 5455 This method makes a synchronous HTTP request by default. To make an 5456 asynchronous HTTP request, please define a `callback` function 5457 to be invoked when receiving the response. 5458 >>> def callback_function(response): 5459 >>> pprint(response) 5460 >>> 5461 >>> thread = api.delete_template_scheduled_sending_definition(account_id, template_id, callback=callback_function) 5462 5463 :param callback function: The callback function 5464 for asynchronous request. (optional) 5465 :param str account_id: The external account number (int) or account ID Guid. (required) 5466 :param str template_id: The ID of the template being accessed. (required) 5467 :return: None 5468 If the method is called asynchronously, 5469 returns the request thread. 5470 """ 5471 kwargs['_return_http_data_only'] = True 5472 if kwargs.get('callback'): 5473 return self.delete_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 5474 else: 5475 (data) = self.delete_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 5476 return data 5477 5478 def delete_template_scheduled_sending_definition_with_http_info(self, account_id, template_id, **kwargs): 5479 """ 5480 Deletes the scheduled sending rules for the template's workflow. 5481 This method makes a synchronous HTTP request by default. To make an 5482 asynchronous HTTP request, please define a `callback` function 5483 to be invoked when receiving the response. 5484 >>> def callback_function(response): 5485 >>> pprint(response) 5486 >>> 5487 >>> thread = api.delete_template_scheduled_sending_definition_with_http_info(account_id, template_id, callback=callback_function) 5488 5489 :param callback function: The callback function 5490 for asynchronous request. (optional) 5491 :param str account_id: The external account number (int) or account ID Guid. (required) 5492 :param str template_id: The ID of the template being accessed. (required) 5493 :return: None 5494 If the method is called asynchronously, 5495 returns the request thread. 5496 """ 5497 5498 all_params = ['account_id', 'template_id'] 5499 all_params.append('callback') 5500 all_params.append('_return_http_data_only') 5501 all_params.append('_preload_content') 5502 all_params.append('_request_timeout') 5503 5504 params = locals() 5505 for key, val in iteritems(params['kwargs']): 5506 if key not in all_params: 5507 raise TypeError( 5508 "Got an unexpected keyword argument '%s'" 5509 " to method delete_template_scheduled_sending_definition" % key 5510 ) 5511 params[key] = val 5512 del params['kwargs'] 5513 # verify the required parameter 'account_id' is set 5514 if ('account_id' not in params) or (params['account_id'] is None): 5515 raise ValueError("Missing the required parameter `account_id` when calling `delete_template_scheduled_sending_definition`") 5516 # verify the required parameter 'template_id' is set 5517 if ('template_id' not in params) or (params['template_id'] is None): 5518 raise ValueError("Missing the required parameter `template_id` when calling `delete_template_scheduled_sending_definition`") 5519 5520 5521 collection_formats = {} 5522 5523 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/scheduledSending'.replace('{format}', 'json') 5524 path_params = {} 5525 if 'account_id' in params: 5526 path_params['accountId'] = params['account_id'] 5527 if 'template_id' in params: 5528 path_params['templateId'] = params['template_id'] 5529 5530 query_params = {} 5531 5532 header_params = {} 5533 5534 form_params = [] 5535 local_var_files = {} 5536 5537 body_params = None 5538 # HTTP header `Accept` 5539 header_params['Accept'] = self.api_client.\ 5540 select_header_accept(['application/json']) 5541 5542 # Authentication setting 5543 auth_settings = [] 5544 5545 return self.api_client.call_api(resource_path, 'DELETE', 5546 path_params, 5547 query_params, 5548 header_params, 5549 body=body_params, 5550 post_params=form_params, 5551 files=local_var_files, 5552 response_type=None, 5553 auth_settings=auth_settings, 5554 callback=params.get('callback'), 5555 _return_http_data_only=params.get('_return_http_data_only'), 5556 _preload_content=params.get('_preload_content', True), 5557 _request_timeout=params.get('_request_timeout'), 5558 collection_formats=collection_formats) 5559 5560 def delete_template_workflow_definition(self, account_id, template_id, **kwargs): 5561 """ 5562 Delete the workflow definition for a template. 5563 Deletes the specified template's workflow definition if it has one. 5564 This method makes a synchronous HTTP request by default. To make an 5565 asynchronous HTTP request, please define a `callback` function 5566 to be invoked when receiving the response. 5567 >>> def callback_function(response): 5568 >>> pprint(response) 5569 >>> 5570 >>> thread = api.delete_template_workflow_definition(account_id, template_id, callback=callback_function) 5571 5572 :param callback function: The callback function 5573 for asynchronous request. (optional) 5574 :param str account_id: The external account number (int) or account ID Guid. (required) 5575 :param str template_id: The ID of the template being accessed. (required) 5576 :return: None 5577 If the method is called asynchronously, 5578 returns the request thread. 5579 """ 5580 kwargs['_return_http_data_only'] = True 5581 if kwargs.get('callback'): 5582 return self.delete_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 5583 else: 5584 (data) = self.delete_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 5585 return data 5586 5587 def delete_template_workflow_definition_with_http_info(self, account_id, template_id, **kwargs): 5588 """ 5589 Delete the workflow definition for a template. 5590 Deletes the specified template's workflow definition if it has one. 5591 This method makes a synchronous HTTP request by default. To make an 5592 asynchronous HTTP request, please define a `callback` function 5593 to be invoked when receiving the response. 5594 >>> def callback_function(response): 5595 >>> pprint(response) 5596 >>> 5597 >>> thread = api.delete_template_workflow_definition_with_http_info(account_id, template_id, callback=callback_function) 5598 5599 :param callback function: The callback function 5600 for asynchronous request. (optional) 5601 :param str account_id: The external account number (int) or account ID Guid. (required) 5602 :param str template_id: The ID of the template being accessed. (required) 5603 :return: None 5604 If the method is called asynchronously, 5605 returns the request thread. 5606 """ 5607 5608 all_params = ['account_id', 'template_id'] 5609 all_params.append('callback') 5610 all_params.append('_return_http_data_only') 5611 all_params.append('_preload_content') 5612 all_params.append('_request_timeout') 5613 5614 params = locals() 5615 for key, val in iteritems(params['kwargs']): 5616 if key not in all_params: 5617 raise TypeError( 5618 "Got an unexpected keyword argument '%s'" 5619 " to method delete_template_workflow_definition" % key 5620 ) 5621 params[key] = val 5622 del params['kwargs'] 5623 # verify the required parameter 'account_id' is set 5624 if ('account_id' not in params) or (params['account_id'] is None): 5625 raise ValueError("Missing the required parameter `account_id` when calling `delete_template_workflow_definition`") 5626 # verify the required parameter 'template_id' is set 5627 if ('template_id' not in params) or (params['template_id'] is None): 5628 raise ValueError("Missing the required parameter `template_id` when calling `delete_template_workflow_definition`") 5629 5630 5631 collection_formats = {} 5632 5633 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow'.replace('{format}', 'json') 5634 path_params = {} 5635 if 'account_id' in params: 5636 path_params['accountId'] = params['account_id'] 5637 if 'template_id' in params: 5638 path_params['templateId'] = params['template_id'] 5639 5640 query_params = {} 5641 5642 header_params = {} 5643 5644 form_params = [] 5645 local_var_files = {} 5646 5647 body_params = None 5648 # HTTP header `Accept` 5649 header_params['Accept'] = self.api_client.\ 5650 select_header_accept(['application/json']) 5651 5652 # Authentication setting 5653 auth_settings = [] 5654 5655 return self.api_client.call_api(resource_path, 'DELETE', 5656 path_params, 5657 query_params, 5658 header_params, 5659 body=body_params, 5660 post_params=form_params, 5661 files=local_var_files, 5662 response_type=None, 5663 auth_settings=auth_settings, 5664 callback=params.get('callback'), 5665 _return_http_data_only=params.get('_return_http_data_only'), 5666 _preload_content=params.get('_preload_content', True), 5667 _request_timeout=params.get('_request_timeout'), 5668 collection_formats=collection_formats) 5669 5670 def delete_template_workflow_step_definition(self, account_id, template_id, workflow_step_id, **kwargs): 5671 """ 5672 Deletes the workflow step definition for an template's workflow by step id. 5673 This method makes a synchronous HTTP request by default. To make an 5674 asynchronous HTTP request, please define a `callback` function 5675 to be invoked when receiving the response. 5676 >>> def callback_function(response): 5677 >>> pprint(response) 5678 >>> 5679 >>> thread = api.delete_template_workflow_step_definition(account_id, template_id, workflow_step_id, callback=callback_function) 5680 5681 :param callback function: The callback function 5682 for asynchronous request. (optional) 5683 :param str account_id: The external account number (int) or account ID Guid. (required) 5684 :param str template_id: The ID of the template being accessed. (required) 5685 :param str workflow_step_id: (required) 5686 :return: None 5687 If the method is called asynchronously, 5688 returns the request thread. 5689 """ 5690 kwargs['_return_http_data_only'] = True 5691 if kwargs.get('callback'): 5692 return self.delete_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 5693 else: 5694 (data) = self.delete_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 5695 return data 5696 5697 def delete_template_workflow_step_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 5698 """ 5699 Deletes the workflow step definition for an template's workflow by step id. 5700 This method makes a synchronous HTTP request by default. To make an 5701 asynchronous HTTP request, please define a `callback` function 5702 to be invoked when receiving the response. 5703 >>> def callback_function(response): 5704 >>> pprint(response) 5705 >>> 5706 >>> thread = api.delete_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 5707 5708 :param callback function: The callback function 5709 for asynchronous request. (optional) 5710 :param str account_id: The external account number (int) or account ID Guid. (required) 5711 :param str template_id: The ID of the template being accessed. (required) 5712 :param str workflow_step_id: (required) 5713 :return: None 5714 If the method is called asynchronously, 5715 returns the request thread. 5716 """ 5717 5718 all_params = ['account_id', 'template_id', 'workflow_step_id'] 5719 all_params.append('callback') 5720 all_params.append('_return_http_data_only') 5721 all_params.append('_preload_content') 5722 all_params.append('_request_timeout') 5723 5724 params = locals() 5725 for key, val in iteritems(params['kwargs']): 5726 if key not in all_params: 5727 raise TypeError( 5728 "Got an unexpected keyword argument '%s'" 5729 " to method delete_template_workflow_step_definition" % key 5730 ) 5731 params[key] = val 5732 del params['kwargs'] 5733 # verify the required parameter 'account_id' is set 5734 if ('account_id' not in params) or (params['account_id'] is None): 5735 raise ValueError("Missing the required parameter `account_id` when calling `delete_template_workflow_step_definition`") 5736 # verify the required parameter 'template_id' is set 5737 if ('template_id' not in params) or (params['template_id'] is None): 5738 raise ValueError("Missing the required parameter `template_id` when calling `delete_template_workflow_step_definition`") 5739 # verify the required parameter 'workflow_step_id' is set 5740 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 5741 raise ValueError("Missing the required parameter `workflow_step_id` when calling `delete_template_workflow_step_definition`") 5742 5743 5744 collection_formats = {} 5745 5746 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 5747 path_params = {} 5748 if 'account_id' in params: 5749 path_params['accountId'] = params['account_id'] 5750 if 'template_id' in params: 5751 path_params['templateId'] = params['template_id'] 5752 if 'workflow_step_id' in params: 5753 path_params['workflowStepId'] = params['workflow_step_id'] 5754 5755 query_params = {} 5756 5757 header_params = {} 5758 5759 form_params = [] 5760 local_var_files = {} 5761 5762 body_params = None 5763 # HTTP header `Accept` 5764 header_params['Accept'] = self.api_client.\ 5765 select_header_accept(['application/json']) 5766 5767 # Authentication setting 5768 auth_settings = [] 5769 5770 return self.api_client.call_api(resource_path, 'DELETE', 5771 path_params, 5772 query_params, 5773 header_params, 5774 body=body_params, 5775 post_params=form_params, 5776 files=local_var_files, 5777 response_type=None, 5778 auth_settings=auth_settings, 5779 callback=params.get('callback'), 5780 _return_http_data_only=params.get('_return_http_data_only'), 5781 _preload_content=params.get('_preload_content', True), 5782 _request_timeout=params.get('_request_timeout'), 5783 collection_formats=collection_formats) 5784 5785 def delete_templates_from_document(self, account_id, document_id, envelope_id, template_id, **kwargs): 5786 """ 5787 Deletes a template from a document in an existing envelope. 5788 Deletes the specified template from a document in an existing envelope. 5789 This method makes a synchronous HTTP request by default. To make an 5790 asynchronous HTTP request, please define a `callback` function 5791 to be invoked when receiving the response. 5792 >>> def callback_function(response): 5793 >>> pprint(response) 5794 >>> 5795 >>> thread = api.delete_templates_from_document(account_id, document_id, envelope_id, template_id, callback=callback_function) 5796 5797 :param callback function: The callback function 5798 for asynchronous request. (optional) 5799 :param str account_id: The external account number (int) or account ID Guid. (required) 5800 :param str document_id: The ID of the document being accessed. (required) 5801 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5802 :param str template_id: The ID of the template being accessed. (required) 5803 :return: None 5804 If the method is called asynchronously, 5805 returns the request thread. 5806 """ 5807 kwargs['_return_http_data_only'] = True 5808 if kwargs.get('callback'): 5809 return self.delete_templates_from_document_with_http_info(account_id, document_id, envelope_id, template_id, **kwargs) 5810 else: 5811 (data) = self.delete_templates_from_document_with_http_info(account_id, document_id, envelope_id, template_id, **kwargs) 5812 return data 5813 5814 def delete_templates_from_document_with_http_info(self, account_id, document_id, envelope_id, template_id, **kwargs): 5815 """ 5816 Deletes a template from a document in an existing envelope. 5817 Deletes the specified template from a document in an existing envelope. 5818 This method makes a synchronous HTTP request by default. To make an 5819 asynchronous HTTP request, please define a `callback` function 5820 to be invoked when receiving the response. 5821 >>> def callback_function(response): 5822 >>> pprint(response) 5823 >>> 5824 >>> thread = api.delete_templates_from_document_with_http_info(account_id, document_id, envelope_id, template_id, callback=callback_function) 5825 5826 :param callback function: The callback function 5827 for asynchronous request. (optional) 5828 :param str account_id: The external account number (int) or account ID Guid. (required) 5829 :param str document_id: The ID of the document being accessed. (required) 5830 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5831 :param str template_id: The ID of the template being accessed. (required) 5832 :return: None 5833 If the method is called asynchronously, 5834 returns the request thread. 5835 """ 5836 5837 all_params = ['account_id', 'document_id', 'envelope_id', 'template_id'] 5838 all_params.append('callback') 5839 all_params.append('_return_http_data_only') 5840 all_params.append('_preload_content') 5841 all_params.append('_request_timeout') 5842 5843 params = locals() 5844 for key, val in iteritems(params['kwargs']): 5845 if key not in all_params: 5846 raise TypeError( 5847 "Got an unexpected keyword argument '%s'" 5848 " to method delete_templates_from_document" % key 5849 ) 5850 params[key] = val 5851 del params['kwargs'] 5852 # verify the required parameter 'account_id' is set 5853 if ('account_id' not in params) or (params['account_id'] is None): 5854 raise ValueError("Missing the required parameter `account_id` when calling `delete_templates_from_document`") 5855 # verify the required parameter 'document_id' is set 5856 if ('document_id' not in params) or (params['document_id'] is None): 5857 raise ValueError("Missing the required parameter `document_id` when calling `delete_templates_from_document`") 5858 # verify the required parameter 'envelope_id' is set 5859 if ('envelope_id' not in params) or (params['envelope_id'] is None): 5860 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_templates_from_document`") 5861 # verify the required parameter 'template_id' is set 5862 if ('template_id' not in params) or (params['template_id'] is None): 5863 raise ValueError("Missing the required parameter `template_id` when calling `delete_templates_from_document`") 5864 5865 5866 collection_formats = {} 5867 5868 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/templates/{templateId}'.replace('{format}', 'json') 5869 path_params = {} 5870 if 'account_id' in params: 5871 path_params['accountId'] = params['account_id'] 5872 if 'document_id' in params: 5873 path_params['documentId'] = params['document_id'] 5874 if 'envelope_id' in params: 5875 path_params['envelopeId'] = params['envelope_id'] 5876 if 'template_id' in params: 5877 path_params['templateId'] = params['template_id'] 5878 5879 query_params = {} 5880 5881 header_params = {} 5882 5883 form_params = [] 5884 local_var_files = {} 5885 5886 body_params = None 5887 # HTTP header `Accept` 5888 header_params['Accept'] = self.api_client.\ 5889 select_header_accept(['application/json']) 5890 5891 # Authentication setting 5892 auth_settings = [] 5893 5894 return self.api_client.call_api(resource_path, 'DELETE', 5895 path_params, 5896 query_params, 5897 header_params, 5898 body=body_params, 5899 post_params=form_params, 5900 files=local_var_files, 5901 response_type=None, 5902 auth_settings=auth_settings, 5903 callback=params.get('callback'), 5904 _return_http_data_only=params.get('_return_http_data_only'), 5905 _preload_content=params.get('_preload_content', True), 5906 _request_timeout=params.get('_request_timeout'), 5907 collection_formats=collection_formats) 5908 5909 def get_attachment(self, account_id, attachment_id, envelope_id, **kwargs): 5910 """ 5911 Retrieves an attachment from the envelope. 5912 Retrieves an attachment from an envelope. 5913 This method makes a synchronous HTTP request by default. To make an 5914 asynchronous HTTP request, please define a `callback` function 5915 to be invoked when receiving the response. 5916 >>> def callback_function(response): 5917 >>> pprint(response) 5918 >>> 5919 >>> thread = api.get_attachment(account_id, attachment_id, envelope_id, callback=callback_function) 5920 5921 :param callback function: The callback function 5922 for asynchronous request. (optional) 5923 :param str account_id: The external account number (int) or account ID Guid. (required) 5924 :param str attachment_id: (required) 5925 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5926 :return: file 5927 If the method is called asynchronously, 5928 returns the request thread. 5929 """ 5930 kwargs['_return_http_data_only'] = True 5931 if kwargs.get('callback'): 5932 return self.get_attachment_with_http_info(account_id, attachment_id, envelope_id, **kwargs) 5933 else: 5934 (data) = self.get_attachment_with_http_info(account_id, attachment_id, envelope_id, **kwargs) 5935 return data 5936 5937 def get_attachment_with_http_info(self, account_id, attachment_id, envelope_id, **kwargs): 5938 """ 5939 Retrieves an attachment from the envelope. 5940 Retrieves an attachment from an envelope. 5941 This method makes a synchronous HTTP request by default. To make an 5942 asynchronous HTTP request, please define a `callback` function 5943 to be invoked when receiving the response. 5944 >>> def callback_function(response): 5945 >>> pprint(response) 5946 >>> 5947 >>> thread = api.get_attachment_with_http_info(account_id, attachment_id, envelope_id, callback=callback_function) 5948 5949 :param callback function: The callback function 5950 for asynchronous request. (optional) 5951 :param str account_id: The external account number (int) or account ID Guid. (required) 5952 :param str attachment_id: (required) 5953 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5954 :return: file 5955 If the method is called asynchronously, 5956 returns the request thread. 5957 """ 5958 5959 all_params = ['account_id', 'attachment_id', 'envelope_id'] 5960 all_params.append('callback') 5961 all_params.append('_return_http_data_only') 5962 all_params.append('_preload_content') 5963 all_params.append('_request_timeout') 5964 5965 params = locals() 5966 for key, val in iteritems(params['kwargs']): 5967 if key not in all_params: 5968 raise TypeError( 5969 "Got an unexpected keyword argument '%s'" 5970 " to method get_attachment" % key 5971 ) 5972 params[key] = val 5973 del params['kwargs'] 5974 # verify the required parameter 'account_id' is set 5975 if ('account_id' not in params) or (params['account_id'] is None): 5976 raise ValueError("Missing the required parameter `account_id` when calling `get_attachment`") 5977 # verify the required parameter 'attachment_id' is set 5978 if ('attachment_id' not in params) or (params['attachment_id'] is None): 5979 raise ValueError("Missing the required parameter `attachment_id` when calling `get_attachment`") 5980 # verify the required parameter 'envelope_id' is set 5981 if ('envelope_id' not in params) or (params['envelope_id'] is None): 5982 raise ValueError("Missing the required parameter `envelope_id` when calling `get_attachment`") 5983 5984 5985 collection_formats = {} 5986 5987 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments/{attachmentId}'.replace('{format}', 'json') 5988 path_params = {} 5989 if 'account_id' in params: 5990 path_params['accountId'] = params['account_id'] 5991 if 'attachment_id' in params: 5992 path_params['attachmentId'] = params['attachment_id'] 5993 if 'envelope_id' in params: 5994 path_params['envelopeId'] = params['envelope_id'] 5995 5996 query_params = {} 5997 5998 header_params = {} 5999 6000 form_params = [] 6001 local_var_files = {} 6002 6003 body_params = None 6004 # HTTP header `Accept` 6005 header_params['Accept'] = self.api_client.\ 6006 select_header_accept(['application/octet-stream']) 6007 6008 # Authentication setting 6009 auth_settings = [] 6010 6011 return self.api_client.call_api(resource_path, 'GET', 6012 path_params, 6013 query_params, 6014 header_params, 6015 body=body_params, 6016 post_params=form_params, 6017 files=local_var_files, 6018 response_type='file', 6019 auth_settings=auth_settings, 6020 callback=params.get('callback'), 6021 _return_http_data_only=params.get('_return_http_data_only'), 6022 _preload_content=params.get('_preload_content', True), 6023 _request_timeout=params.get('_request_timeout'), 6024 collection_formats=collection_formats) 6025 6026 def get_attachments(self, account_id, envelope_id, **kwargs): 6027 """ 6028 Returns a list of attachments associated with the specified envelope 6029 Returns a list of attachments associated with a specified envelope 6030 This method makes a synchronous HTTP request by default. To make an 6031 asynchronous HTTP request, please define a `callback` function 6032 to be invoked when receiving the response. 6033 >>> def callback_function(response): 6034 >>> pprint(response) 6035 >>> 6036 >>> thread = api.get_attachments(account_id, envelope_id, callback=callback_function) 6037 6038 :param callback function: The callback function 6039 for asynchronous request. (optional) 6040 :param str account_id: The external account number (int) or account ID Guid. (required) 6041 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6042 :return: EnvelopeAttachmentsResult 6043 If the method is called asynchronously, 6044 returns the request thread. 6045 """ 6046 kwargs['_return_http_data_only'] = True 6047 if kwargs.get('callback'): 6048 return self.get_attachments_with_http_info(account_id, envelope_id, **kwargs) 6049 else: 6050 (data) = self.get_attachments_with_http_info(account_id, envelope_id, **kwargs) 6051 return data 6052 6053 def get_attachments_with_http_info(self, account_id, envelope_id, **kwargs): 6054 """ 6055 Returns a list of attachments associated with the specified envelope 6056 Returns a list of attachments associated with a specified envelope 6057 This method makes a synchronous HTTP request by default. To make an 6058 asynchronous HTTP request, please define a `callback` function 6059 to be invoked when receiving the response. 6060 >>> def callback_function(response): 6061 >>> pprint(response) 6062 >>> 6063 >>> thread = api.get_attachments_with_http_info(account_id, envelope_id, callback=callback_function) 6064 6065 :param callback function: The callback function 6066 for asynchronous request. (optional) 6067 :param str account_id: The external account number (int) or account ID Guid. (required) 6068 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6069 :return: EnvelopeAttachmentsResult 6070 If the method is called asynchronously, 6071 returns the request thread. 6072 """ 6073 6074 all_params = ['account_id', 'envelope_id'] 6075 all_params.append('callback') 6076 all_params.append('_return_http_data_only') 6077 all_params.append('_preload_content') 6078 all_params.append('_request_timeout') 6079 6080 params = locals() 6081 for key, val in iteritems(params['kwargs']): 6082 if key not in all_params: 6083 raise TypeError( 6084 "Got an unexpected keyword argument '%s'" 6085 " to method get_attachments" % key 6086 ) 6087 params[key] = val 6088 del params['kwargs'] 6089 # verify the required parameter 'account_id' is set 6090 if ('account_id' not in params) or (params['account_id'] is None): 6091 raise ValueError("Missing the required parameter `account_id` when calling `get_attachments`") 6092 # verify the required parameter 'envelope_id' is set 6093 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6094 raise ValueError("Missing the required parameter `envelope_id` when calling `get_attachments`") 6095 6096 6097 collection_formats = {} 6098 6099 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments'.replace('{format}', 'json') 6100 path_params = {} 6101 if 'account_id' in params: 6102 path_params['accountId'] = params['account_id'] 6103 if 'envelope_id' in params: 6104 path_params['envelopeId'] = params['envelope_id'] 6105 6106 query_params = {} 6107 6108 header_params = {} 6109 6110 form_params = [] 6111 local_var_files = {} 6112 6113 body_params = None 6114 # HTTP header `Accept` 6115 header_params['Accept'] = self.api_client.\ 6116 select_header_accept(['application/json']) 6117 6118 # Authentication setting 6119 auth_settings = [] 6120 6121 return self.api_client.call_api(resource_path, 'GET', 6122 path_params, 6123 query_params, 6124 header_params, 6125 body=body_params, 6126 post_params=form_params, 6127 files=local_var_files, 6128 response_type='EnvelopeAttachmentsResult', 6129 auth_settings=auth_settings, 6130 callback=params.get('callback'), 6131 _return_http_data_only=params.get('_return_http_data_only'), 6132 _preload_content=params.get('_preload_content', True), 6133 _request_timeout=params.get('_request_timeout'), 6134 collection_formats=collection_formats) 6135 6136 def get_chunked_upload(self, account_id, chunked_upload_id, **kwargs): 6137 """ 6138 Retrieves the current metadata of a ChunkedUpload. 6139 Returns the details (but not the content) about a chunked upload. **Note:** You cannot obtain details about a chunked upload that has expired, been deleted, or consumed by other actions. 6140 This method makes a synchronous HTTP request by default. To make an 6141 asynchronous HTTP request, please define a `callback` function 6142 to be invoked when receiving the response. 6143 >>> def callback_function(response): 6144 >>> pprint(response) 6145 >>> 6146 >>> thread = api.get_chunked_upload(account_id, chunked_upload_id, callback=callback_function) 6147 6148 :param callback function: The callback function 6149 for asynchronous request. (optional) 6150 :param str account_id: The external account number (int) or account ID Guid. (required) 6151 :param str chunked_upload_id: (required) 6152 :param str include: 6153 :return: ChunkedUploadResponse 6154 If the method is called asynchronously, 6155 returns the request thread. 6156 """ 6157 kwargs['_return_http_data_only'] = True 6158 if kwargs.get('callback'): 6159 return self.get_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 6160 else: 6161 (data) = self.get_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 6162 return data 6163 6164 def get_chunked_upload_with_http_info(self, account_id, chunked_upload_id, **kwargs): 6165 """ 6166 Retrieves the current metadata of a ChunkedUpload. 6167 Returns the details (but not the content) about a chunked upload. **Note:** You cannot obtain details about a chunked upload that has expired, been deleted, or consumed by other actions. 6168 This method makes a synchronous HTTP request by default. To make an 6169 asynchronous HTTP request, please define a `callback` function 6170 to be invoked when receiving the response. 6171 >>> def callback_function(response): 6172 >>> pprint(response) 6173 >>> 6174 >>> thread = api.get_chunked_upload_with_http_info(account_id, chunked_upload_id, callback=callback_function) 6175 6176 :param callback function: The callback function 6177 for asynchronous request. (optional) 6178 :param str account_id: The external account number (int) or account ID Guid. (required) 6179 :param str chunked_upload_id: (required) 6180 :param str include: 6181 :return: ChunkedUploadResponse 6182 If the method is called asynchronously, 6183 returns the request thread. 6184 """ 6185 6186 all_params = ['account_id', 'chunked_upload_id', 'include'] 6187 all_params.append('callback') 6188 all_params.append('_return_http_data_only') 6189 all_params.append('_preload_content') 6190 all_params.append('_request_timeout') 6191 6192 params = locals() 6193 for key, val in iteritems(params['kwargs']): 6194 if key not in all_params: 6195 raise TypeError( 6196 "Got an unexpected keyword argument '%s'" 6197 " to method get_chunked_upload" % key 6198 ) 6199 params[key] = val 6200 del params['kwargs'] 6201 # verify the required parameter 'account_id' is set 6202 if ('account_id' not in params) or (params['account_id'] is None): 6203 raise ValueError("Missing the required parameter `account_id` when calling `get_chunked_upload`") 6204 # verify the required parameter 'chunked_upload_id' is set 6205 if ('chunked_upload_id' not in params) or (params['chunked_upload_id'] is None): 6206 raise ValueError("Missing the required parameter `chunked_upload_id` when calling `get_chunked_upload`") 6207 6208 6209 collection_formats = {} 6210 6211 resource_path = '/v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}'.replace('{format}', 'json') 6212 path_params = {} 6213 if 'account_id' in params: 6214 path_params['accountId'] = params['account_id'] 6215 if 'chunked_upload_id' in params: 6216 path_params['chunkedUploadId'] = params['chunked_upload_id'] 6217 6218 query_params = {} 6219 if 'include' in params: 6220 query_params['include'] = params['include'] 6221 6222 header_params = {} 6223 6224 form_params = [] 6225 local_var_files = {} 6226 6227 body_params = None 6228 # HTTP header `Accept` 6229 header_params['Accept'] = self.api_client.\ 6230 select_header_accept(['application/json']) 6231 6232 # Authentication setting 6233 auth_settings = [] 6234 6235 return self.api_client.call_api(resource_path, 'GET', 6236 path_params, 6237 query_params, 6238 header_params, 6239 body=body_params, 6240 post_params=form_params, 6241 files=local_var_files, 6242 response_type='ChunkedUploadResponse', 6243 auth_settings=auth_settings, 6244 callback=params.get('callback'), 6245 _return_http_data_only=params.get('_return_http_data_only'), 6246 _preload_content=params.get('_preload_content', True), 6247 _request_timeout=params.get('_request_timeout'), 6248 collection_formats=collection_formats) 6249 6250 def get_comments_transcript(self, account_id, envelope_id, **kwargs): 6251 """ 6252 Gets comment transcript for envelope and user 6253 Retrieves a PDF file containing all of the comments that senders and recipients have added to the documents in an envelope. The response body of this method is the PDF file as a byte stream. **Note:** Comments are disabled by default. To use the comments feature, an account administrator must enable comments on the account (in the `accountSettingsInformation` object, set the `enableSigningExtensionComments` property to **true**). 6254 This method makes a synchronous HTTP request by default. To make an 6255 asynchronous HTTP request, please define a `callback` function 6256 to be invoked when receiving the response. 6257 >>> def callback_function(response): 6258 >>> pprint(response) 6259 >>> 6260 >>> thread = api.get_comments_transcript(account_id, envelope_id, callback=callback_function) 6261 6262 :param callback function: The callback function 6263 for asynchronous request. (optional) 6264 :param str account_id: The external account number (int) or account ID Guid. (required) 6265 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6266 :param str encoding: 6267 :return: file 6268 If the method is called asynchronously, 6269 returns the request thread. 6270 """ 6271 kwargs['_return_http_data_only'] = True 6272 if kwargs.get('callback'): 6273 return self.get_comments_transcript_with_http_info(account_id, envelope_id, **kwargs) 6274 else: 6275 (data) = self.get_comments_transcript_with_http_info(account_id, envelope_id, **kwargs) 6276 return data 6277 6278 def get_comments_transcript_with_http_info(self, account_id, envelope_id, **kwargs): 6279 """ 6280 Gets comment transcript for envelope and user 6281 Retrieves a PDF file containing all of the comments that senders and recipients have added to the documents in an envelope. The response body of this method is the PDF file as a byte stream. **Note:** Comments are disabled by default. To use the comments feature, an account administrator must enable comments on the account (in the `accountSettingsInformation` object, set the `enableSigningExtensionComments` property to **true**). 6282 This method makes a synchronous HTTP request by default. To make an 6283 asynchronous HTTP request, please define a `callback` function 6284 to be invoked when receiving the response. 6285 >>> def callback_function(response): 6286 >>> pprint(response) 6287 >>> 6288 >>> thread = api.get_comments_transcript_with_http_info(account_id, envelope_id, callback=callback_function) 6289 6290 :param callback function: The callback function 6291 for asynchronous request. (optional) 6292 :param str account_id: The external account number (int) or account ID Guid. (required) 6293 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6294 :param str encoding: 6295 :return: file 6296 If the method is called asynchronously, 6297 returns the request thread. 6298 """ 6299 6300 all_params = ['account_id', 'envelope_id', 'encoding'] 6301 all_params.append('callback') 6302 all_params.append('_return_http_data_only') 6303 all_params.append('_preload_content') 6304 all_params.append('_request_timeout') 6305 6306 params = locals() 6307 for key, val in iteritems(params['kwargs']): 6308 if key not in all_params: 6309 raise TypeError( 6310 "Got an unexpected keyword argument '%s'" 6311 " to method get_comments_transcript" % key 6312 ) 6313 params[key] = val 6314 del params['kwargs'] 6315 # verify the required parameter 'account_id' is set 6316 if ('account_id' not in params) or (params['account_id'] is None): 6317 raise ValueError("Missing the required parameter `account_id` when calling `get_comments_transcript`") 6318 # verify the required parameter 'envelope_id' is set 6319 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6320 raise ValueError("Missing the required parameter `envelope_id` when calling `get_comments_transcript`") 6321 6322 6323 collection_formats = {} 6324 6325 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/comments/transcript'.replace('{format}', 'json') 6326 path_params = {} 6327 if 'account_id' in params: 6328 path_params['accountId'] = params['account_id'] 6329 if 'envelope_id' in params: 6330 path_params['envelopeId'] = params['envelope_id'] 6331 6332 query_params = {} 6333 if 'encoding' in params: 6334 query_params['encoding'] = params['encoding'] 6335 6336 header_params = {} 6337 6338 form_params = [] 6339 local_var_files = {} 6340 6341 body_params = None 6342 # HTTP header `Accept` 6343 header_params['Accept'] = self.api_client.\ 6344 select_header_accept(['application/pdf']) 6345 6346 # Authentication setting 6347 auth_settings = [] 6348 6349 return self.api_client.call_api(resource_path, 'GET', 6350 path_params, 6351 query_params, 6352 header_params, 6353 body=body_params, 6354 post_params=form_params, 6355 files=local_var_files, 6356 response_type='file', 6357 auth_settings=auth_settings, 6358 callback=params.get('callback'), 6359 _return_http_data_only=params.get('_return_http_data_only'), 6360 _preload_content=params.get('_preload_content', True), 6361 _request_timeout=params.get('_request_timeout'), 6362 collection_formats=collection_formats) 6363 6364 def get_consumer_disclosure(self, account_id, envelope_id, lang_code, recipient_id, **kwargs): 6365 """ 6366 Reserved: Gets the Electronic Record and Signature Disclosure associated with the account. 6367 Reserved: Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, associated with the account. 6368 This method makes a synchronous HTTP request by default. To make an 6369 asynchronous HTTP request, please define a `callback` function 6370 to be invoked when receiving the response. 6371 >>> def callback_function(response): 6372 >>> pprint(response) 6373 >>> 6374 >>> thread = api.get_consumer_disclosure(account_id, envelope_id, lang_code, recipient_id, callback=callback_function) 6375 6376 :param callback function: The callback function 6377 for asynchronous request. (optional) 6378 :param str account_id: The external account number (int) or account ID Guid. (required) 6379 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6380 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 6381 :param str recipient_id: The ID of the recipient being accessed. (required) 6382 :param str lang_code2: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. 6383 :return: ConsumerDisclosure 6384 If the method is called asynchronously, 6385 returns the request thread. 6386 """ 6387 kwargs['_return_http_data_only'] = True 6388 if kwargs.get('callback'): 6389 return self.get_consumer_disclosure_with_http_info(account_id, envelope_id, lang_code, recipient_id, **kwargs) 6390 else: 6391 (data) = self.get_consumer_disclosure_with_http_info(account_id, envelope_id, lang_code, recipient_id, **kwargs) 6392 return data 6393 6394 def get_consumer_disclosure_with_http_info(self, account_id, envelope_id, lang_code, recipient_id, **kwargs): 6395 """ 6396 Reserved: Gets the Electronic Record and Signature Disclosure associated with the account. 6397 Reserved: Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, associated with the account. 6398 This method makes a synchronous HTTP request by default. To make an 6399 asynchronous HTTP request, please define a `callback` function 6400 to be invoked when receiving the response. 6401 >>> def callback_function(response): 6402 >>> pprint(response) 6403 >>> 6404 >>> thread = api.get_consumer_disclosure_with_http_info(account_id, envelope_id, lang_code, recipient_id, callback=callback_function) 6405 6406 :param callback function: The callback function 6407 for asynchronous request. (optional) 6408 :param str account_id: The external account number (int) or account ID Guid. (required) 6409 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6410 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 6411 :param str recipient_id: The ID of the recipient being accessed. (required) 6412 :param str lang_code2: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. 6413 :return: ConsumerDisclosure 6414 If the method is called asynchronously, 6415 returns the request thread. 6416 """ 6417 6418 all_params = ['account_id', 'envelope_id', 'lang_code', 'recipient_id', 'lang_code2'] 6419 all_params.append('callback') 6420 all_params.append('_return_http_data_only') 6421 all_params.append('_preload_content') 6422 all_params.append('_request_timeout') 6423 6424 params = locals() 6425 for key, val in iteritems(params['kwargs']): 6426 if key not in all_params: 6427 raise TypeError( 6428 "Got an unexpected keyword argument '%s'" 6429 " to method get_consumer_disclosure" % key 6430 ) 6431 params[key] = val 6432 del params['kwargs'] 6433 # verify the required parameter 'account_id' is set 6434 if ('account_id' not in params) or (params['account_id'] is None): 6435 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure`") 6436 # verify the required parameter 'envelope_id' is set 6437 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6438 raise ValueError("Missing the required parameter `envelope_id` when calling `get_consumer_disclosure`") 6439 # verify the required parameter 'lang_code' is set 6440 if ('lang_code' not in params) or (params['lang_code'] is None): 6441 raise ValueError("Missing the required parameter `lang_code` when calling `get_consumer_disclosure`") 6442 # verify the required parameter 'recipient_id' is set 6443 if ('recipient_id' not in params) or (params['recipient_id'] is None): 6444 raise ValueError("Missing the required parameter `recipient_id` when calling `get_consumer_disclosure`") 6445 6446 6447 collection_formats = {} 6448 6449 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 6450 path_params = {} 6451 if 'account_id' in params: 6452 path_params['accountId'] = params['account_id'] 6453 if 'envelope_id' in params: 6454 path_params['envelopeId'] = params['envelope_id'] 6455 if 'lang_code' in params: 6456 path_params['langCode'] = params['lang_code'] 6457 if 'recipient_id' in params: 6458 path_params['recipientId'] = params['recipient_id'] 6459 6460 query_params = {} 6461 if 'lang_code2' in params: 6462 query_params['langCode'] = params['lang_code2'] 6463 6464 header_params = {} 6465 6466 form_params = [] 6467 local_var_files = {} 6468 6469 body_params = None 6470 # HTTP header `Accept` 6471 header_params['Accept'] = self.api_client.\ 6472 select_header_accept(['application/json']) 6473 6474 # Authentication setting 6475 auth_settings = [] 6476 6477 return self.api_client.call_api(resource_path, 'GET', 6478 path_params, 6479 query_params, 6480 header_params, 6481 body=body_params, 6482 post_params=form_params, 6483 files=local_var_files, 6484 response_type='ConsumerDisclosure', 6485 auth_settings=auth_settings, 6486 callback=params.get('callback'), 6487 _return_http_data_only=params.get('_return_http_data_only'), 6488 _preload_content=params.get('_preload_content', True), 6489 _request_timeout=params.get('_request_timeout'), 6490 collection_formats=collection_formats) 6491 6492 def get_consumer_disclosure_default(self, account_id, envelope_id, recipient_id, **kwargs): 6493 """ 6494 Gets the Electronic Record and Signature Disclosure associated with the account. 6495 Retrieves the Electronic Record and Signature Disclosure, with html formatting, associated with the account. You can use an optional query string to set the language for the disclosure. 6496 This method makes a synchronous HTTP request by default. To make an 6497 asynchronous HTTP request, please define a `callback` function 6498 to be invoked when receiving the response. 6499 >>> def callback_function(response): 6500 >>> pprint(response) 6501 >>> 6502 >>> thread = api.get_consumer_disclosure_default(account_id, envelope_id, recipient_id, callback=callback_function) 6503 6504 :param callback function: The callback function 6505 for asynchronous request. (optional) 6506 :param str account_id: The external account number (int) or account ID Guid. (required) 6507 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6508 :param str recipient_id: The ID of the recipient being accessed. (required) 6509 :param str lang_code: 6510 :return: ConsumerDisclosure 6511 If the method is called asynchronously, 6512 returns the request thread. 6513 """ 6514 kwargs['_return_http_data_only'] = True 6515 if kwargs.get('callback'): 6516 return self.get_consumer_disclosure_default_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 6517 else: 6518 (data) = self.get_consumer_disclosure_default_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 6519 return data 6520 6521 def get_consumer_disclosure_default_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 6522 """ 6523 Gets the Electronic Record and Signature Disclosure associated with the account. 6524 Retrieves the Electronic Record and Signature Disclosure, with html formatting, associated with the account. You can use an optional query string to set the language for the disclosure. 6525 This method makes a synchronous HTTP request by default. To make an 6526 asynchronous HTTP request, please define a `callback` function 6527 to be invoked when receiving the response. 6528 >>> def callback_function(response): 6529 >>> pprint(response) 6530 >>> 6531 >>> thread = api.get_consumer_disclosure_default_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 6532 6533 :param callback function: The callback function 6534 for asynchronous request. (optional) 6535 :param str account_id: The external account number (int) or account ID Guid. (required) 6536 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6537 :param str recipient_id: The ID of the recipient being accessed. (required) 6538 :param str lang_code: 6539 :return: ConsumerDisclosure 6540 If the method is called asynchronously, 6541 returns the request thread. 6542 """ 6543 6544 all_params = ['account_id', 'envelope_id', 'recipient_id', 'lang_code'] 6545 all_params.append('callback') 6546 all_params.append('_return_http_data_only') 6547 all_params.append('_preload_content') 6548 all_params.append('_request_timeout') 6549 6550 params = locals() 6551 for key, val in iteritems(params['kwargs']): 6552 if key not in all_params: 6553 raise TypeError( 6554 "Got an unexpected keyword argument '%s'" 6555 " to method get_consumer_disclosure_default" % key 6556 ) 6557 params[key] = val 6558 del params['kwargs'] 6559 # verify the required parameter 'account_id' is set 6560 if ('account_id' not in params) or (params['account_id'] is None): 6561 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure_default`") 6562 # verify the required parameter 'envelope_id' is set 6563 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6564 raise ValueError("Missing the required parameter `envelope_id` when calling `get_consumer_disclosure_default`") 6565 # verify the required parameter 'recipient_id' is set 6566 if ('recipient_id' not in params) or (params['recipient_id'] is None): 6567 raise ValueError("Missing the required parameter `recipient_id` when calling `get_consumer_disclosure_default`") 6568 6569 6570 collection_formats = {} 6571 6572 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/consumer_disclosure'.replace('{format}', 'json') 6573 path_params = {} 6574 if 'account_id' in params: 6575 path_params['accountId'] = params['account_id'] 6576 if 'envelope_id' in params: 6577 path_params['envelopeId'] = params['envelope_id'] 6578 if 'recipient_id' in params: 6579 path_params['recipientId'] = params['recipient_id'] 6580 6581 query_params = {} 6582 if 'lang_code' in params: 6583 query_params['langCode'] = params['lang_code'] 6584 6585 header_params = {} 6586 6587 form_params = [] 6588 local_var_files = {} 6589 6590 body_params = None 6591 # HTTP header `Accept` 6592 header_params['Accept'] = self.api_client.\ 6593 select_header_accept(['application/json']) 6594 6595 # Authentication setting 6596 auth_settings = [] 6597 6598 return self.api_client.call_api(resource_path, 'GET', 6599 path_params, 6600 query_params, 6601 header_params, 6602 body=body_params, 6603 post_params=form_params, 6604 files=local_var_files, 6605 response_type='ConsumerDisclosure', 6606 auth_settings=auth_settings, 6607 callback=params.get('callback'), 6608 _return_http_data_only=params.get('_return_http_data_only'), 6609 _preload_content=params.get('_preload_content', True), 6610 _request_timeout=params.get('_request_timeout'), 6611 collection_formats=collection_formats) 6612 6613 def get_document(self, account_id, document_id, envelope_id, **kwargs): 6614 """ 6615 Gets a document from an envelope. 6616 Retrieves the specified document from the envelope. If the account has the Highlight Data Changes feature enabled, there is an option to request that any changes in the envelope be highlighted. You can also use this method to retrieve a PDF containing the combined content of all documents and the certificate. If the account has the Highlight Data Changes feature enabled, there is an option to request that any changes in the envelope be highlighted. To retrieve the combined content replace the `{documentId}` parameter in the endpoint with `combined`. /accounts/{accountId}/envelopes/{envelopeId}/documents/combined 6617 This method makes a synchronous HTTP request by default. To make an 6618 asynchronous HTTP request, please define a `callback` function 6619 to be invoked when receiving the response. 6620 >>> def callback_function(response): 6621 >>> pprint(response) 6622 >>> 6623 >>> thread = api.get_document(account_id, document_id, envelope_id, callback=callback_function) 6624 6625 :param callback function: The callback function 6626 for asynchronous request. (optional) 6627 :param str account_id: The external account number (int) or account ID Guid. (required) 6628 :param str document_id: The ID of the document being accessed. (required) 6629 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6630 :param str certificate: When set to **false**, the envelope signing certificate is removed from the download. 6631 :param str documents_by_userid: 6632 :param str encoding: 6633 :param str encrypt: When set to **true**, the PDF bytes returned in the response are encrypted for all the key managers configured on your DocuSign account. The documents can be decrypted with the KeyManager Decrypt Document API. 6634 :param str language: Specifies the language for the Certificate of Completion in the response. The supported languages, with the language value shown in parenthesis, are: Chinese Simplified (zh_CN), , Chinese Traditional (zh_TW), Dutch (nl), English US (en), French (fr), German (de), Italian (it), Japanese (ja), Korean (ko), Portuguese (pt), Portuguese (Brazil) (pt_BR), Russian (ru), Spanish (es). 6635 :param str recipient_id: 6636 :param str shared_user_id: 6637 :param str show_changes: When set to **true**, any changed fields for the returned PDF are highlighted in yellow and optional signatures or initials outlined in red. 6638 :param str watermark: When set to **true**, the account has the watermark feature enabled, and the envelope is not complete, the watermark for the account is added to the PDF documents. This option can remove the watermark. 6639 :return: file 6640 If the method is called asynchronously, 6641 returns the request thread. 6642 """ 6643 kwargs['_return_http_data_only'] = True 6644 if kwargs.get('callback'): 6645 return self.get_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 6646 else: 6647 (data) = self.get_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 6648 return data 6649 6650 def get_document_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 6651 """ 6652 Gets a document from an envelope. 6653 Retrieves the specified document from the envelope. If the account has the Highlight Data Changes feature enabled, there is an option to request that any changes in the envelope be highlighted. You can also use this method to retrieve a PDF containing the combined content of all documents and the certificate. If the account has the Highlight Data Changes feature enabled, there is an option to request that any changes in the envelope be highlighted. To retrieve the combined content replace the `{documentId}` parameter in the endpoint with `combined`. /accounts/{accountId}/envelopes/{envelopeId}/documents/combined 6654 This method makes a synchronous HTTP request by default. To make an 6655 asynchronous HTTP request, please define a `callback` function 6656 to be invoked when receiving the response. 6657 >>> def callback_function(response): 6658 >>> pprint(response) 6659 >>> 6660 >>> thread = api.get_document_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 6661 6662 :param callback function: The callback function 6663 for asynchronous request. (optional) 6664 :param str account_id: The external account number (int) or account ID Guid. (required) 6665 :param str document_id: The ID of the document being accessed. (required) 6666 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6667 :param str certificate: When set to **false**, the envelope signing certificate is removed from the download. 6668 :param str documents_by_userid: 6669 :param str encoding: 6670 :param str encrypt: When set to **true**, the PDF bytes returned in the response are encrypted for all the key managers configured on your DocuSign account. The documents can be decrypted with the KeyManager Decrypt Document API. 6671 :param str language: Specifies the language for the Certificate of Completion in the response. The supported languages, with the language value shown in parenthesis, are: Chinese Simplified (zh_CN), , Chinese Traditional (zh_TW), Dutch (nl), English US (en), French (fr), German (de), Italian (it), Japanese (ja), Korean (ko), Portuguese (pt), Portuguese (Brazil) (pt_BR), Russian (ru), Spanish (es). 6672 :param str recipient_id: 6673 :param str shared_user_id: 6674 :param str show_changes: When set to **true**, any changed fields for the returned PDF are highlighted in yellow and optional signatures or initials outlined in red. 6675 :param str watermark: When set to **true**, the account has the watermark feature enabled, and the envelope is not complete, the watermark for the account is added to the PDF documents. This option can remove the watermark. 6676 :return: file 6677 If the method is called asynchronously, 6678 returns the request thread. 6679 """ 6680 6681 all_params = ['account_id', 'document_id', 'envelope_id', 'certificate', 'documents_by_userid', 'encoding', 'encrypt', 'language', 'recipient_id', 'shared_user_id', 'show_changes', 'watermark'] 6682 all_params.append('callback') 6683 all_params.append('_return_http_data_only') 6684 all_params.append('_preload_content') 6685 all_params.append('_request_timeout') 6686 6687 params = locals() 6688 for key, val in iteritems(params['kwargs']): 6689 if key not in all_params: 6690 raise TypeError( 6691 "Got an unexpected keyword argument '%s'" 6692 " to method get_document" % key 6693 ) 6694 params[key] = val 6695 del params['kwargs'] 6696 # verify the required parameter 'account_id' is set 6697 if ('account_id' not in params) or (params['account_id'] is None): 6698 raise ValueError("Missing the required parameter `account_id` when calling `get_document`") 6699 # verify the required parameter 'document_id' is set 6700 if ('document_id' not in params) or (params['document_id'] is None): 6701 raise ValueError("Missing the required parameter `document_id` when calling `get_document`") 6702 # verify the required parameter 'envelope_id' is set 6703 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6704 raise ValueError("Missing the required parameter `envelope_id` when calling `get_document`") 6705 6706 6707 collection_formats = {} 6708 6709 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}'.replace('{format}', 'json') 6710 path_params = {} 6711 if 'account_id' in params: 6712 path_params['accountId'] = params['account_id'] 6713 if 'document_id' in params: 6714 path_params['documentId'] = params['document_id'] 6715 if 'envelope_id' in params: 6716 path_params['envelopeId'] = params['envelope_id'] 6717 6718 query_params = {} 6719 if 'certificate' in params: 6720 query_params['certificate'] = params['certificate'] 6721 if 'documents_by_userid' in params: 6722 query_params['documents_by_userid'] = params['documents_by_userid'] 6723 if 'encoding' in params: 6724 query_params['encoding'] = params['encoding'] 6725 if 'encrypt' in params: 6726 query_params['encrypt'] = params['encrypt'] 6727 if 'language' in params: 6728 query_params['language'] = params['language'] 6729 if 'recipient_id' in params: 6730 query_params['recipient_id'] = params['recipient_id'] 6731 if 'shared_user_id' in params: 6732 query_params['shared_user_id'] = params['shared_user_id'] 6733 if 'show_changes' in params: 6734 query_params['show_changes'] = params['show_changes'] 6735 if 'watermark' in params: 6736 query_params['watermark'] = params['watermark'] 6737 6738 header_params = {} 6739 6740 form_params = [] 6741 local_var_files = {} 6742 6743 body_params = None 6744 # HTTP header `Accept` 6745 header_params['Accept'] = self.api_client.\ 6746 select_header_accept(['application/pdf']) 6747 6748 # Authentication setting 6749 auth_settings = [] 6750 6751 return self.api_client.call_api(resource_path, 'GET', 6752 path_params, 6753 query_params, 6754 header_params, 6755 body=body_params, 6756 post_params=form_params, 6757 files=local_var_files, 6758 response_type='file', 6759 auth_settings=auth_settings, 6760 callback=params.get('callback'), 6761 _return_http_data_only=params.get('_return_http_data_only'), 6762 _preload_content=params.get('_preload_content', True), 6763 _request_timeout=params.get('_request_timeout'), 6764 collection_formats=collection_formats) 6765 6766 def get_document_page_image(self, account_id, document_id, envelope_id, page_number, **kwargs): 6767 """ 6768 Gets a page image from an envelope for display. 6769 Retrieves a page image for display from the specified envelope. 6770 This method makes a synchronous HTTP request by default. To make an 6771 asynchronous HTTP request, please define a `callback` function 6772 to be invoked when receiving the response. 6773 >>> def callback_function(response): 6774 >>> pprint(response) 6775 >>> 6776 >>> thread = api.get_document_page_image(account_id, document_id, envelope_id, page_number, callback=callback_function) 6777 6778 :param callback function: The callback function 6779 for asynchronous request. (optional) 6780 :param str account_id: The external account number (int) or account ID Guid. (required) 6781 :param str document_id: The ID of the document being accessed. (required) 6782 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6783 :param str page_number: The page number being accessed. (required) 6784 :param str dpi: Sets the dpi for the image. 6785 :param str max_height: Sets the maximum height for the page image in pixels. The dpi is recalculated based on this setting. 6786 :param str max_width: Sets the maximum width for the page image in pixels. The dpi is recalculated based on this setting. 6787 :param str show_changes: 6788 :return: file 6789 If the method is called asynchronously, 6790 returns the request thread. 6791 """ 6792 kwargs['_return_http_data_only'] = True 6793 if kwargs.get('callback'): 6794 return self.get_document_page_image_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 6795 else: 6796 (data) = self.get_document_page_image_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 6797 return data 6798 6799 def get_document_page_image_with_http_info(self, account_id, document_id, envelope_id, page_number, **kwargs): 6800 """ 6801 Gets a page image from an envelope for display. 6802 Retrieves a page image for display from the specified envelope. 6803 This method makes a synchronous HTTP request by default. To make an 6804 asynchronous HTTP request, please define a `callback` function 6805 to be invoked when receiving the response. 6806 >>> def callback_function(response): 6807 >>> pprint(response) 6808 >>> 6809 >>> thread = api.get_document_page_image_with_http_info(account_id, document_id, envelope_id, page_number, callback=callback_function) 6810 6811 :param callback function: The callback function 6812 for asynchronous request. (optional) 6813 :param str account_id: The external account number (int) or account ID Guid. (required) 6814 :param str document_id: The ID of the document being accessed. (required) 6815 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6816 :param str page_number: The page number being accessed. (required) 6817 :param str dpi: Sets the dpi for the image. 6818 :param str max_height: Sets the maximum height for the page image in pixels. The dpi is recalculated based on this setting. 6819 :param str max_width: Sets the maximum width for the page image in pixels. The dpi is recalculated based on this setting. 6820 :param str show_changes: 6821 :return: file 6822 If the method is called asynchronously, 6823 returns the request thread. 6824 """ 6825 6826 all_params = ['account_id', 'document_id', 'envelope_id', 'page_number', 'dpi', 'max_height', 'max_width', 'show_changes'] 6827 all_params.append('callback') 6828 all_params.append('_return_http_data_only') 6829 all_params.append('_preload_content') 6830 all_params.append('_request_timeout') 6831 6832 params = locals() 6833 for key, val in iteritems(params['kwargs']): 6834 if key not in all_params: 6835 raise TypeError( 6836 "Got an unexpected keyword argument '%s'" 6837 " to method get_document_page_image" % key 6838 ) 6839 params[key] = val 6840 del params['kwargs'] 6841 # verify the required parameter 'account_id' is set 6842 if ('account_id' not in params) or (params['account_id'] is None): 6843 raise ValueError("Missing the required parameter `account_id` when calling `get_document_page_image`") 6844 # verify the required parameter 'document_id' is set 6845 if ('document_id' not in params) or (params['document_id'] is None): 6846 raise ValueError("Missing the required parameter `document_id` when calling `get_document_page_image`") 6847 # verify the required parameter 'envelope_id' is set 6848 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6849 raise ValueError("Missing the required parameter `envelope_id` when calling `get_document_page_image`") 6850 # verify the required parameter 'page_number' is set 6851 if ('page_number' not in params) or (params['page_number'] is None): 6852 raise ValueError("Missing the required parameter `page_number` when calling `get_document_page_image`") 6853 6854 6855 collection_formats = {} 6856 6857 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/pages/{pageNumber}/page_image'.replace('{format}', 'json') 6858 path_params = {} 6859 if 'account_id' in params: 6860 path_params['accountId'] = params['account_id'] 6861 if 'document_id' in params: 6862 path_params['documentId'] = params['document_id'] 6863 if 'envelope_id' in params: 6864 path_params['envelopeId'] = params['envelope_id'] 6865 if 'page_number' in params: 6866 path_params['pageNumber'] = params['page_number'] 6867 6868 query_params = {} 6869 if 'dpi' in params: 6870 query_params['dpi'] = params['dpi'] 6871 if 'max_height' in params: 6872 query_params['max_height'] = params['max_height'] 6873 if 'max_width' in params: 6874 query_params['max_width'] = params['max_width'] 6875 if 'show_changes' in params: 6876 query_params['show_changes'] = params['show_changes'] 6877 6878 header_params = {} 6879 6880 form_params = [] 6881 local_var_files = {} 6882 6883 body_params = None 6884 # HTTP header `Accept` 6885 header_params['Accept'] = self.api_client.\ 6886 select_header_accept(['image/png']) 6887 6888 # Authentication setting 6889 auth_settings = [] 6890 6891 return self.api_client.call_api(resource_path, 'GET', 6892 path_params, 6893 query_params, 6894 header_params, 6895 body=body_params, 6896 post_params=form_params, 6897 files=local_var_files, 6898 response_type='file', 6899 auth_settings=auth_settings, 6900 callback=params.get('callback'), 6901 _return_http_data_only=params.get('_return_http_data_only'), 6902 _preload_content=params.get('_preload_content', True), 6903 _request_timeout=params.get('_request_timeout'), 6904 collection_formats=collection_formats) 6905 6906 def get_document_tabs(self, account_id, document_id, envelope_id, **kwargs): 6907 """ 6908 Returns tabs on the document. 6909 Returns the tabs on the document specified by `documentId` in the envelope specified by `envelopeId`. 6910 This method makes a synchronous HTTP request by default. To make an 6911 asynchronous HTTP request, please define a `callback` function 6912 to be invoked when receiving the response. 6913 >>> def callback_function(response): 6914 >>> pprint(response) 6915 >>> 6916 >>> thread = api.get_document_tabs(account_id, document_id, envelope_id, callback=callback_function) 6917 6918 :param callback function: The callback function 6919 for asynchronous request. (optional) 6920 :param str account_id: The external account number (int) or account ID Guid. (required) 6921 :param str document_id: The ID of the document being accessed. (required) 6922 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6923 :param str include_metadata: 6924 :param str page_numbers: 6925 :return: Tabs 6926 If the method is called asynchronously, 6927 returns the request thread. 6928 """ 6929 kwargs['_return_http_data_only'] = True 6930 if kwargs.get('callback'): 6931 return self.get_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 6932 else: 6933 (data) = self.get_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 6934 return data 6935 6936 def get_document_tabs_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 6937 """ 6938 Returns tabs on the document. 6939 Returns the tabs on the document specified by `documentId` in the envelope specified by `envelopeId`. 6940 This method makes a synchronous HTTP request by default. To make an 6941 asynchronous HTTP request, please define a `callback` function 6942 to be invoked when receiving the response. 6943 >>> def callback_function(response): 6944 >>> pprint(response) 6945 >>> 6946 >>> thread = api.get_document_tabs_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 6947 6948 :param callback function: The callback function 6949 for asynchronous request. (optional) 6950 :param str account_id: The external account number (int) or account ID Guid. (required) 6951 :param str document_id: The ID of the document being accessed. (required) 6952 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6953 :param str include_metadata: 6954 :param str page_numbers: 6955 :return: Tabs 6956 If the method is called asynchronously, 6957 returns the request thread. 6958 """ 6959 6960 all_params = ['account_id', 'document_id', 'envelope_id', 'include_metadata', 'page_numbers'] 6961 all_params.append('callback') 6962 all_params.append('_return_http_data_only') 6963 all_params.append('_preload_content') 6964 all_params.append('_request_timeout') 6965 6966 params = locals() 6967 for key, val in iteritems(params['kwargs']): 6968 if key not in all_params: 6969 raise TypeError( 6970 "Got an unexpected keyword argument '%s'" 6971 " to method get_document_tabs" % key 6972 ) 6973 params[key] = val 6974 del params['kwargs'] 6975 # verify the required parameter 'account_id' is set 6976 if ('account_id' not in params) or (params['account_id'] is None): 6977 raise ValueError("Missing the required parameter `account_id` when calling `get_document_tabs`") 6978 # verify the required parameter 'document_id' is set 6979 if ('document_id' not in params) or (params['document_id'] is None): 6980 raise ValueError("Missing the required parameter `document_id` when calling `get_document_tabs`") 6981 # verify the required parameter 'envelope_id' is set 6982 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6983 raise ValueError("Missing the required parameter `envelope_id` when calling `get_document_tabs`") 6984 6985 6986 collection_formats = {} 6987 6988 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/tabs'.replace('{format}', 'json') 6989 path_params = {} 6990 if 'account_id' in params: 6991 path_params['accountId'] = params['account_id'] 6992 if 'document_id' in params: 6993 path_params['documentId'] = params['document_id'] 6994 if 'envelope_id' in params: 6995 path_params['envelopeId'] = params['envelope_id'] 6996 6997 query_params = {} 6998 if 'include_metadata' in params: 6999 query_params['include_metadata'] = params['include_metadata'] 7000 if 'page_numbers' in params: 7001 query_params['page_numbers'] = params['page_numbers'] 7002 7003 header_params = {} 7004 7005 form_params = [] 7006 local_var_files = {} 7007 7008 body_params = None 7009 # HTTP header `Accept` 7010 header_params['Accept'] = self.api_client.\ 7011 select_header_accept(['application/json']) 7012 7013 # Authentication setting 7014 auth_settings = [] 7015 7016 return self.api_client.call_api(resource_path, 'GET', 7017 path_params, 7018 query_params, 7019 header_params, 7020 body=body_params, 7021 post_params=form_params, 7022 files=local_var_files, 7023 response_type='Tabs', 7024 auth_settings=auth_settings, 7025 callback=params.get('callback'), 7026 _return_http_data_only=params.get('_return_http_data_only'), 7027 _preload_content=params.get('_preload_content', True), 7028 _request_timeout=params.get('_request_timeout'), 7029 collection_formats=collection_formats) 7030 7031 def get_email_settings(self, account_id, envelope_id, **kwargs): 7032 """ 7033 Gets the email setting overrides for an envelope. 7034 Retrieves the email override settings for the specified envelope. 7035 This method makes a synchronous HTTP request by default. To make an 7036 asynchronous HTTP request, please define a `callback` function 7037 to be invoked when receiving the response. 7038 >>> def callback_function(response): 7039 >>> pprint(response) 7040 >>> 7041 >>> thread = api.get_email_settings(account_id, envelope_id, callback=callback_function) 7042 7043 :param callback function: The callback function 7044 for asynchronous request. (optional) 7045 :param str account_id: The external account number (int) or account ID Guid. (required) 7046 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7047 :return: EmailSettings 7048 If the method is called asynchronously, 7049 returns the request thread. 7050 """ 7051 kwargs['_return_http_data_only'] = True 7052 if kwargs.get('callback'): 7053 return self.get_email_settings_with_http_info(account_id, envelope_id, **kwargs) 7054 else: 7055 (data) = self.get_email_settings_with_http_info(account_id, envelope_id, **kwargs) 7056 return data 7057 7058 def get_email_settings_with_http_info(self, account_id, envelope_id, **kwargs): 7059 """ 7060 Gets the email setting overrides for an envelope. 7061 Retrieves the email override settings for the specified envelope. 7062 This method makes a synchronous HTTP request by default. To make an 7063 asynchronous HTTP request, please define a `callback` function 7064 to be invoked when receiving the response. 7065 >>> def callback_function(response): 7066 >>> pprint(response) 7067 >>> 7068 >>> thread = api.get_email_settings_with_http_info(account_id, envelope_id, callback=callback_function) 7069 7070 :param callback function: The callback function 7071 for asynchronous request. (optional) 7072 :param str account_id: The external account number (int) or account ID Guid. (required) 7073 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7074 :return: EmailSettings 7075 If the method is called asynchronously, 7076 returns the request thread. 7077 """ 7078 7079 all_params = ['account_id', 'envelope_id'] 7080 all_params.append('callback') 7081 all_params.append('_return_http_data_only') 7082 all_params.append('_preload_content') 7083 all_params.append('_request_timeout') 7084 7085 params = locals() 7086 for key, val in iteritems(params['kwargs']): 7087 if key not in all_params: 7088 raise TypeError( 7089 "Got an unexpected keyword argument '%s'" 7090 " to method get_email_settings" % key 7091 ) 7092 params[key] = val 7093 del params['kwargs'] 7094 # verify the required parameter 'account_id' is set 7095 if ('account_id' not in params) or (params['account_id'] is None): 7096 raise ValueError("Missing the required parameter `account_id` when calling `get_email_settings`") 7097 # verify the required parameter 'envelope_id' is set 7098 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7099 raise ValueError("Missing the required parameter `envelope_id` when calling `get_email_settings`") 7100 7101 7102 collection_formats = {} 7103 7104 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/email_settings'.replace('{format}', 'json') 7105 path_params = {} 7106 if 'account_id' in params: 7107 path_params['accountId'] = params['account_id'] 7108 if 'envelope_id' in params: 7109 path_params['envelopeId'] = params['envelope_id'] 7110 7111 query_params = {} 7112 7113 header_params = {} 7114 7115 form_params = [] 7116 local_var_files = {} 7117 7118 body_params = None 7119 # HTTP header `Accept` 7120 header_params['Accept'] = self.api_client.\ 7121 select_header_accept(['application/json']) 7122 7123 # Authentication setting 7124 auth_settings = [] 7125 7126 return self.api_client.call_api(resource_path, 'GET', 7127 path_params, 7128 query_params, 7129 header_params, 7130 body=body_params, 7131 post_params=form_params, 7132 files=local_var_files, 7133 response_type='EmailSettings', 7134 auth_settings=auth_settings, 7135 callback=params.get('callback'), 7136 _return_http_data_only=params.get('_return_http_data_only'), 7137 _preload_content=params.get('_preload_content', True), 7138 _request_timeout=params.get('_request_timeout'), 7139 collection_formats=collection_formats) 7140 7141 def get_envelope(self, account_id, envelope_id, **kwargs): 7142 """ 7143 Gets the status of a envelope. 7144 Retrieves the overall status for the specified envelope. 7145 This method makes a synchronous HTTP request by default. To make an 7146 asynchronous HTTP request, please define a `callback` function 7147 to be invoked when receiving the response. 7148 >>> def callback_function(response): 7149 >>> pprint(response) 7150 >>> 7151 >>> thread = api.get_envelope(account_id, envelope_id, callback=callback_function) 7152 7153 :param callback function: The callback function 7154 for asynchronous request. (optional) 7155 :param str account_id: The external account number (int) or account ID Guid. (required) 7156 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7157 :param str advanced_update: When true, envelope information can be added or modified. 7158 :param str include: 7159 :param str include_anchor_tab_locations: 7160 :return: Envelope 7161 If the method is called asynchronously, 7162 returns the request thread. 7163 """ 7164 kwargs['_return_http_data_only'] = True 7165 if kwargs.get('callback'): 7166 return self.get_envelope_with_http_info(account_id, envelope_id, **kwargs) 7167 else: 7168 (data) = self.get_envelope_with_http_info(account_id, envelope_id, **kwargs) 7169 return data 7170 7171 def get_envelope_with_http_info(self, account_id, envelope_id, **kwargs): 7172 """ 7173 Gets the status of a envelope. 7174 Retrieves the overall status for the specified envelope. 7175 This method makes a synchronous HTTP request by default. To make an 7176 asynchronous HTTP request, please define a `callback` function 7177 to be invoked when receiving the response. 7178 >>> def callback_function(response): 7179 >>> pprint(response) 7180 >>> 7181 >>> thread = api.get_envelope_with_http_info(account_id, envelope_id, callback=callback_function) 7182 7183 :param callback function: The callback function 7184 for asynchronous request. (optional) 7185 :param str account_id: The external account number (int) or account ID Guid. (required) 7186 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7187 :param str advanced_update: When true, envelope information can be added or modified. 7188 :param str include: 7189 :param str include_anchor_tab_locations: 7190 :return: Envelope 7191 If the method is called asynchronously, 7192 returns the request thread. 7193 """ 7194 7195 all_params = ['account_id', 'envelope_id', 'advanced_update', 'include', 'include_anchor_tab_locations'] 7196 all_params.append('callback') 7197 all_params.append('_return_http_data_only') 7198 all_params.append('_preload_content') 7199 all_params.append('_request_timeout') 7200 7201 params = locals() 7202 for key, val in iteritems(params['kwargs']): 7203 if key not in all_params: 7204 raise TypeError( 7205 "Got an unexpected keyword argument '%s'" 7206 " to method get_envelope" % key 7207 ) 7208 params[key] = val 7209 del params['kwargs'] 7210 # verify the required parameter 'account_id' is set 7211 if ('account_id' not in params) or (params['account_id'] is None): 7212 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope`") 7213 # verify the required parameter 'envelope_id' is set 7214 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7215 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope`") 7216 7217 7218 collection_formats = {} 7219 7220 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}'.replace('{format}', 'json') 7221 path_params = {} 7222 if 'account_id' in params: 7223 path_params['accountId'] = params['account_id'] 7224 if 'envelope_id' in params: 7225 path_params['envelopeId'] = params['envelope_id'] 7226 7227 query_params = {} 7228 if 'advanced_update' in params: 7229 query_params['advanced_update'] = params['advanced_update'] 7230 if 'include' in params: 7231 query_params['include'] = params['include'] 7232 if 'include_anchor_tab_locations' in params: 7233 query_params['include_anchor_tab_locations'] = params['include_anchor_tab_locations'] 7234 7235 header_params = {} 7236 7237 form_params = [] 7238 local_var_files = {} 7239 7240 body_params = None 7241 # HTTP header `Accept` 7242 header_params['Accept'] = self.api_client.\ 7243 select_header_accept(['application/json']) 7244 7245 # Authentication setting 7246 auth_settings = [] 7247 7248 return self.api_client.call_api(resource_path, 'GET', 7249 path_params, 7250 query_params, 7251 header_params, 7252 body=body_params, 7253 post_params=form_params, 7254 files=local_var_files, 7255 response_type='Envelope', 7256 auth_settings=auth_settings, 7257 callback=params.get('callback'), 7258 _return_http_data_only=params.get('_return_http_data_only'), 7259 _preload_content=params.get('_preload_content', True), 7260 _request_timeout=params.get('_request_timeout'), 7261 collection_formats=collection_formats) 7262 7263 def get_envelope_delayed_routing_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 7264 """ 7265 Returns the delayed routing rules for an envelope's workflow step definition. 7266 This method makes a synchronous HTTP request by default. To make an 7267 asynchronous HTTP request, please define a `callback` function 7268 to be invoked when receiving the response. 7269 >>> def callback_function(response): 7270 >>> pprint(response) 7271 >>> 7272 >>> thread = api.get_envelope_delayed_routing_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 7273 7274 :param callback function: The callback function 7275 for asynchronous request. (optional) 7276 :param str account_id: The external account number (int) or account ID Guid. (required) 7277 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7278 :param str workflow_step_id: (required) 7279 :return: DelayedRouting 7280 If the method is called asynchronously, 7281 returns the request thread. 7282 """ 7283 kwargs['_return_http_data_only'] = True 7284 if kwargs.get('callback'): 7285 return self.get_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 7286 else: 7287 (data) = self.get_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 7288 return data 7289 7290 def get_envelope_delayed_routing_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 7291 """ 7292 Returns the delayed routing rules for an envelope's workflow step definition. 7293 This method makes a synchronous HTTP request by default. To make an 7294 asynchronous HTTP request, please define a `callback` function 7295 to be invoked when receiving the response. 7296 >>> def callback_function(response): 7297 >>> pprint(response) 7298 >>> 7299 >>> thread = api.get_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 7300 7301 :param callback function: The callback function 7302 for asynchronous request. (optional) 7303 :param str account_id: The external account number (int) or account ID Guid. (required) 7304 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7305 :param str workflow_step_id: (required) 7306 :return: DelayedRouting 7307 If the method is called asynchronously, 7308 returns the request thread. 7309 """ 7310 7311 all_params = ['account_id', 'envelope_id', 'workflow_step_id'] 7312 all_params.append('callback') 7313 all_params.append('_return_http_data_only') 7314 all_params.append('_preload_content') 7315 all_params.append('_request_timeout') 7316 7317 params = locals() 7318 for key, val in iteritems(params['kwargs']): 7319 if key not in all_params: 7320 raise TypeError( 7321 "Got an unexpected keyword argument '%s'" 7322 " to method get_envelope_delayed_routing_definition" % key 7323 ) 7324 params[key] = val 7325 del params['kwargs'] 7326 # verify the required parameter 'account_id' is set 7327 if ('account_id' not in params) or (params['account_id'] is None): 7328 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_delayed_routing_definition`") 7329 # verify the required parameter 'envelope_id' is set 7330 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7331 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_delayed_routing_definition`") 7332 # verify the required parameter 'workflow_step_id' is set 7333 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 7334 raise ValueError("Missing the required parameter `workflow_step_id` when calling `get_envelope_delayed_routing_definition`") 7335 7336 7337 collection_formats = {} 7338 7339 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 7340 path_params = {} 7341 if 'account_id' in params: 7342 path_params['accountId'] = params['account_id'] 7343 if 'envelope_id' in params: 7344 path_params['envelopeId'] = params['envelope_id'] 7345 if 'workflow_step_id' in params: 7346 path_params['workflowStepId'] = params['workflow_step_id'] 7347 7348 query_params = {} 7349 7350 header_params = {} 7351 7352 form_params = [] 7353 local_var_files = {} 7354 7355 body_params = None 7356 # HTTP header `Accept` 7357 header_params['Accept'] = self.api_client.\ 7358 select_header_accept(['application/json']) 7359 7360 # Authentication setting 7361 auth_settings = [] 7362 7363 return self.api_client.call_api(resource_path, 'GET', 7364 path_params, 7365 query_params, 7366 header_params, 7367 body=body_params, 7368 post_params=form_params, 7369 files=local_var_files, 7370 response_type='DelayedRouting', 7371 auth_settings=auth_settings, 7372 callback=params.get('callback'), 7373 _return_http_data_only=params.get('_return_http_data_only'), 7374 _preload_content=params.get('_preload_content', True), 7375 _request_timeout=params.get('_request_timeout'), 7376 collection_formats=collection_formats) 7377 7378 def get_envelope_doc_gen_form_fields(self, account_id, envelope_id, **kwargs): 7379 """ 7380 Returns formfields for an envelope 7381 This method makes a synchronous HTTP request by default. To make an 7382 asynchronous HTTP request, please define a `callback` function 7383 to be invoked when receiving the response. 7384 >>> def callback_function(response): 7385 >>> pprint(response) 7386 >>> 7387 >>> thread = api.get_envelope_doc_gen_form_fields(account_id, envelope_id, callback=callback_function) 7388 7389 :param callback function: The callback function 7390 for asynchronous request. (optional) 7391 :param str account_id: The external account number (int) or account ID Guid. (required) 7392 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7393 :return: DocGenFormFieldResponse 7394 If the method is called asynchronously, 7395 returns the request thread. 7396 """ 7397 kwargs['_return_http_data_only'] = True 7398 if kwargs.get('callback'): 7399 return self.get_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, **kwargs) 7400 else: 7401 (data) = self.get_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, **kwargs) 7402 return data 7403 7404 def get_envelope_doc_gen_form_fields_with_http_info(self, account_id, envelope_id, **kwargs): 7405 """ 7406 Returns formfields for an envelope 7407 This method makes a synchronous HTTP request by default. To make an 7408 asynchronous HTTP request, please define a `callback` function 7409 to be invoked when receiving the response. 7410 >>> def callback_function(response): 7411 >>> pprint(response) 7412 >>> 7413 >>> thread = api.get_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, callback=callback_function) 7414 7415 :param callback function: The callback function 7416 for asynchronous request. (optional) 7417 :param str account_id: The external account number (int) or account ID Guid. (required) 7418 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7419 :return: DocGenFormFieldResponse 7420 If the method is called asynchronously, 7421 returns the request thread. 7422 """ 7423 7424 all_params = ['account_id', 'envelope_id'] 7425 all_params.append('callback') 7426 all_params.append('_return_http_data_only') 7427 all_params.append('_preload_content') 7428 all_params.append('_request_timeout') 7429 7430 params = locals() 7431 for key, val in iteritems(params['kwargs']): 7432 if key not in all_params: 7433 raise TypeError( 7434 "Got an unexpected keyword argument '%s'" 7435 " to method get_envelope_doc_gen_form_fields" % key 7436 ) 7437 params[key] = val 7438 del params['kwargs'] 7439 # verify the required parameter 'account_id' is set 7440 if ('account_id' not in params) or (params['account_id'] is None): 7441 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_doc_gen_form_fields`") 7442 # verify the required parameter 'envelope_id' is set 7443 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7444 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_doc_gen_form_fields`") 7445 7446 7447 collection_formats = {} 7448 7449 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/docGenFormFields'.replace('{format}', 'json') 7450 path_params = {} 7451 if 'account_id' in params: 7452 path_params['accountId'] = params['account_id'] 7453 if 'envelope_id' in params: 7454 path_params['envelopeId'] = params['envelope_id'] 7455 7456 query_params = {} 7457 7458 header_params = {} 7459 7460 form_params = [] 7461 local_var_files = {} 7462 7463 body_params = None 7464 # HTTP header `Accept` 7465 header_params['Accept'] = self.api_client.\ 7466 select_header_accept(['application/json']) 7467 7468 # Authentication setting 7469 auth_settings = [] 7470 7471 return self.api_client.call_api(resource_path, 'GET', 7472 path_params, 7473 query_params, 7474 header_params, 7475 body=body_params, 7476 post_params=form_params, 7477 files=local_var_files, 7478 response_type='DocGenFormFieldResponse', 7479 auth_settings=auth_settings, 7480 callback=params.get('callback'), 7481 _return_http_data_only=params.get('_return_http_data_only'), 7482 _preload_content=params.get('_preload_content', True), 7483 _request_timeout=params.get('_request_timeout'), 7484 collection_formats=collection_formats) 7485 7486 def get_envelope_document_html_definitions(self, account_id, document_id, envelope_id, **kwargs): 7487 """ 7488 Get the Original HTML Definition used to generate the Responsive HTML for a given document. 7489 7490 This method makes a synchronous HTTP request by default. To make an 7491 asynchronous HTTP request, please define a `callback` function 7492 to be invoked when receiving the response. 7493 >>> def callback_function(response): 7494 >>> pprint(response) 7495 >>> 7496 >>> thread = api.get_envelope_document_html_definitions(account_id, document_id, envelope_id, callback=callback_function) 7497 7498 :param callback function: The callback function 7499 for asynchronous request. (optional) 7500 :param str account_id: The external account number (int) or account ID Guid. (required) 7501 :param str document_id: The ID of the document being accessed. (required) 7502 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7503 :return: DocumentHtmlDefinitionOriginals 7504 If the method is called asynchronously, 7505 returns the request thread. 7506 """ 7507 kwargs['_return_http_data_only'] = True 7508 if kwargs.get('callback'): 7509 return self.get_envelope_document_html_definitions_with_http_info(account_id, document_id, envelope_id, **kwargs) 7510 else: 7511 (data) = self.get_envelope_document_html_definitions_with_http_info(account_id, document_id, envelope_id, **kwargs) 7512 return data 7513 7514 def get_envelope_document_html_definitions_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 7515 """ 7516 Get the Original HTML Definition used to generate the Responsive HTML for a given document. 7517 7518 This method makes a synchronous HTTP request by default. To make an 7519 asynchronous HTTP request, please define a `callback` function 7520 to be invoked when receiving the response. 7521 >>> def callback_function(response): 7522 >>> pprint(response) 7523 >>> 7524 >>> thread = api.get_envelope_document_html_definitions_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 7525 7526 :param callback function: The callback function 7527 for asynchronous request. (optional) 7528 :param str account_id: The external account number (int) or account ID Guid. (required) 7529 :param str document_id: The ID of the document being accessed. (required) 7530 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7531 :return: DocumentHtmlDefinitionOriginals 7532 If the method is called asynchronously, 7533 returns the request thread. 7534 """ 7535 7536 all_params = ['account_id', 'document_id', 'envelope_id'] 7537 all_params.append('callback') 7538 all_params.append('_return_http_data_only') 7539 all_params.append('_preload_content') 7540 all_params.append('_request_timeout') 7541 7542 params = locals() 7543 for key, val in iteritems(params['kwargs']): 7544 if key not in all_params: 7545 raise TypeError( 7546 "Got an unexpected keyword argument '%s'" 7547 " to method get_envelope_document_html_definitions" % key 7548 ) 7549 params[key] = val 7550 del params['kwargs'] 7551 # verify the required parameter 'account_id' is set 7552 if ('account_id' not in params) or (params['account_id'] is None): 7553 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_document_html_definitions`") 7554 # verify the required parameter 'document_id' is set 7555 if ('document_id' not in params) or (params['document_id'] is None): 7556 raise ValueError("Missing the required parameter `document_id` when calling `get_envelope_document_html_definitions`") 7557 # verify the required parameter 'envelope_id' is set 7558 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7559 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_document_html_definitions`") 7560 7561 7562 collection_formats = {} 7563 7564 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/html_definitions'.replace('{format}', 'json') 7565 path_params = {} 7566 if 'account_id' in params: 7567 path_params['accountId'] = params['account_id'] 7568 if 'document_id' in params: 7569 path_params['documentId'] = params['document_id'] 7570 if 'envelope_id' in params: 7571 path_params['envelopeId'] = params['envelope_id'] 7572 7573 query_params = {} 7574 7575 header_params = {} 7576 7577 form_params = [] 7578 local_var_files = {} 7579 7580 body_params = None 7581 # HTTP header `Accept` 7582 header_params['Accept'] = self.api_client.\ 7583 select_header_accept(['application/json']) 7584 7585 # Authentication setting 7586 auth_settings = [] 7587 7588 return self.api_client.call_api(resource_path, 'GET', 7589 path_params, 7590 query_params, 7591 header_params, 7592 body=body_params, 7593 post_params=form_params, 7594 files=local_var_files, 7595 response_type='DocumentHtmlDefinitionOriginals', 7596 auth_settings=auth_settings, 7597 callback=params.get('callback'), 7598 _return_http_data_only=params.get('_return_http_data_only'), 7599 _preload_content=params.get('_preload_content', True), 7600 _request_timeout=params.get('_request_timeout'), 7601 collection_formats=collection_formats) 7602 7603 def get_envelope_html_definitions(self, account_id, envelope_id, **kwargs): 7604 """ 7605 Get the Original HTML Definition used to generate the Responsive HTML for the envelope. 7606 7607 This method makes a synchronous HTTP request by default. To make an 7608 asynchronous HTTP request, please define a `callback` function 7609 to be invoked when receiving the response. 7610 >>> def callback_function(response): 7611 >>> pprint(response) 7612 >>> 7613 >>> thread = api.get_envelope_html_definitions(account_id, envelope_id, callback=callback_function) 7614 7615 :param callback function: The callback function 7616 for asynchronous request. (optional) 7617 :param str account_id: The external account number (int) or account ID Guid. (required) 7618 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7619 :return: DocumentHtmlDefinitionOriginals 7620 If the method is called asynchronously, 7621 returns the request thread. 7622 """ 7623 kwargs['_return_http_data_only'] = True 7624 if kwargs.get('callback'): 7625 return self.get_envelope_html_definitions_with_http_info(account_id, envelope_id, **kwargs) 7626 else: 7627 (data) = self.get_envelope_html_definitions_with_http_info(account_id, envelope_id, **kwargs) 7628 return data 7629 7630 def get_envelope_html_definitions_with_http_info(self, account_id, envelope_id, **kwargs): 7631 """ 7632 Get the Original HTML Definition used to generate the Responsive HTML for the envelope. 7633 7634 This method makes a synchronous HTTP request by default. To make an 7635 asynchronous HTTP request, please define a `callback` function 7636 to be invoked when receiving the response. 7637 >>> def callback_function(response): 7638 >>> pprint(response) 7639 >>> 7640 >>> thread = api.get_envelope_html_definitions_with_http_info(account_id, envelope_id, callback=callback_function) 7641 7642 :param callback function: The callback function 7643 for asynchronous request. (optional) 7644 :param str account_id: The external account number (int) or account ID Guid. (required) 7645 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7646 :return: DocumentHtmlDefinitionOriginals 7647 If the method is called asynchronously, 7648 returns the request thread. 7649 """ 7650 7651 all_params = ['account_id', 'envelope_id'] 7652 all_params.append('callback') 7653 all_params.append('_return_http_data_only') 7654 all_params.append('_preload_content') 7655 all_params.append('_request_timeout') 7656 7657 params = locals() 7658 for key, val in iteritems(params['kwargs']): 7659 if key not in all_params: 7660 raise TypeError( 7661 "Got an unexpected keyword argument '%s'" 7662 " to method get_envelope_html_definitions" % key 7663 ) 7664 params[key] = val 7665 del params['kwargs'] 7666 # verify the required parameter 'account_id' is set 7667 if ('account_id' not in params) or (params['account_id'] is None): 7668 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_html_definitions`") 7669 # verify the required parameter 'envelope_id' is set 7670 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7671 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_html_definitions`") 7672 7673 7674 collection_formats = {} 7675 7676 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/html_definitions'.replace('{format}', 'json') 7677 path_params = {} 7678 if 'account_id' in params: 7679 path_params['accountId'] = params['account_id'] 7680 if 'envelope_id' in params: 7681 path_params['envelopeId'] = params['envelope_id'] 7682 7683 query_params = {} 7684 7685 header_params = {} 7686 7687 form_params = [] 7688 local_var_files = {} 7689 7690 body_params = None 7691 # HTTP header `Accept` 7692 header_params['Accept'] = self.api_client.\ 7693 select_header_accept(['application/json']) 7694 7695 # Authentication setting 7696 auth_settings = [] 7697 7698 return self.api_client.call_api(resource_path, 'GET', 7699 path_params, 7700 query_params, 7701 header_params, 7702 body=body_params, 7703 post_params=form_params, 7704 files=local_var_files, 7705 response_type='DocumentHtmlDefinitionOriginals', 7706 auth_settings=auth_settings, 7707 callback=params.get('callback'), 7708 _return_http_data_only=params.get('_return_http_data_only'), 7709 _preload_content=params.get('_preload_content', True), 7710 _request_timeout=params.get('_request_timeout'), 7711 collection_formats=collection_formats) 7712 7713 def get_envelope_scheduled_sending_definition(self, account_id, envelope_id, **kwargs): 7714 """ 7715 Returns the scheduled sending rules for an envelope's workflow definition. 7716 This method makes a synchronous HTTP request by default. To make an 7717 asynchronous HTTP request, please define a `callback` function 7718 to be invoked when receiving the response. 7719 >>> def callback_function(response): 7720 >>> pprint(response) 7721 >>> 7722 >>> thread = api.get_envelope_scheduled_sending_definition(account_id, envelope_id, callback=callback_function) 7723 7724 :param callback function: The callback function 7725 for asynchronous request. (optional) 7726 :param str account_id: The external account number (int) or account ID Guid. (required) 7727 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7728 :return: ScheduledSending 7729 If the method is called asynchronously, 7730 returns the request thread. 7731 """ 7732 kwargs['_return_http_data_only'] = True 7733 if kwargs.get('callback'): 7734 return self.get_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 7735 else: 7736 (data) = self.get_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 7737 return data 7738 7739 def get_envelope_scheduled_sending_definition_with_http_info(self, account_id, envelope_id, **kwargs): 7740 """ 7741 Returns the scheduled sending rules for an envelope's workflow definition. 7742 This method makes a synchronous HTTP request by default. To make an 7743 asynchronous HTTP request, please define a `callback` function 7744 to be invoked when receiving the response. 7745 >>> def callback_function(response): 7746 >>> pprint(response) 7747 >>> 7748 >>> thread = api.get_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, callback=callback_function) 7749 7750 :param callback function: The callback function 7751 for asynchronous request. (optional) 7752 :param str account_id: The external account number (int) or account ID Guid. (required) 7753 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7754 :return: ScheduledSending 7755 If the method is called asynchronously, 7756 returns the request thread. 7757 """ 7758 7759 all_params = ['account_id', 'envelope_id'] 7760 all_params.append('callback') 7761 all_params.append('_return_http_data_only') 7762 all_params.append('_preload_content') 7763 all_params.append('_request_timeout') 7764 7765 params = locals() 7766 for key, val in iteritems(params['kwargs']): 7767 if key not in all_params: 7768 raise TypeError( 7769 "Got an unexpected keyword argument '%s'" 7770 " to method get_envelope_scheduled_sending_definition" % key 7771 ) 7772 params[key] = val 7773 del params['kwargs'] 7774 # verify the required parameter 'account_id' is set 7775 if ('account_id' not in params) or (params['account_id'] is None): 7776 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_scheduled_sending_definition`") 7777 # verify the required parameter 'envelope_id' is set 7778 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7779 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_scheduled_sending_definition`") 7780 7781 7782 collection_formats = {} 7783 7784 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/scheduledSending'.replace('{format}', 'json') 7785 path_params = {} 7786 if 'account_id' in params: 7787 path_params['accountId'] = params['account_id'] 7788 if 'envelope_id' in params: 7789 path_params['envelopeId'] = params['envelope_id'] 7790 7791 query_params = {} 7792 7793 header_params = {} 7794 7795 form_params = [] 7796 local_var_files = {} 7797 7798 body_params = None 7799 # HTTP header `Accept` 7800 header_params['Accept'] = self.api_client.\ 7801 select_header_accept(['application/json']) 7802 7803 # Authentication setting 7804 auth_settings = [] 7805 7806 return self.api_client.call_api(resource_path, 'GET', 7807 path_params, 7808 query_params, 7809 header_params, 7810 body=body_params, 7811 post_params=form_params, 7812 files=local_var_files, 7813 response_type='ScheduledSending', 7814 auth_settings=auth_settings, 7815 callback=params.get('callback'), 7816 _return_http_data_only=params.get('_return_http_data_only'), 7817 _preload_content=params.get('_preload_content', True), 7818 _request_timeout=params.get('_request_timeout'), 7819 collection_formats=collection_formats) 7820 7821 def get_envelope_transfer_rules(self, account_id, **kwargs): 7822 """ 7823 Returns a list of envelope transfer rules in the specified account. 7824 This method retrieves a list of envelope transfer rules associated with an account. **Note:** Only Administrators can create and use envelope transfer rules. In addition, to use envelope transfer rules, the **Transfer Custody** feature must be enabled for your account. 7825 This method makes a synchronous HTTP request by default. To make an 7826 asynchronous HTTP request, please define a `callback` function 7827 to be invoked when receiving the response. 7828 >>> def callback_function(response): 7829 >>> pprint(response) 7830 >>> 7831 >>> thread = api.get_envelope_transfer_rules(account_id, callback=callback_function) 7832 7833 :param callback function: The callback function 7834 for asynchronous request. (optional) 7835 :param str account_id: The external account number (int) or account ID Guid. (required) 7836 :param str count: 7837 :param str start_position: 7838 :return: EnvelopeTransferRuleInformation 7839 If the method is called asynchronously, 7840 returns the request thread. 7841 """ 7842 kwargs['_return_http_data_only'] = True 7843 if kwargs.get('callback'): 7844 return self.get_envelope_transfer_rules_with_http_info(account_id, **kwargs) 7845 else: 7846 (data) = self.get_envelope_transfer_rules_with_http_info(account_id, **kwargs) 7847 return data 7848 7849 def get_envelope_transfer_rules_with_http_info(self, account_id, **kwargs): 7850 """ 7851 Returns a list of envelope transfer rules in the specified account. 7852 This method retrieves a list of envelope transfer rules associated with an account. **Note:** Only Administrators can create and use envelope transfer rules. In addition, to use envelope transfer rules, the **Transfer Custody** feature must be enabled for your account. 7853 This method makes a synchronous HTTP request by default. To make an 7854 asynchronous HTTP request, please define a `callback` function 7855 to be invoked when receiving the response. 7856 >>> def callback_function(response): 7857 >>> pprint(response) 7858 >>> 7859 >>> thread = api.get_envelope_transfer_rules_with_http_info(account_id, callback=callback_function) 7860 7861 :param callback function: The callback function 7862 for asynchronous request. (optional) 7863 :param str account_id: The external account number (int) or account ID Guid. (required) 7864 :param str count: 7865 :param str start_position: 7866 :return: EnvelopeTransferRuleInformation 7867 If the method is called asynchronously, 7868 returns the request thread. 7869 """ 7870 7871 all_params = ['account_id', 'count', 'start_position'] 7872 all_params.append('callback') 7873 all_params.append('_return_http_data_only') 7874 all_params.append('_preload_content') 7875 all_params.append('_request_timeout') 7876 7877 params = locals() 7878 for key, val in iteritems(params['kwargs']): 7879 if key not in all_params: 7880 raise TypeError( 7881 "Got an unexpected keyword argument '%s'" 7882 " to method get_envelope_transfer_rules" % key 7883 ) 7884 params[key] = val 7885 del params['kwargs'] 7886 # verify the required parameter 'account_id' is set 7887 if ('account_id' not in params) or (params['account_id'] is None): 7888 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_transfer_rules`") 7889 7890 7891 collection_formats = {} 7892 7893 resource_path = '/v2.1/accounts/{accountId}/envelopes/transfer_rules'.replace('{format}', 'json') 7894 path_params = {} 7895 if 'account_id' in params: 7896 path_params['accountId'] = params['account_id'] 7897 7898 query_params = {} 7899 if 'count' in params: 7900 query_params['count'] = params['count'] 7901 if 'start_position' in params: 7902 query_params['start_position'] = params['start_position'] 7903 7904 header_params = {} 7905 7906 form_params = [] 7907 local_var_files = {} 7908 7909 body_params = None 7910 # HTTP header `Accept` 7911 header_params['Accept'] = self.api_client.\ 7912 select_header_accept(['application/json']) 7913 7914 # Authentication setting 7915 auth_settings = [] 7916 7917 return self.api_client.call_api(resource_path, 'GET', 7918 path_params, 7919 query_params, 7920 header_params, 7921 body=body_params, 7922 post_params=form_params, 7923 files=local_var_files, 7924 response_type='EnvelopeTransferRuleInformation', 7925 auth_settings=auth_settings, 7926 callback=params.get('callback'), 7927 _return_http_data_only=params.get('_return_http_data_only'), 7928 _preload_content=params.get('_preload_content', True), 7929 _request_timeout=params.get('_request_timeout'), 7930 collection_formats=collection_formats) 7931 7932 def get_envelope_workflow_definition(self, account_id, envelope_id, **kwargs): 7933 """ 7934 Returns the workflow definition for an envelope. 7935 Returns an envelope's workflow definition if the envelope specified by `envelopeId` has one. 7936 This method makes a synchronous HTTP request by default. To make an 7937 asynchronous HTTP request, please define a `callback` function 7938 to be invoked when receiving the response. 7939 >>> def callback_function(response): 7940 >>> pprint(response) 7941 >>> 7942 >>> thread = api.get_envelope_workflow_definition(account_id, envelope_id, callback=callback_function) 7943 7944 :param callback function: The callback function 7945 for asynchronous request. (optional) 7946 :param str account_id: The external account number (int) or account ID Guid. (required) 7947 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7948 :return: Workflow 7949 If the method is called asynchronously, 7950 returns the request thread. 7951 """ 7952 kwargs['_return_http_data_only'] = True 7953 if kwargs.get('callback'): 7954 return self.get_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 7955 else: 7956 (data) = self.get_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 7957 return data 7958 7959 def get_envelope_workflow_definition_with_http_info(self, account_id, envelope_id, **kwargs): 7960 """ 7961 Returns the workflow definition for an envelope. 7962 Returns an envelope's workflow definition if the envelope specified by `envelopeId` has one. 7963 This method makes a synchronous HTTP request by default. To make an 7964 asynchronous HTTP request, please define a `callback` function 7965 to be invoked when receiving the response. 7966 >>> def callback_function(response): 7967 >>> pprint(response) 7968 >>> 7969 >>> thread = api.get_envelope_workflow_definition_with_http_info(account_id, envelope_id, callback=callback_function) 7970 7971 :param callback function: The callback function 7972 for asynchronous request. (optional) 7973 :param str account_id: The external account number (int) or account ID Guid. (required) 7974 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7975 :return: Workflow 7976 If the method is called asynchronously, 7977 returns the request thread. 7978 """ 7979 7980 all_params = ['account_id', 'envelope_id'] 7981 all_params.append('callback') 7982 all_params.append('_return_http_data_only') 7983 all_params.append('_preload_content') 7984 all_params.append('_request_timeout') 7985 7986 params = locals() 7987 for key, val in iteritems(params['kwargs']): 7988 if key not in all_params: 7989 raise TypeError( 7990 "Got an unexpected keyword argument '%s'" 7991 " to method get_envelope_workflow_definition" % key 7992 ) 7993 params[key] = val 7994 del params['kwargs'] 7995 # verify the required parameter 'account_id' is set 7996 if ('account_id' not in params) or (params['account_id'] is None): 7997 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_workflow_definition`") 7998 # verify the required parameter 'envelope_id' is set 7999 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8000 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_workflow_definition`") 8001 8002 8003 collection_formats = {} 8004 8005 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow'.replace('{format}', 'json') 8006 path_params = {} 8007 if 'account_id' in params: 8008 path_params['accountId'] = params['account_id'] 8009 if 'envelope_id' in params: 8010 path_params['envelopeId'] = params['envelope_id'] 8011 8012 query_params = {} 8013 8014 header_params = {} 8015 8016 form_params = [] 8017 local_var_files = {} 8018 8019 body_params = None 8020 # HTTP header `Accept` 8021 header_params['Accept'] = self.api_client.\ 8022 select_header_accept(['application/json']) 8023 8024 # Authentication setting 8025 auth_settings = [] 8026 8027 return self.api_client.call_api(resource_path, 'GET', 8028 path_params, 8029 query_params, 8030 header_params, 8031 body=body_params, 8032 post_params=form_params, 8033 files=local_var_files, 8034 response_type='Workflow', 8035 auth_settings=auth_settings, 8036 callback=params.get('callback'), 8037 _return_http_data_only=params.get('_return_http_data_only'), 8038 _preload_content=params.get('_preload_content', True), 8039 _request_timeout=params.get('_request_timeout'), 8040 collection_formats=collection_formats) 8041 8042 def get_envelope_workflow_step_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 8043 """ 8044 Returns the workflow step definition for an envelope by step id. 8045 This method makes a synchronous HTTP request by default. To make an 8046 asynchronous HTTP request, please define a `callback` function 8047 to be invoked when receiving the response. 8048 >>> def callback_function(response): 8049 >>> pprint(response) 8050 >>> 8051 >>> thread = api.get_envelope_workflow_step_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 8052 8053 :param callback function: The callback function 8054 for asynchronous request. (optional) 8055 :param str account_id: The external account number (int) or account ID Guid. (required) 8056 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8057 :param str workflow_step_id: (required) 8058 :return: WorkflowStep 8059 If the method is called asynchronously, 8060 returns the request thread. 8061 """ 8062 kwargs['_return_http_data_only'] = True 8063 if kwargs.get('callback'): 8064 return self.get_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 8065 else: 8066 (data) = self.get_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 8067 return data 8068 8069 def get_envelope_workflow_step_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 8070 """ 8071 Returns the workflow step definition for an envelope by step id. 8072 This method makes a synchronous HTTP request by default. To make an 8073 asynchronous HTTP request, please define a `callback` function 8074 to be invoked when receiving the response. 8075 >>> def callback_function(response): 8076 >>> pprint(response) 8077 >>> 8078 >>> thread = api.get_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 8079 8080 :param callback function: The callback function 8081 for asynchronous request. (optional) 8082 :param str account_id: The external account number (int) or account ID Guid. (required) 8083 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8084 :param str workflow_step_id: (required) 8085 :return: WorkflowStep 8086 If the method is called asynchronously, 8087 returns the request thread. 8088 """ 8089 8090 all_params = ['account_id', 'envelope_id', 'workflow_step_id'] 8091 all_params.append('callback') 8092 all_params.append('_return_http_data_only') 8093 all_params.append('_preload_content') 8094 all_params.append('_request_timeout') 8095 8096 params = locals() 8097 for key, val in iteritems(params['kwargs']): 8098 if key not in all_params: 8099 raise TypeError( 8100 "Got an unexpected keyword argument '%s'" 8101 " to method get_envelope_workflow_step_definition" % key 8102 ) 8103 params[key] = val 8104 del params['kwargs'] 8105 # verify the required parameter 'account_id' is set 8106 if ('account_id' not in params) or (params['account_id'] is None): 8107 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_workflow_step_definition`") 8108 # verify the required parameter 'envelope_id' is set 8109 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8110 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_workflow_step_definition`") 8111 # verify the required parameter 'workflow_step_id' is set 8112 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 8113 raise ValueError("Missing the required parameter `workflow_step_id` when calling `get_envelope_workflow_step_definition`") 8114 8115 8116 collection_formats = {} 8117 8118 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 8119 path_params = {} 8120 if 'account_id' in params: 8121 path_params['accountId'] = params['account_id'] 8122 if 'envelope_id' in params: 8123 path_params['envelopeId'] = params['envelope_id'] 8124 if 'workflow_step_id' in params: 8125 path_params['workflowStepId'] = params['workflow_step_id'] 8126 8127 query_params = {} 8128 8129 header_params = {} 8130 8131 form_params = [] 8132 local_var_files = {} 8133 8134 body_params = None 8135 # HTTP header `Accept` 8136 header_params['Accept'] = self.api_client.\ 8137 select_header_accept(['application/json']) 8138 8139 # Authentication setting 8140 auth_settings = [] 8141 8142 return self.api_client.call_api(resource_path, 'GET', 8143 path_params, 8144 query_params, 8145 header_params, 8146 body=body_params, 8147 post_params=form_params, 8148 files=local_var_files, 8149 response_type='WorkflowStep', 8150 auth_settings=auth_settings, 8151 callback=params.get('callback'), 8152 _return_http_data_only=params.get('_return_http_data_only'), 8153 _preload_content=params.get('_preload_content', True), 8154 _request_timeout=params.get('_request_timeout'), 8155 collection_formats=collection_formats) 8156 8157 def get_form_data(self, account_id, envelope_id, **kwargs): 8158 """ 8159 Returns envelope form data for an existing envelope. 8160 This method downloads the envelope and tab data (also called form data) from any in-process, completed, or canceled envelope that you sent or that is shared with you. Recipients who are also full administrators on an account can view form data for any envelopes that another user on the account has sent to them. **Note:** To use this feature, the Sending Setting \"Allow sender to download form data\" must be enabled for the account. ### Related topics - [How to get envelope tab values](/docs/esign-rest-api/how-to/get-envelope-tab-values/) 8161 This method makes a synchronous HTTP request by default. To make an 8162 asynchronous HTTP request, please define a `callback` function 8163 to be invoked when receiving the response. 8164 >>> def callback_function(response): 8165 >>> pprint(response) 8166 >>> 8167 >>> thread = api.get_form_data(account_id, envelope_id, callback=callback_function) 8168 8169 :param callback function: The callback function 8170 for asynchronous request. (optional) 8171 :param str account_id: The external account number (int) or account ID Guid. (required) 8172 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8173 :return: EnvelopeFormData 8174 If the method is called asynchronously, 8175 returns the request thread. 8176 """ 8177 kwargs['_return_http_data_only'] = True 8178 if kwargs.get('callback'): 8179 return self.get_form_data_with_http_info(account_id, envelope_id, **kwargs) 8180 else: 8181 (data) = self.get_form_data_with_http_info(account_id, envelope_id, **kwargs) 8182 return data 8183 8184 def get_form_data_with_http_info(self, account_id, envelope_id, **kwargs): 8185 """ 8186 Returns envelope form data for an existing envelope. 8187 This method downloads the envelope and tab data (also called form data) from any in-process, completed, or canceled envelope that you sent or that is shared with you. Recipients who are also full administrators on an account can view form data for any envelopes that another user on the account has sent to them. **Note:** To use this feature, the Sending Setting \"Allow sender to download form data\" must be enabled for the account. ### Related topics - [How to get envelope tab values](/docs/esign-rest-api/how-to/get-envelope-tab-values/) 8188 This method makes a synchronous HTTP request by default. To make an 8189 asynchronous HTTP request, please define a `callback` function 8190 to be invoked when receiving the response. 8191 >>> def callback_function(response): 8192 >>> pprint(response) 8193 >>> 8194 >>> thread = api.get_form_data_with_http_info(account_id, envelope_id, callback=callback_function) 8195 8196 :param callback function: The callback function 8197 for asynchronous request. (optional) 8198 :param str account_id: The external account number (int) or account ID Guid. (required) 8199 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8200 :return: EnvelopeFormData 8201 If the method is called asynchronously, 8202 returns the request thread. 8203 """ 8204 8205 all_params = ['account_id', 'envelope_id'] 8206 all_params.append('callback') 8207 all_params.append('_return_http_data_only') 8208 all_params.append('_preload_content') 8209 all_params.append('_request_timeout') 8210 8211 params = locals() 8212 for key, val in iteritems(params['kwargs']): 8213 if key not in all_params: 8214 raise TypeError( 8215 "Got an unexpected keyword argument '%s'" 8216 " to method get_form_data" % key 8217 ) 8218 params[key] = val 8219 del params['kwargs'] 8220 # verify the required parameter 'account_id' is set 8221 if ('account_id' not in params) or (params['account_id'] is None): 8222 raise ValueError("Missing the required parameter `account_id` when calling `get_form_data`") 8223 # verify the required parameter 'envelope_id' is set 8224 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8225 raise ValueError("Missing the required parameter `envelope_id` when calling `get_form_data`") 8226 8227 8228 collection_formats = {} 8229 8230 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/form_data'.replace('{format}', 'json') 8231 path_params = {} 8232 if 'account_id' in params: 8233 path_params['accountId'] = params['account_id'] 8234 if 'envelope_id' in params: 8235 path_params['envelopeId'] = params['envelope_id'] 8236 8237 query_params = {} 8238 8239 header_params = {} 8240 8241 form_params = [] 8242 local_var_files = {} 8243 8244 body_params = None 8245 # HTTP header `Accept` 8246 header_params['Accept'] = self.api_client.\ 8247 select_header_accept(['application/json']) 8248 8249 # Authentication setting 8250 auth_settings = [] 8251 8252 return self.api_client.call_api(resource_path, 'GET', 8253 path_params, 8254 query_params, 8255 header_params, 8256 body=body_params, 8257 post_params=form_params, 8258 files=local_var_files, 8259 response_type='EnvelopeFormData', 8260 auth_settings=auth_settings, 8261 callback=params.get('callback'), 8262 _return_http_data_only=params.get('_return_http_data_only'), 8263 _preload_content=params.get('_preload_content', True), 8264 _request_timeout=params.get('_request_timeout'), 8265 collection_formats=collection_formats) 8266 8267 def get_lock(self, account_id, envelope_id, **kwargs): 8268 """ 8269 Gets envelope lock information. 8270 Retrieves general information about the envelope lock. If the call is made by the locked by user and the request has the same integrator key as original, then the `X-DocuSign-Edit` header and additional lock information is included in the response. This allows users to recover a lost editing session token and the `X-DocuSign-Edit` header. 8271 This method makes a synchronous HTTP request by default. To make an 8272 asynchronous HTTP request, please define a `callback` function 8273 to be invoked when receiving the response. 8274 >>> def callback_function(response): 8275 >>> pprint(response) 8276 >>> 8277 >>> thread = api.get_lock(account_id, envelope_id, callback=callback_function) 8278 8279 :param callback function: The callback function 8280 for asynchronous request. (optional) 8281 :param str account_id: The external account number (int) or account ID Guid. (required) 8282 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8283 :return: LockInformation 8284 If the method is called asynchronously, 8285 returns the request thread. 8286 """ 8287 kwargs['_return_http_data_only'] = True 8288 if kwargs.get('callback'): 8289 return self.get_lock_with_http_info(account_id, envelope_id, **kwargs) 8290 else: 8291 (data) = self.get_lock_with_http_info(account_id, envelope_id, **kwargs) 8292 return data 8293 8294 def get_lock_with_http_info(self, account_id, envelope_id, **kwargs): 8295 """ 8296 Gets envelope lock information. 8297 Retrieves general information about the envelope lock. If the call is made by the locked by user and the request has the same integrator key as original, then the `X-DocuSign-Edit` header and additional lock information is included in the response. This allows users to recover a lost editing session token and the `X-DocuSign-Edit` header. 8298 This method makes a synchronous HTTP request by default. To make an 8299 asynchronous HTTP request, please define a `callback` function 8300 to be invoked when receiving the response. 8301 >>> def callback_function(response): 8302 >>> pprint(response) 8303 >>> 8304 >>> thread = api.get_lock_with_http_info(account_id, envelope_id, callback=callback_function) 8305 8306 :param callback function: The callback function 8307 for asynchronous request. (optional) 8308 :param str account_id: The external account number (int) or account ID Guid. (required) 8309 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8310 :return: LockInformation 8311 If the method is called asynchronously, 8312 returns the request thread. 8313 """ 8314 8315 all_params = ['account_id', 'envelope_id'] 8316 all_params.append('callback') 8317 all_params.append('_return_http_data_only') 8318 all_params.append('_preload_content') 8319 all_params.append('_request_timeout') 8320 8321 params = locals() 8322 for key, val in iteritems(params['kwargs']): 8323 if key not in all_params: 8324 raise TypeError( 8325 "Got an unexpected keyword argument '%s'" 8326 " to method get_lock" % key 8327 ) 8328 params[key] = val 8329 del params['kwargs'] 8330 # verify the required parameter 'account_id' is set 8331 if ('account_id' not in params) or (params['account_id'] is None): 8332 raise ValueError("Missing the required parameter `account_id` when calling `get_lock`") 8333 # verify the required parameter 'envelope_id' is set 8334 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8335 raise ValueError("Missing the required parameter `envelope_id` when calling `get_lock`") 8336 8337 8338 collection_formats = {} 8339 8340 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/lock'.replace('{format}', 'json') 8341 path_params = {} 8342 if 'account_id' in params: 8343 path_params['accountId'] = params['account_id'] 8344 if 'envelope_id' in params: 8345 path_params['envelopeId'] = params['envelope_id'] 8346 8347 query_params = {} 8348 8349 header_params = {} 8350 8351 form_params = [] 8352 local_var_files = {} 8353 8354 body_params = None 8355 # HTTP header `Accept` 8356 header_params['Accept'] = self.api_client.\ 8357 select_header_accept(['application/json']) 8358 8359 # Authentication setting 8360 auth_settings = [] 8361 8362 return self.api_client.call_api(resource_path, 'GET', 8363 path_params, 8364 query_params, 8365 header_params, 8366 body=body_params, 8367 post_params=form_params, 8368 files=local_var_files, 8369 response_type='LockInformation', 8370 auth_settings=auth_settings, 8371 callback=params.get('callback'), 8372 _return_http_data_only=params.get('_return_http_data_only'), 8373 _preload_content=params.get('_preload_content', True), 8374 _request_timeout=params.get('_request_timeout'), 8375 collection_formats=collection_formats) 8376 8377 def get_notification_settings(self, account_id, envelope_id, **kwargs): 8378 """ 8379 Gets envelope notification information. 8380 Retrieves the envelope notification, reminders and expirations, information for an existing envelope. 8381 This method makes a synchronous HTTP request by default. To make an 8382 asynchronous HTTP request, please define a `callback` function 8383 to be invoked when receiving the response. 8384 >>> def callback_function(response): 8385 >>> pprint(response) 8386 >>> 8387 >>> thread = api.get_notification_settings(account_id, envelope_id, callback=callback_function) 8388 8389 :param callback function: The callback function 8390 for asynchronous request. (optional) 8391 :param str account_id: The external account number (int) or account ID Guid. (required) 8392 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8393 :return: Notification 8394 If the method is called asynchronously, 8395 returns the request thread. 8396 """ 8397 kwargs['_return_http_data_only'] = True 8398 if kwargs.get('callback'): 8399 return self.get_notification_settings_with_http_info(account_id, envelope_id, **kwargs) 8400 else: 8401 (data) = self.get_notification_settings_with_http_info(account_id, envelope_id, **kwargs) 8402 return data 8403 8404 def get_notification_settings_with_http_info(self, account_id, envelope_id, **kwargs): 8405 """ 8406 Gets envelope notification information. 8407 Retrieves the envelope notification, reminders and expirations, information for an existing envelope. 8408 This method makes a synchronous HTTP request by default. To make an 8409 asynchronous HTTP request, please define a `callback` function 8410 to be invoked when receiving the response. 8411 >>> def callback_function(response): 8412 >>> pprint(response) 8413 >>> 8414 >>> thread = api.get_notification_settings_with_http_info(account_id, envelope_id, callback=callback_function) 8415 8416 :param callback function: The callback function 8417 for asynchronous request. (optional) 8418 :param str account_id: The external account number (int) or account ID Guid. (required) 8419 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8420 :return: Notification 8421 If the method is called asynchronously, 8422 returns the request thread. 8423 """ 8424 8425 all_params = ['account_id', 'envelope_id'] 8426 all_params.append('callback') 8427 all_params.append('_return_http_data_only') 8428 all_params.append('_preload_content') 8429 all_params.append('_request_timeout') 8430 8431 params = locals() 8432 for key, val in iteritems(params['kwargs']): 8433 if key not in all_params: 8434 raise TypeError( 8435 "Got an unexpected keyword argument '%s'" 8436 " to method get_notification_settings" % key 8437 ) 8438 params[key] = val 8439 del params['kwargs'] 8440 # verify the required parameter 'account_id' is set 8441 if ('account_id' not in params) or (params['account_id'] is None): 8442 raise ValueError("Missing the required parameter `account_id` when calling `get_notification_settings`") 8443 # verify the required parameter 'envelope_id' is set 8444 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8445 raise ValueError("Missing the required parameter `envelope_id` when calling `get_notification_settings`") 8446 8447 8448 collection_formats = {} 8449 8450 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/notification'.replace('{format}', 'json') 8451 path_params = {} 8452 if 'account_id' in params: 8453 path_params['accountId'] = params['account_id'] 8454 if 'envelope_id' in params: 8455 path_params['envelopeId'] = params['envelope_id'] 8456 8457 query_params = {} 8458 8459 header_params = {} 8460 8461 form_params = [] 8462 local_var_files = {} 8463 8464 body_params = None 8465 # HTTP header `Accept` 8466 header_params['Accept'] = self.api_client.\ 8467 select_header_accept(['application/json']) 8468 8469 # Authentication setting 8470 auth_settings = [] 8471 8472 return self.api_client.call_api(resource_path, 'GET', 8473 path_params, 8474 query_params, 8475 header_params, 8476 body=body_params, 8477 post_params=form_params, 8478 files=local_var_files, 8479 response_type='Notification', 8480 auth_settings=auth_settings, 8481 callback=params.get('callback'), 8482 _return_http_data_only=params.get('_return_http_data_only'), 8483 _preload_content=params.get('_preload_content', True), 8484 _request_timeout=params.get('_request_timeout'), 8485 collection_formats=collection_formats) 8486 8487 def get_page_tabs(self, account_id, document_id, envelope_id, page_number, **kwargs): 8488 """ 8489 Returns tabs on the specified page. 8490 Returns the tabs from the page specified by `pageNumber` of the document specified by `documentId` in the envelope specified by `envelopeId`. 8491 This method makes a synchronous HTTP request by default. To make an 8492 asynchronous HTTP request, please define a `callback` function 8493 to be invoked when receiving the response. 8494 >>> def callback_function(response): 8495 >>> pprint(response) 8496 >>> 8497 >>> thread = api.get_page_tabs(account_id, document_id, envelope_id, page_number, callback=callback_function) 8498 8499 :param callback function: The callback function 8500 for asynchronous request. (optional) 8501 :param str account_id: The external account number (int) or account ID Guid. (required) 8502 :param str document_id: The ID of the document being accessed. (required) 8503 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8504 :param str page_number: The page number being accessed. (required) 8505 :return: Tabs 8506 If the method is called asynchronously, 8507 returns the request thread. 8508 """ 8509 kwargs['_return_http_data_only'] = True 8510 if kwargs.get('callback'): 8511 return self.get_page_tabs_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 8512 else: 8513 (data) = self.get_page_tabs_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 8514 return data 8515 8516 def get_page_tabs_with_http_info(self, account_id, document_id, envelope_id, page_number, **kwargs): 8517 """ 8518 Returns tabs on the specified page. 8519 Returns the tabs from the page specified by `pageNumber` of the document specified by `documentId` in the envelope specified by `envelopeId`. 8520 This method makes a synchronous HTTP request by default. To make an 8521 asynchronous HTTP request, please define a `callback` function 8522 to be invoked when receiving the response. 8523 >>> def callback_function(response): 8524 >>> pprint(response) 8525 >>> 8526 >>> thread = api.get_page_tabs_with_http_info(account_id, document_id, envelope_id, page_number, callback=callback_function) 8527 8528 :param callback function: The callback function 8529 for asynchronous request. (optional) 8530 :param str account_id: The external account number (int) or account ID Guid. (required) 8531 :param str document_id: The ID of the document being accessed. (required) 8532 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8533 :param str page_number: The page number being accessed. (required) 8534 :return: Tabs 8535 If the method is called asynchronously, 8536 returns the request thread. 8537 """ 8538 8539 all_params = ['account_id', 'document_id', 'envelope_id', 'page_number'] 8540 all_params.append('callback') 8541 all_params.append('_return_http_data_only') 8542 all_params.append('_preload_content') 8543 all_params.append('_request_timeout') 8544 8545 params = locals() 8546 for key, val in iteritems(params['kwargs']): 8547 if key not in all_params: 8548 raise TypeError( 8549 "Got an unexpected keyword argument '%s'" 8550 " to method get_page_tabs" % key 8551 ) 8552 params[key] = val 8553 del params['kwargs'] 8554 # verify the required parameter 'account_id' is set 8555 if ('account_id' not in params) or (params['account_id'] is None): 8556 raise ValueError("Missing the required parameter `account_id` when calling `get_page_tabs`") 8557 # verify the required parameter 'document_id' is set 8558 if ('document_id' not in params) or (params['document_id'] is None): 8559 raise ValueError("Missing the required parameter `document_id` when calling `get_page_tabs`") 8560 # verify the required parameter 'envelope_id' is set 8561 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8562 raise ValueError("Missing the required parameter `envelope_id` when calling `get_page_tabs`") 8563 # verify the required parameter 'page_number' is set 8564 if ('page_number' not in params) or (params['page_number'] is None): 8565 raise ValueError("Missing the required parameter `page_number` when calling `get_page_tabs`") 8566 8567 8568 collection_formats = {} 8569 8570 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/pages/{pageNumber}/tabs'.replace('{format}', 'json') 8571 path_params = {} 8572 if 'account_id' in params: 8573 path_params['accountId'] = params['account_id'] 8574 if 'document_id' in params: 8575 path_params['documentId'] = params['document_id'] 8576 if 'envelope_id' in params: 8577 path_params['envelopeId'] = params['envelope_id'] 8578 if 'page_number' in params: 8579 path_params['pageNumber'] = params['page_number'] 8580 8581 query_params = {} 8582 8583 header_params = {} 8584 8585 form_params = [] 8586 local_var_files = {} 8587 8588 body_params = None 8589 # HTTP header `Accept` 8590 header_params['Accept'] = self.api_client.\ 8591 select_header_accept(['application/json']) 8592 8593 # Authentication setting 8594 auth_settings = [] 8595 8596 return self.api_client.call_api(resource_path, 'GET', 8597 path_params, 8598 query_params, 8599 header_params, 8600 body=body_params, 8601 post_params=form_params, 8602 files=local_var_files, 8603 response_type='Tabs', 8604 auth_settings=auth_settings, 8605 callback=params.get('callback'), 8606 _return_http_data_only=params.get('_return_http_data_only'), 8607 _preload_content=params.get('_preload_content', True), 8608 _request_timeout=params.get('_request_timeout'), 8609 collection_formats=collection_formats) 8610 8611 def get_pages(self, account_id, document_id, envelope_id, **kwargs): 8612 """ 8613 Returns document page image(s) based on input. 8614 Returns images of the pages in a document for display based on the parameters that you specify. 8615 This method makes a synchronous HTTP request by default. To make an 8616 asynchronous HTTP request, please define a `callback` function 8617 to be invoked when receiving the response. 8618 >>> def callback_function(response): 8619 >>> pprint(response) 8620 >>> 8621 >>> thread = api.get_pages(account_id, document_id, envelope_id, callback=callback_function) 8622 8623 :param callback function: The callback function 8624 for asynchronous request. (optional) 8625 :param str account_id: The external account number (int) or account ID Guid. (required) 8626 :param str document_id: The ID of the document being accessed. (required) 8627 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8628 :param str count: 8629 :param str dpi: 8630 :param str max_height: 8631 :param str max_width: 8632 :param str nocache: 8633 :param str show_changes: 8634 :param str start_position: 8635 :return: PageImages 8636 If the method is called asynchronously, 8637 returns the request thread. 8638 """ 8639 kwargs['_return_http_data_only'] = True 8640 if kwargs.get('callback'): 8641 return self.get_pages_with_http_info(account_id, document_id, envelope_id, **kwargs) 8642 else: 8643 (data) = self.get_pages_with_http_info(account_id, document_id, envelope_id, **kwargs) 8644 return data 8645 8646 def get_pages_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 8647 """ 8648 Returns document page image(s) based on input. 8649 Returns images of the pages in a document for display based on the parameters that you specify. 8650 This method makes a synchronous HTTP request by default. To make an 8651 asynchronous HTTP request, please define a `callback` function 8652 to be invoked when receiving the response. 8653 >>> def callback_function(response): 8654 >>> pprint(response) 8655 >>> 8656 >>> thread = api.get_pages_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 8657 8658 :param callback function: The callback function 8659 for asynchronous request. (optional) 8660 :param str account_id: The external account number (int) or account ID Guid. (required) 8661 :param str document_id: The ID of the document being accessed. (required) 8662 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8663 :param str count: 8664 :param str dpi: 8665 :param str max_height: 8666 :param str max_width: 8667 :param str nocache: 8668 :param str show_changes: 8669 :param str start_position: 8670 :return: PageImages 8671 If the method is called asynchronously, 8672 returns the request thread. 8673 """ 8674 8675 all_params = ['account_id', 'document_id', 'envelope_id', 'count', 'dpi', 'max_height', 'max_width', 'nocache', 'show_changes', 'start_position'] 8676 all_params.append('callback') 8677 all_params.append('_return_http_data_only') 8678 all_params.append('_preload_content') 8679 all_params.append('_request_timeout') 8680 8681 params = locals() 8682 for key, val in iteritems(params['kwargs']): 8683 if key not in all_params: 8684 raise TypeError( 8685 "Got an unexpected keyword argument '%s'" 8686 " to method get_pages" % key 8687 ) 8688 params[key] = val 8689 del params['kwargs'] 8690 # verify the required parameter 'account_id' is set 8691 if ('account_id' not in params) or (params['account_id'] is None): 8692 raise ValueError("Missing the required parameter `account_id` when calling `get_pages`") 8693 # verify the required parameter 'document_id' is set 8694 if ('document_id' not in params) or (params['document_id'] is None): 8695 raise ValueError("Missing the required parameter `document_id` when calling `get_pages`") 8696 # verify the required parameter 'envelope_id' is set 8697 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8698 raise ValueError("Missing the required parameter `envelope_id` when calling `get_pages`") 8699 8700 8701 collection_formats = {} 8702 8703 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/pages'.replace('{format}', 'json') 8704 path_params = {} 8705 if 'account_id' in params: 8706 path_params['accountId'] = params['account_id'] 8707 if 'document_id' in params: 8708 path_params['documentId'] = params['document_id'] 8709 if 'envelope_id' in params: 8710 path_params['envelopeId'] = params['envelope_id'] 8711 8712 query_params = {} 8713 if 'count' in params: 8714 query_params['count'] = params['count'] 8715 if 'dpi' in params: 8716 query_params['dpi'] = params['dpi'] 8717 if 'max_height' in params: 8718 query_params['max_height'] = params['max_height'] 8719 if 'max_width' in params: 8720 query_params['max_width'] = params['max_width'] 8721 if 'nocache' in params: 8722 query_params['nocache'] = params['nocache'] 8723 if 'show_changes' in params: 8724 query_params['show_changes'] = params['show_changes'] 8725 if 'start_position' in params: 8726 query_params['start_position'] = params['start_position'] 8727 8728 header_params = {} 8729 8730 form_params = [] 8731 local_var_files = {} 8732 8733 body_params = None 8734 # HTTP header `Accept` 8735 header_params['Accept'] = self.api_client.\ 8736 select_header_accept(['application/json']) 8737 8738 # Authentication setting 8739 auth_settings = [] 8740 8741 return self.api_client.call_api(resource_path, 'GET', 8742 path_params, 8743 query_params, 8744 header_params, 8745 body=body_params, 8746 post_params=form_params, 8747 files=local_var_files, 8748 response_type='PageImages', 8749 auth_settings=auth_settings, 8750 callback=params.get('callback'), 8751 _return_http_data_only=params.get('_return_http_data_only'), 8752 _preload_content=params.get('_preload_content', True), 8753 _request_timeout=params.get('_request_timeout'), 8754 collection_formats=collection_formats) 8755 8756 def get_recipient_document_visibility(self, account_id, envelope_id, recipient_id, **kwargs): 8757 """ 8758 Returns document visibility for the recipients 8759 This method returns information about document visibility for a recipient. 8760 This method makes a synchronous HTTP request by default. To make an 8761 asynchronous HTTP request, please define a `callback` function 8762 to be invoked when receiving the response. 8763 >>> def callback_function(response): 8764 >>> pprint(response) 8765 >>> 8766 >>> thread = api.get_recipient_document_visibility(account_id, envelope_id, recipient_id, callback=callback_function) 8767 8768 :param callback function: The callback function 8769 for asynchronous request. (optional) 8770 :param str account_id: The external account number (int) or account ID Guid. (required) 8771 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8772 :param str recipient_id: The ID of the recipient being accessed. (required) 8773 :return: DocumentVisibilityList 8774 If the method is called asynchronously, 8775 returns the request thread. 8776 """ 8777 kwargs['_return_http_data_only'] = True 8778 if kwargs.get('callback'): 8779 return self.get_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 8780 else: 8781 (data) = self.get_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 8782 return data 8783 8784 def get_recipient_document_visibility_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 8785 """ 8786 Returns document visibility for the recipients 8787 This method returns information about document visibility for a recipient. 8788 This method makes a synchronous HTTP request by default. To make an 8789 asynchronous HTTP request, please define a `callback` function 8790 to be invoked when receiving the response. 8791 >>> def callback_function(response): 8792 >>> pprint(response) 8793 >>> 8794 >>> thread = api.get_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 8795 8796 :param callback function: The callback function 8797 for asynchronous request. (optional) 8798 :param str account_id: The external account number (int) or account ID Guid. (required) 8799 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8800 :param str recipient_id: The ID of the recipient being accessed. (required) 8801 :return: DocumentVisibilityList 8802 If the method is called asynchronously, 8803 returns the request thread. 8804 """ 8805 8806 all_params = ['account_id', 'envelope_id', 'recipient_id'] 8807 all_params.append('callback') 8808 all_params.append('_return_http_data_only') 8809 all_params.append('_preload_content') 8810 all_params.append('_request_timeout') 8811 8812 params = locals() 8813 for key, val in iteritems(params['kwargs']): 8814 if key not in all_params: 8815 raise TypeError( 8816 "Got an unexpected keyword argument '%s'" 8817 " to method get_recipient_document_visibility" % key 8818 ) 8819 params[key] = val 8820 del params['kwargs'] 8821 # verify the required parameter 'account_id' is set 8822 if ('account_id' not in params) or (params['account_id'] is None): 8823 raise ValueError("Missing the required parameter `account_id` when calling `get_recipient_document_visibility`") 8824 # verify the required parameter 'envelope_id' is set 8825 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8826 raise ValueError("Missing the required parameter `envelope_id` when calling `get_recipient_document_visibility`") 8827 # verify the required parameter 'recipient_id' is set 8828 if ('recipient_id' not in params) or (params['recipient_id'] is None): 8829 raise ValueError("Missing the required parameter `recipient_id` when calling `get_recipient_document_visibility`") 8830 8831 8832 collection_formats = {} 8833 8834 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/document_visibility'.replace('{format}', 'json') 8835 path_params = {} 8836 if 'account_id' in params: 8837 path_params['accountId'] = params['account_id'] 8838 if 'envelope_id' in params: 8839 path_params['envelopeId'] = params['envelope_id'] 8840 if 'recipient_id' in params: 8841 path_params['recipientId'] = params['recipient_id'] 8842 8843 query_params = {} 8844 8845 header_params = {} 8846 8847 form_params = [] 8848 local_var_files = {} 8849 8850 body_params = None 8851 # HTTP header `Accept` 8852 header_params['Accept'] = self.api_client.\ 8853 select_header_accept(['application/json']) 8854 8855 # Authentication setting 8856 auth_settings = [] 8857 8858 return self.api_client.call_api(resource_path, 'GET', 8859 path_params, 8860 query_params, 8861 header_params, 8862 body=body_params, 8863 post_params=form_params, 8864 files=local_var_files, 8865 response_type='DocumentVisibilityList', 8866 auth_settings=auth_settings, 8867 callback=params.get('callback'), 8868 _return_http_data_only=params.get('_return_http_data_only'), 8869 _preload_content=params.get('_preload_content', True), 8870 _request_timeout=params.get('_request_timeout'), 8871 collection_formats=collection_formats) 8872 8873 def get_recipient_initials_image(self, account_id, envelope_id, recipient_id, **kwargs): 8874 """ 8875 Gets the initials image for a user. 8876 Retrieves the initials image for the specified user. The image is returned in the same format as it was uploaded. In the request you can specify if the chrome (the added line and identifier around the initial image) is returned with the image. The userId specified in the endpoint must match the authenticated user's user id and the user must be a member of the account. The `signatureIdOrName` paramter accepts signature ID or signature name. DocuSign recommends you use signature ID (`signatureId`), since some names contain characters that do not properly URL encode. If you use the user name, it is likely that the name includes spaces and you might need to URL encode the name before using it in the endpoint. For example: \"Bob Smith\" to \"Bob%20Smith\" Older envelopes might only contain chromed images. If getting the non-chromed image fails, try getting the chromed image. 8877 This method makes a synchronous HTTP request by default. To make an 8878 asynchronous HTTP request, please define a `callback` function 8879 to be invoked when receiving the response. 8880 >>> def callback_function(response): 8881 >>> pprint(response) 8882 >>> 8883 >>> thread = api.get_recipient_initials_image(account_id, envelope_id, recipient_id, callback=callback_function) 8884 8885 :param callback function: The callback function 8886 for asynchronous request. (optional) 8887 :param str account_id: The external account number (int) or account ID Guid. (required) 8888 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8889 :param str recipient_id: The ID of the recipient being accessed. (required) 8890 :param str include_chrome: The added line and identifier around the initial image. Note: Older envelopes might only have chromed images. If getting the non-chromed image fails, try getting the chromed image. 8891 :return: file 8892 If the method is called asynchronously, 8893 returns the request thread. 8894 """ 8895 kwargs['_return_http_data_only'] = True 8896 if kwargs.get('callback'): 8897 return self.get_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 8898 else: 8899 (data) = self.get_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 8900 return data 8901 8902 def get_recipient_initials_image_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 8903 """ 8904 Gets the initials image for a user. 8905 Retrieves the initials image for the specified user. The image is returned in the same format as it was uploaded. In the request you can specify if the chrome (the added line and identifier around the initial image) is returned with the image. The userId specified in the endpoint must match the authenticated user's user id and the user must be a member of the account. The `signatureIdOrName` paramter accepts signature ID or signature name. DocuSign recommends you use signature ID (`signatureId`), since some names contain characters that do not properly URL encode. If you use the user name, it is likely that the name includes spaces and you might need to URL encode the name before using it in the endpoint. For example: \"Bob Smith\" to \"Bob%20Smith\" Older envelopes might only contain chromed images. If getting the non-chromed image fails, try getting the chromed image. 8906 This method makes a synchronous HTTP request by default. To make an 8907 asynchronous HTTP request, please define a `callback` function 8908 to be invoked when receiving the response. 8909 >>> def callback_function(response): 8910 >>> pprint(response) 8911 >>> 8912 >>> thread = api.get_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 8913 8914 :param callback function: The callback function 8915 for asynchronous request. (optional) 8916 :param str account_id: The external account number (int) or account ID Guid. (required) 8917 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8918 :param str recipient_id: The ID of the recipient being accessed. (required) 8919 :param str include_chrome: The added line and identifier around the initial image. Note: Older envelopes might only have chromed images. If getting the non-chromed image fails, try getting the chromed image. 8920 :return: file 8921 If the method is called asynchronously, 8922 returns the request thread. 8923 """ 8924 8925 all_params = ['account_id', 'envelope_id', 'recipient_id', 'include_chrome'] 8926 all_params.append('callback') 8927 all_params.append('_return_http_data_only') 8928 all_params.append('_preload_content') 8929 all_params.append('_request_timeout') 8930 8931 params = locals() 8932 for key, val in iteritems(params['kwargs']): 8933 if key not in all_params: 8934 raise TypeError( 8935 "Got an unexpected keyword argument '%s'" 8936 " to method get_recipient_initials_image" % key 8937 ) 8938 params[key] = val 8939 del params['kwargs'] 8940 # verify the required parameter 'account_id' is set 8941 if ('account_id' not in params) or (params['account_id'] is None): 8942 raise ValueError("Missing the required parameter `account_id` when calling `get_recipient_initials_image`") 8943 # verify the required parameter 'envelope_id' is set 8944 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8945 raise ValueError("Missing the required parameter `envelope_id` when calling `get_recipient_initials_image`") 8946 # verify the required parameter 'recipient_id' is set 8947 if ('recipient_id' not in params) or (params['recipient_id'] is None): 8948 raise ValueError("Missing the required parameter `recipient_id` when calling `get_recipient_initials_image`") 8949 8950 8951 collection_formats = {} 8952 8953 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/initials_image'.replace('{format}', 'json') 8954 path_params = {} 8955 if 'account_id' in params: 8956 path_params['accountId'] = params['account_id'] 8957 if 'envelope_id' in params: 8958 path_params['envelopeId'] = params['envelope_id'] 8959 if 'recipient_id' in params: 8960 path_params['recipientId'] = params['recipient_id'] 8961 8962 query_params = {} 8963 if 'include_chrome' in params: 8964 query_params['include_chrome'] = params['include_chrome'] 8965 8966 header_params = {} 8967 8968 form_params = [] 8969 local_var_files = {} 8970 8971 body_params = None 8972 # HTTP header `Accept` 8973 header_params['Accept'] = self.api_client.\ 8974 select_header_accept(['image/gif']) 8975 8976 # Authentication setting 8977 auth_settings = [] 8978 8979 return self.api_client.call_api(resource_path, 'GET', 8980 path_params, 8981 query_params, 8982 header_params, 8983 body=body_params, 8984 post_params=form_params, 8985 files=local_var_files, 8986 response_type='file', 8987 auth_settings=auth_settings, 8988 callback=params.get('callback'), 8989 _return_http_data_only=params.get('_return_http_data_only'), 8990 _preload_content=params.get('_preload_content', True), 8991 _request_timeout=params.get('_request_timeout'), 8992 collection_formats=collection_formats) 8993 8994 def get_recipient_signature(self, account_id, envelope_id, recipient_id, **kwargs): 8995 """ 8996 Gets signature information for a signer or sign-in-person recipient. 8997 Retrieves signature information for a signer or sign-in-person recipient. 8998 This method makes a synchronous HTTP request by default. To make an 8999 asynchronous HTTP request, please define a `callback` function 9000 to be invoked when receiving the response. 9001 >>> def callback_function(response): 9002 >>> pprint(response) 9003 >>> 9004 >>> thread = api.get_recipient_signature(account_id, envelope_id, recipient_id, callback=callback_function) 9005 9006 :param callback function: The callback function 9007 for asynchronous request. (optional) 9008 :param str account_id: The external account number (int) or account ID Guid. (required) 9009 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9010 :param str recipient_id: The ID of the recipient being accessed. (required) 9011 :return: UserSignature 9012 If the method is called asynchronously, 9013 returns the request thread. 9014 """ 9015 kwargs['_return_http_data_only'] = True 9016 if kwargs.get('callback'): 9017 return self.get_recipient_signature_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 9018 else: 9019 (data) = self.get_recipient_signature_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 9020 return data 9021 9022 def get_recipient_signature_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 9023 """ 9024 Gets signature information for a signer or sign-in-person recipient. 9025 Retrieves signature information for a signer or sign-in-person recipient. 9026 This method makes a synchronous HTTP request by default. To make an 9027 asynchronous HTTP request, please define a `callback` function 9028 to be invoked when receiving the response. 9029 >>> def callback_function(response): 9030 >>> pprint(response) 9031 >>> 9032 >>> thread = api.get_recipient_signature_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 9033 9034 :param callback function: The callback function 9035 for asynchronous request. (optional) 9036 :param str account_id: The external account number (int) or account ID Guid. (required) 9037 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9038 :param str recipient_id: The ID of the recipient being accessed. (required) 9039 :return: UserSignature 9040 If the method is called asynchronously, 9041 returns the request thread. 9042 """ 9043 9044 all_params = ['account_id', 'envelope_id', 'recipient_id'] 9045 all_params.append('callback') 9046 all_params.append('_return_http_data_only') 9047 all_params.append('_preload_content') 9048 all_params.append('_request_timeout') 9049 9050 params = locals() 9051 for key, val in iteritems(params['kwargs']): 9052 if key not in all_params: 9053 raise TypeError( 9054 "Got an unexpected keyword argument '%s'" 9055 " to method get_recipient_signature" % key 9056 ) 9057 params[key] = val 9058 del params['kwargs'] 9059 # verify the required parameter 'account_id' is set 9060 if ('account_id' not in params) or (params['account_id'] is None): 9061 raise ValueError("Missing the required parameter `account_id` when calling `get_recipient_signature`") 9062 # verify the required parameter 'envelope_id' is set 9063 if ('envelope_id' not in params) or (params['envelope_id'] is None): 9064 raise ValueError("Missing the required parameter `envelope_id` when calling `get_recipient_signature`") 9065 # verify the required parameter 'recipient_id' is set 9066 if ('recipient_id' not in params) or (params['recipient_id'] is None): 9067 raise ValueError("Missing the required parameter `recipient_id` when calling `get_recipient_signature`") 9068 9069 9070 collection_formats = {} 9071 9072 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/signature'.replace('{format}', 'json') 9073 path_params = {} 9074 if 'account_id' in params: 9075 path_params['accountId'] = params['account_id'] 9076 if 'envelope_id' in params: 9077 path_params['envelopeId'] = params['envelope_id'] 9078 if 'recipient_id' in params: 9079 path_params['recipientId'] = params['recipient_id'] 9080 9081 query_params = {} 9082 9083 header_params = {} 9084 9085 form_params = [] 9086 local_var_files = {} 9087 9088 body_params = None 9089 # HTTP header `Accept` 9090 header_params['Accept'] = self.api_client.\ 9091 select_header_accept(['application/json']) 9092 9093 # Authentication setting 9094 auth_settings = [] 9095 9096 return self.api_client.call_api(resource_path, 'GET', 9097 path_params, 9098 query_params, 9099 header_params, 9100 body=body_params, 9101 post_params=form_params, 9102 files=local_var_files, 9103 response_type='UserSignature', 9104 auth_settings=auth_settings, 9105 callback=params.get('callback'), 9106 _return_http_data_only=params.get('_return_http_data_only'), 9107 _preload_content=params.get('_preload_content', True), 9108 _request_timeout=params.get('_request_timeout'), 9109 collection_formats=collection_formats) 9110 9111 def get_recipient_signature_image(self, account_id, envelope_id, recipient_id, **kwargs): 9112 """ 9113 Retrieve signature image information for a signer/sign-in-person recipient. 9114 Retrieves the specified user signature image. The image is returned in the same format as uploaded. In the request you can specify if the chrome (the added line and identifier around the initial image) is returned with the image. The userId specified in the endpoint must match the authenticated user's user ID and the user must be a member of the account. The `signatureIdOrName` parameter accepts signature ID or signature name. DocuSign recommends you use signature ID (`signatureId`), since some names contain characters that don't properly URL encode. If you use the user name, it is likely that the name includes spaces and you might need to URL encode the name before using it in the endpoint. For example: \"Bob Smith\" to \"Bob%20Smith\" Older envelopes might only have chromed images. If getting the non-chromed image fails, try getting the chromed image. 9115 This method makes a synchronous HTTP request by default. To make an 9116 asynchronous HTTP request, please define a `callback` function 9117 to be invoked when receiving the response. 9118 >>> def callback_function(response): 9119 >>> pprint(response) 9120 >>> 9121 >>> thread = api.get_recipient_signature_image(account_id, envelope_id, recipient_id, callback=callback_function) 9122 9123 :param callback function: The callback function 9124 for asynchronous request. (optional) 9125 :param str account_id: The external account number (int) or account ID Guid. (required) 9126 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9127 :param str recipient_id: The ID of the recipient being accessed. (required) 9128 :param str include_chrome: When set to **true**, indicates the chromed version of the signature image should be retrieved. 9129 :return: file 9130 If the method is called asynchronously, 9131 returns the request thread. 9132 """ 9133 kwargs['_return_http_data_only'] = True 9134 if kwargs.get('callback'): 9135 return self.get_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 9136 else: 9137 (data) = self.get_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 9138 return data 9139 9140 def get_recipient_signature_image_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 9141 """ 9142 Retrieve signature image information for a signer/sign-in-person recipient. 9143 Retrieves the specified user signature image. The image is returned in the same format as uploaded. In the request you can specify if the chrome (the added line and identifier around the initial image) is returned with the image. The userId specified in the endpoint must match the authenticated user's user ID and the user must be a member of the account. The `signatureIdOrName` parameter accepts signature ID or signature name. DocuSign recommends you use signature ID (`signatureId`), since some names contain characters that don't properly URL encode. If you use the user name, it is likely that the name includes spaces and you might need to URL encode the name before using it in the endpoint. For example: \"Bob Smith\" to \"Bob%20Smith\" Older envelopes might only have chromed images. If getting the non-chromed image fails, try getting the chromed image. 9144 This method makes a synchronous HTTP request by default. To make an 9145 asynchronous HTTP request, please define a `callback` function 9146 to be invoked when receiving the response. 9147 >>> def callback_function(response): 9148 >>> pprint(response) 9149 >>> 9150 >>> thread = api.get_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 9151 9152 :param callback function: The callback function 9153 for asynchronous request. (optional) 9154 :param str account_id: The external account number (int) or account ID Guid. (required) 9155 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9156 :param str recipient_id: The ID of the recipient being accessed. (required) 9157 :param str include_chrome: When set to **true**, indicates the chromed version of the signature image should be retrieved. 9158 :return: file 9159 If the method is called asynchronously, 9160 returns the request thread. 9161 """ 9162 9163 all_params = ['account_id', 'envelope_id', 'recipient_id', 'include_chrome'] 9164 all_params.append('callback') 9165 all_params.append('_return_http_data_only') 9166 all_params.append('_preload_content') 9167 all_params.append('_request_timeout') 9168 9169 params = locals() 9170 for key, val in iteritems(params['kwargs']): 9171 if key not in all_params: 9172 raise TypeError( 9173 "Got an unexpected keyword argument '%s'" 9174 " to method get_recipient_signature_image" % key 9175 ) 9176 params[key] = val 9177 del params['kwargs'] 9178 # verify the required parameter 'account_id' is set 9179 if ('account_id' not in params) or (params['account_id'] is None): 9180 raise ValueError("Missing the required parameter `account_id` when calling `get_recipient_signature_image`") 9181 # verify the required parameter 'envelope_id' is set 9182 if ('envelope_id' not in params) or (params['envelope_id'] is None): 9183 raise ValueError("Missing the required parameter `envelope_id` when calling `get_recipient_signature_image`") 9184 # verify the required parameter 'recipient_id' is set 9185 if ('recipient_id' not in params) or (params['recipient_id'] is None): 9186 raise ValueError("Missing the required parameter `recipient_id` when calling `get_recipient_signature_image`") 9187 9188 9189 collection_formats = {} 9190 9191 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/signature_image'.replace('{format}', 'json') 9192 path_params = {} 9193 if 'account_id' in params: 9194 path_params['accountId'] = params['account_id'] 9195 if 'envelope_id' in params: 9196 path_params['envelopeId'] = params['envelope_id'] 9197 if 'recipient_id' in params: 9198 path_params['recipientId'] = params['recipient_id'] 9199 9200 query_params = {} 9201 if 'include_chrome' in params: 9202 query_params['include_chrome'] = params['include_chrome'] 9203 9204 header_params = {} 9205 9206 form_params = [] 9207 local_var_files = {} 9208 9209 body_params = None 9210 # HTTP header `Accept` 9211 header_params['Accept'] = self.api_client.\ 9212 select_header_accept(['image/gif']) 9213 9214 # Authentication setting 9215 auth_settings = [] 9216 9217 return self.api_client.call_api(resource_path, 'GET', 9218 path_params, 9219 query_params, 9220 header_params, 9221 body=body_params, 9222 post_params=form_params, 9223 files=local_var_files, 9224 response_type='file', 9225 auth_settings=auth_settings, 9226 callback=params.get('callback'), 9227 _return_http_data_only=params.get('_return_http_data_only'), 9228 _preload_content=params.get('_preload_content', True), 9229 _request_timeout=params.get('_request_timeout'), 9230 collection_formats=collection_formats) 9231 9232 def get_tabs_blob(self, account_id, envelope_id, **kwargs): 9233 """ 9234 Get encrypted tabs for envelope. 9235 9236 This method makes a synchronous HTTP request by default. To make an 9237 asynchronous HTTP request, please define a `callback` function 9238 to be invoked when receiving the response. 9239 >>> def callback_function(response): 9240 >>> pprint(response) 9241 >>> 9242 >>> thread = api.get_tabs_blob(account_id, envelope_id, callback=callback_function) 9243 9244 :param callback function: The callback function 9245 for asynchronous request. (optional) 9246 :param str account_id: The external account number (int) or account ID Guid. (required) 9247 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9248 :return: None 9249 If the method is called asynchronously, 9250 returns the request thread. 9251 """ 9252 kwargs['_return_http_data_only'] = True 9253 if kwargs.get('callback'): 9254 return self.get_tabs_blob_with_http_info(account_id, envelope_id, **kwargs) 9255 else: 9256 (data) = self.get_tabs_blob_with_http_info(account_id, envelope_id, **kwargs) 9257 return data 9258 9259 def get_tabs_blob_with_http_info(self, account_id, envelope_id, **kwargs): 9260 """ 9261 Get encrypted tabs for envelope. 9262 9263 This method makes a synchronous HTTP request by default. To make an 9264 asynchronous HTTP request, please define a `callback` function 9265 to be invoked when receiving the response. 9266 >>> def callback_function(response): 9267 >>> pprint(response) 9268 >>> 9269 >>> thread = api.get_tabs_blob_with_http_info(account_id, envelope_id, callback=callback_function) 9270 9271 :param callback function: The callback function 9272 for asynchronous request. (optional) 9273 :param str account_id: The external account number (int) or account ID Guid. (required) 9274 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9275 :return: None 9276 If the method is called asynchronously, 9277 returns the request thread. 9278 """ 9279 9280 all_params = ['account_id', 'envelope_id'] 9281 all_params.append('callback') 9282 all_params.append('_return_http_data_only') 9283 all_params.append('_preload_content') 9284 all_params.append('_request_timeout') 9285 9286 params = locals() 9287 for key, val in iteritems(params['kwargs']): 9288 if key not in all_params: 9289 raise TypeError( 9290 "Got an unexpected keyword argument '%s'" 9291 " to method get_tabs_blob" % key 9292 ) 9293 params[key] = val 9294 del params['kwargs'] 9295 # verify the required parameter 'account_id' is set 9296 if ('account_id' not in params) or (params['account_id'] is None): 9297 raise ValueError("Missing the required parameter `account_id` when calling `get_tabs_blob`") 9298 # verify the required parameter 'envelope_id' is set 9299 if ('envelope_id' not in params) or (params['envelope_id'] is None): 9300 raise ValueError("Missing the required parameter `envelope_id` when calling `get_tabs_blob`") 9301 9302 9303 collection_formats = {} 9304 9305 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/tabs_blob'.replace('{format}', 'json') 9306 path_params = {} 9307 if 'account_id' in params: 9308 path_params['accountId'] = params['account_id'] 9309 if 'envelope_id' in params: 9310 path_params['envelopeId'] = params['envelope_id'] 9311 9312 query_params = {} 9313 9314 header_params = {} 9315 9316 form_params = [] 9317 local_var_files = {} 9318 9319 body_params = None 9320 # HTTP header `Accept` 9321 header_params['Accept'] = self.api_client.\ 9322 select_header_accept(['application/json']) 9323 9324 # Authentication setting 9325 auth_settings = [] 9326 9327 return self.api_client.call_api(resource_path, 'GET', 9328 path_params, 9329 query_params, 9330 header_params, 9331 body=body_params, 9332 post_params=form_params, 9333 files=local_var_files, 9334 response_type=None, 9335 auth_settings=auth_settings, 9336 callback=params.get('callback'), 9337 _return_http_data_only=params.get('_return_http_data_only'), 9338 _preload_content=params.get('_preload_content', True), 9339 _request_timeout=params.get('_request_timeout'), 9340 collection_formats=collection_formats) 9341 9342 def get_template_delayed_routing_definition(self, account_id, template_id, workflow_step_id, **kwargs): 9343 """ 9344 Returns the delayed routing rules for a template's workflow step definition. 9345 This method makes a synchronous HTTP request by default. To make an 9346 asynchronous HTTP request, please define a `callback` function 9347 to be invoked when receiving the response. 9348 >>> def callback_function(response): 9349 >>> pprint(response) 9350 >>> 9351 >>> thread = api.get_template_delayed_routing_definition(account_id, template_id, workflow_step_id, callback=callback_function) 9352 9353 :param callback function: The callback function 9354 for asynchronous request. (optional) 9355 :param str account_id: The external account number (int) or account ID Guid. (required) 9356 :param str template_id: The ID of the template being accessed. (required) 9357 :param str workflow_step_id: (required) 9358 :return: DelayedRouting 9359 If the method is called asynchronously, 9360 returns the request thread. 9361 """ 9362 kwargs['_return_http_data_only'] = True 9363 if kwargs.get('callback'): 9364 return self.get_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 9365 else: 9366 (data) = self.get_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 9367 return data 9368 9369 def get_template_delayed_routing_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 9370 """ 9371 Returns the delayed routing rules for a template's workflow step definition. 9372 This method makes a synchronous HTTP request by default. To make an 9373 asynchronous HTTP request, please define a `callback` function 9374 to be invoked when receiving the response. 9375 >>> def callback_function(response): 9376 >>> pprint(response) 9377 >>> 9378 >>> thread = api.get_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 9379 9380 :param callback function: The callback function 9381 for asynchronous request. (optional) 9382 :param str account_id: The external account number (int) or account ID Guid. (required) 9383 :param str template_id: The ID of the template being accessed. (required) 9384 :param str workflow_step_id: (required) 9385 :return: DelayedRouting 9386 If the method is called asynchronously, 9387 returns the request thread. 9388 """ 9389 9390 all_params = ['account_id', 'template_id', 'workflow_step_id'] 9391 all_params.append('callback') 9392 all_params.append('_return_http_data_only') 9393 all_params.append('_preload_content') 9394 all_params.append('_request_timeout') 9395 9396 params = locals() 9397 for key, val in iteritems(params['kwargs']): 9398 if key not in all_params: 9399 raise TypeError( 9400 "Got an unexpected keyword argument '%s'" 9401 " to method get_template_delayed_routing_definition" % key 9402 ) 9403 params[key] = val 9404 del params['kwargs'] 9405 # verify the required parameter 'account_id' is set 9406 if ('account_id' not in params) or (params['account_id'] is None): 9407 raise ValueError("Missing the required parameter `account_id` when calling `get_template_delayed_routing_definition`") 9408 # verify the required parameter 'template_id' is set 9409 if ('template_id' not in params) or (params['template_id'] is None): 9410 raise ValueError("Missing the required parameter `template_id` when calling `get_template_delayed_routing_definition`") 9411 # verify the required parameter 'workflow_step_id' is set 9412 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 9413 raise ValueError("Missing the required parameter `workflow_step_id` when calling `get_template_delayed_routing_definition`") 9414 9415 9416 collection_formats = {} 9417 9418 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 9419 path_params = {} 9420 if 'account_id' in params: 9421 path_params['accountId'] = params['account_id'] 9422 if 'template_id' in params: 9423 path_params['templateId'] = params['template_id'] 9424 if 'workflow_step_id' in params: 9425 path_params['workflowStepId'] = params['workflow_step_id'] 9426 9427 query_params = {} 9428 9429 header_params = {} 9430 9431 form_params = [] 9432 local_var_files = {} 9433 9434 body_params = None 9435 # HTTP header `Accept` 9436 header_params['Accept'] = self.api_client.\ 9437 select_header_accept(['application/json']) 9438 9439 # Authentication setting 9440 auth_settings = [] 9441 9442 return self.api_client.call_api(resource_path, 'GET', 9443 path_params, 9444 query_params, 9445 header_params, 9446 body=body_params, 9447 post_params=form_params, 9448 files=local_var_files, 9449 response_type='DelayedRouting', 9450 auth_settings=auth_settings, 9451 callback=params.get('callback'), 9452 _return_http_data_only=params.get('_return_http_data_only'), 9453 _preload_content=params.get('_preload_content', True), 9454 _request_timeout=params.get('_request_timeout'), 9455 collection_formats=collection_formats) 9456 9457 def get_template_recipient_document_visibility(self, account_id, recipient_id, template_id, **kwargs): 9458 """ 9459 Returns document visibility for the recipients 9460 This method returns information about document visibility for a template recipient. 9461 This method makes a synchronous HTTP request by default. To make an 9462 asynchronous HTTP request, please define a `callback` function 9463 to be invoked when receiving the response. 9464 >>> def callback_function(response): 9465 >>> pprint(response) 9466 >>> 9467 >>> thread = api.get_template_recipient_document_visibility(account_id, recipient_id, template_id, callback=callback_function) 9468 9469 :param callback function: The callback function 9470 for asynchronous request. (optional) 9471 :param str account_id: The external account number (int) or account ID Guid. (required) 9472 :param str recipient_id: The ID of the recipient being accessed. (required) 9473 :param str template_id: The ID of the template being accessed. (required) 9474 :return: DocumentVisibilityList 9475 If the method is called asynchronously, 9476 returns the request thread. 9477 """ 9478 kwargs['_return_http_data_only'] = True 9479 if kwargs.get('callback'): 9480 return self.get_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, **kwargs) 9481 else: 9482 (data) = self.get_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, **kwargs) 9483 return data 9484 9485 def get_template_recipient_document_visibility_with_http_info(self, account_id, recipient_id, template_id, **kwargs): 9486 """ 9487 Returns document visibility for the recipients 9488 This method returns information about document visibility for a template recipient. 9489 This method makes a synchronous HTTP request by default. To make an 9490 asynchronous HTTP request, please define a `callback` function 9491 to be invoked when receiving the response. 9492 >>> def callback_function(response): 9493 >>> pprint(response) 9494 >>> 9495 >>> thread = api.get_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, callback=callback_function) 9496 9497 :param callback function: The callback function 9498 for asynchronous request. (optional) 9499 :param str account_id: The external account number (int) or account ID Guid. (required) 9500 :param str recipient_id: The ID of the recipient being accessed. (required) 9501 :param str template_id: The ID of the template being accessed. (required) 9502 :return: DocumentVisibilityList 9503 If the method is called asynchronously, 9504 returns the request thread. 9505 """ 9506 9507 all_params = ['account_id', 'recipient_id', 'template_id'] 9508 all_params.append('callback') 9509 all_params.append('_return_http_data_only') 9510 all_params.append('_preload_content') 9511 all_params.append('_request_timeout') 9512 9513 params = locals() 9514 for key, val in iteritems(params['kwargs']): 9515 if key not in all_params: 9516 raise TypeError( 9517 "Got an unexpected keyword argument '%s'" 9518 " to method get_template_recipient_document_visibility" % key 9519 ) 9520 params[key] = val 9521 del params['kwargs'] 9522 # verify the required parameter 'account_id' is set 9523 if ('account_id' not in params) or (params['account_id'] is None): 9524 raise ValueError("Missing the required parameter `account_id` when calling `get_template_recipient_document_visibility`") 9525 # verify the required parameter 'recipient_id' is set 9526 if ('recipient_id' not in params) or (params['recipient_id'] is None): 9527 raise ValueError("Missing the required parameter `recipient_id` when calling `get_template_recipient_document_visibility`") 9528 # verify the required parameter 'template_id' is set 9529 if ('template_id' not in params) or (params['template_id'] is None): 9530 raise ValueError("Missing the required parameter `template_id` when calling `get_template_recipient_document_visibility`") 9531 9532 9533 collection_formats = {} 9534 9535 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/recipients/{recipientId}/document_visibility'.replace('{format}', 'json') 9536 path_params = {} 9537 if 'account_id' in params: 9538 path_params['accountId'] = params['account_id'] 9539 if 'recipient_id' in params: 9540 path_params['recipientId'] = params['recipient_id'] 9541 if 'template_id' in params: 9542 path_params['templateId'] = params['template_id'] 9543 9544 query_params = {} 9545 9546 header_params = {} 9547 9548 form_params = [] 9549 local_var_files = {} 9550 9551 body_params = None 9552 # HTTP header `Accept` 9553 header_params['Accept'] = self.api_client.\ 9554 select_header_accept(['application/json']) 9555 9556 # Authentication setting 9557 auth_settings = [] 9558 9559 return self.api_client.call_api(resource_path, 'GET', 9560 path_params, 9561 query_params, 9562 header_params, 9563 body=body_params, 9564 post_params=form_params, 9565 files=local_var_files, 9566 response_type='DocumentVisibilityList', 9567 auth_settings=auth_settings, 9568 callback=params.get('callback'), 9569 _return_http_data_only=params.get('_return_http_data_only'), 9570 _preload_content=params.get('_preload_content', True), 9571 _request_timeout=params.get('_request_timeout'), 9572 collection_formats=collection_formats) 9573 9574 def get_template_scheduled_sending_definition(self, account_id, template_id, **kwargs): 9575 """ 9576 Returns the scheduled sending rules for a template's workflow definition. 9577 This method makes a synchronous HTTP request by default. To make an 9578 asynchronous HTTP request, please define a `callback` function 9579 to be invoked when receiving the response. 9580 >>> def callback_function(response): 9581 >>> pprint(response) 9582 >>> 9583 >>> thread = api.get_template_scheduled_sending_definition(account_id, template_id, callback=callback_function) 9584 9585 :param callback function: The callback function 9586 for asynchronous request. (optional) 9587 :param str account_id: The external account number (int) or account ID Guid. (required) 9588 :param str template_id: The ID of the template being accessed. (required) 9589 :return: ScheduledSending 9590 If the method is called asynchronously, 9591 returns the request thread. 9592 """ 9593 kwargs['_return_http_data_only'] = True 9594 if kwargs.get('callback'): 9595 return self.get_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 9596 else: 9597 (data) = self.get_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 9598 return data 9599 9600 def get_template_scheduled_sending_definition_with_http_info(self, account_id, template_id, **kwargs): 9601 """ 9602 Returns the scheduled sending rules for a template's workflow definition. 9603 This method makes a synchronous HTTP request by default. To make an 9604 asynchronous HTTP request, please define a `callback` function 9605 to be invoked when receiving the response. 9606 >>> def callback_function(response): 9607 >>> pprint(response) 9608 >>> 9609 >>> thread = api.get_template_scheduled_sending_definition_with_http_info(account_id, template_id, callback=callback_function) 9610 9611 :param callback function: The callback function 9612 for asynchronous request. (optional) 9613 :param str account_id: The external account number (int) or account ID Guid. (required) 9614 :param str template_id: The ID of the template being accessed. (required) 9615 :return: ScheduledSending 9616 If the method is called asynchronously, 9617 returns the request thread. 9618 """ 9619 9620 all_params = ['account_id', 'template_id'] 9621 all_params.append('callback') 9622 all_params.append('_return_http_data_only') 9623 all_params.append('_preload_content') 9624 all_params.append('_request_timeout') 9625 9626 params = locals() 9627 for key, val in iteritems(params['kwargs']): 9628 if key not in all_params: 9629 raise TypeError( 9630 "Got an unexpected keyword argument '%s'" 9631 " to method get_template_scheduled_sending_definition" % key 9632 ) 9633 params[key] = val 9634 del params['kwargs'] 9635 # verify the required parameter 'account_id' is set 9636 if ('account_id' not in params) or (params['account_id'] is None): 9637 raise ValueError("Missing the required parameter `account_id` when calling `get_template_scheduled_sending_definition`") 9638 # verify the required parameter 'template_id' is set 9639 if ('template_id' not in params) or (params['template_id'] is None): 9640 raise ValueError("Missing the required parameter `template_id` when calling `get_template_scheduled_sending_definition`") 9641 9642 9643 collection_formats = {} 9644 9645 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/scheduledSending'.replace('{format}', 'json') 9646 path_params = {} 9647 if 'account_id' in params: 9648 path_params['accountId'] = params['account_id'] 9649 if 'template_id' in params: 9650 path_params['templateId'] = params['template_id'] 9651 9652 query_params = {} 9653 9654 header_params = {} 9655 9656 form_params = [] 9657 local_var_files = {} 9658 9659 body_params = None 9660 # HTTP header `Accept` 9661 header_params['Accept'] = self.api_client.\ 9662 select_header_accept(['application/json']) 9663 9664 # Authentication setting 9665 auth_settings = [] 9666 9667 return self.api_client.call_api(resource_path, 'GET', 9668 path_params, 9669 query_params, 9670 header_params, 9671 body=body_params, 9672 post_params=form_params, 9673 files=local_var_files, 9674 response_type='ScheduledSending', 9675 auth_settings=auth_settings, 9676 callback=params.get('callback'), 9677 _return_http_data_only=params.get('_return_http_data_only'), 9678 _preload_content=params.get('_preload_content', True), 9679 _request_timeout=params.get('_request_timeout'), 9680 collection_formats=collection_formats) 9681 9682 def get_template_workflow_definition(self, account_id, template_id, **kwargs): 9683 """ 9684 Returns the workflow definition for a template. 9685 Returns template's workflow definition if the template specified by `templateId` has one. 9686 This method makes a synchronous HTTP request by default. To make an 9687 asynchronous HTTP request, please define a `callback` function 9688 to be invoked when receiving the response. 9689 >>> def callback_function(response): 9690 >>> pprint(response) 9691 >>> 9692 >>> thread = api.get_template_workflow_definition(account_id, template_id, callback=callback_function) 9693 9694 :param callback function: The callback function 9695 for asynchronous request. (optional) 9696 :param str account_id: The external account number (int) or account ID Guid. (required) 9697 :param str template_id: The ID of the template being accessed. (required) 9698 :return: Workflow 9699 If the method is called asynchronously, 9700 returns the request thread. 9701 """ 9702 kwargs['_return_http_data_only'] = True 9703 if kwargs.get('callback'): 9704 return self.get_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 9705 else: 9706 (data) = self.get_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 9707 return data 9708 9709 def get_template_workflow_definition_with_http_info(self, account_id, template_id, **kwargs): 9710 """ 9711 Returns the workflow definition for a template. 9712 Returns template's workflow definition if the template specified by `templateId` has one. 9713 This method makes a synchronous HTTP request by default. To make an 9714 asynchronous HTTP request, please define a `callback` function 9715 to be invoked when receiving the response. 9716 >>> def callback_function(response): 9717 >>> pprint(response) 9718 >>> 9719 >>> thread = api.get_template_workflow_definition_with_http_info(account_id, template_id, callback=callback_function) 9720 9721 :param callback function: The callback function 9722 for asynchronous request. (optional) 9723 :param str account_id: The external account number (int) or account ID Guid. (required) 9724 :param str template_id: The ID of the template being accessed. (required) 9725 :return: Workflow 9726 If the method is called asynchronously, 9727 returns the request thread. 9728 """ 9729 9730 all_params = ['account_id', 'template_id'] 9731 all_params.append('callback') 9732 all_params.append('_return_http_data_only') 9733 all_params.append('_preload_content') 9734 all_params.append('_request_timeout') 9735 9736 params = locals() 9737 for key, val in iteritems(params['kwargs']): 9738 if key not in all_params: 9739 raise TypeError( 9740 "Got an unexpected keyword argument '%s'" 9741 " to method get_template_workflow_definition" % key 9742 ) 9743 params[key] = val 9744 del params['kwargs'] 9745 # verify the required parameter 'account_id' is set 9746 if ('account_id' not in params) or (params['account_id'] is None): 9747 raise ValueError("Missing the required parameter `account_id` when calling `get_template_workflow_definition`") 9748 # verify the required parameter 'template_id' is set 9749 if ('template_id' not in params) or (params['template_id'] is None): 9750 raise ValueError("Missing the required parameter `template_id` when calling `get_template_workflow_definition`") 9751 9752 9753 collection_formats = {} 9754 9755 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow'.replace('{format}', 'json') 9756 path_params = {} 9757 if 'account_id' in params: 9758 path_params['accountId'] = params['account_id'] 9759 if 'template_id' in params: 9760 path_params['templateId'] = params['template_id'] 9761 9762 query_params = {} 9763 9764 header_params = {} 9765 9766 form_params = [] 9767 local_var_files = {} 9768 9769 body_params = None 9770 # HTTP header `Accept` 9771 header_params['Accept'] = self.api_client.\ 9772 select_header_accept(['application/json']) 9773 9774 # Authentication setting 9775 auth_settings = [] 9776 9777 return self.api_client.call_api(resource_path, 'GET', 9778 path_params, 9779 query_params, 9780 header_params, 9781 body=body_params, 9782 post_params=form_params, 9783 files=local_var_files, 9784 response_type='Workflow', 9785 auth_settings=auth_settings, 9786 callback=params.get('callback'), 9787 _return_http_data_only=params.get('_return_http_data_only'), 9788 _preload_content=params.get('_preload_content', True), 9789 _request_timeout=params.get('_request_timeout'), 9790 collection_formats=collection_formats) 9791 9792 def get_template_workflow_step_definition(self, account_id, template_id, workflow_step_id, **kwargs): 9793 """ 9794 Returns the workflow step definition for a template by step id. 9795 This method makes a synchronous HTTP request by default. To make an 9796 asynchronous HTTP request, please define a `callback` function 9797 to be invoked when receiving the response. 9798 >>> def callback_function(response): 9799 >>> pprint(response) 9800 >>> 9801 >>> thread = api.get_template_workflow_step_definition(account_id, template_id, workflow_step_id, callback=callback_function) 9802 9803 :param callback function: The callback function 9804 for asynchronous request. (optional) 9805 :param str account_id: The external account number (int) or account ID Guid. (required) 9806 :param str template_id: The ID of the template being accessed. (required) 9807 :param str workflow_step_id: (required) 9808 :return: WorkflowStep 9809 If the method is called asynchronously, 9810 returns the request thread. 9811 """ 9812 kwargs['_return_http_data_only'] = True 9813 if kwargs.get('callback'): 9814 return self.get_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 9815 else: 9816 (data) = self.get_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 9817 return data 9818 9819 def get_template_workflow_step_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 9820 """ 9821 Returns the workflow step definition for a template by step id. 9822 This method makes a synchronous HTTP request by default. To make an 9823 asynchronous HTTP request, please define a `callback` function 9824 to be invoked when receiving the response. 9825 >>> def callback_function(response): 9826 >>> pprint(response) 9827 >>> 9828 >>> thread = api.get_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 9829 9830 :param callback function: The callback function 9831 for asynchronous request. (optional) 9832 :param str account_id: The external account number (int) or account ID Guid. (required) 9833 :param str template_id: The ID of the template being accessed. (required) 9834 :param str workflow_step_id: (required) 9835 :return: WorkflowStep 9836 If the method is called asynchronously, 9837 returns the request thread. 9838 """ 9839 9840 all_params = ['account_id', 'template_id', 'workflow_step_id'] 9841 all_params.append('callback') 9842 all_params.append('_return_http_data_only') 9843 all_params.append('_preload_content') 9844 all_params.append('_request_timeout') 9845 9846 params = locals() 9847 for key, val in iteritems(params['kwargs']): 9848 if key not in all_params: 9849 raise TypeError( 9850 "Got an unexpected keyword argument '%s'" 9851 " to method get_template_workflow_step_definition" % key 9852 ) 9853 params[key] = val 9854 del params['kwargs'] 9855 # verify the required parameter 'account_id' is set 9856 if ('account_id' not in params) or (params['account_id'] is None): 9857 raise ValueError("Missing the required parameter `account_id` when calling `get_template_workflow_step_definition`") 9858 # verify the required parameter 'template_id' is set 9859 if ('template_id' not in params) or (params['template_id'] is None): 9860 raise ValueError("Missing the required parameter `template_id` when calling `get_template_workflow_step_definition`") 9861 # verify the required parameter 'workflow_step_id' is set 9862 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 9863 raise ValueError("Missing the required parameter `workflow_step_id` when calling `get_template_workflow_step_definition`") 9864 9865 9866 collection_formats = {} 9867 9868 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 9869 path_params = {} 9870 if 'account_id' in params: 9871 path_params['accountId'] = params['account_id'] 9872 if 'template_id' in params: 9873 path_params['templateId'] = params['template_id'] 9874 if 'workflow_step_id' in params: 9875 path_params['workflowStepId'] = params['workflow_step_id'] 9876 9877 query_params = {} 9878 9879 header_params = {} 9880 9881 form_params = [] 9882 local_var_files = {} 9883 9884 body_params = None 9885 # HTTP header `Accept` 9886 header_params['Accept'] = self.api_client.\ 9887 select_header_accept(['application/json']) 9888 9889 # Authentication setting 9890 auth_settings = [] 9891 9892 return self.api_client.call_api(resource_path, 'GET', 9893 path_params, 9894 query_params, 9895 header_params, 9896 body=body_params, 9897 post_params=form_params, 9898 files=local_var_files, 9899 response_type='WorkflowStep', 9900 auth_settings=auth_settings, 9901 callback=params.get('callback'), 9902 _return_http_data_only=params.get('_return_http_data_only'), 9903 _preload_content=params.get('_preload_content', True), 9904 _request_timeout=params.get('_request_timeout'), 9905 collection_formats=collection_formats) 9906 9907 def list_audit_events(self, account_id, envelope_id, **kwargs): 9908 """ 9909 Gets the envelope audit events for an envelope. 9910 Gets the envelope audit events for the specified envelope. 9911 This method makes a synchronous HTTP request by default. To make an 9912 asynchronous HTTP request, please define a `callback` function 9913 to be invoked when receiving the response. 9914 >>> def callback_function(response): 9915 >>> pprint(response) 9916 >>> 9917 >>> thread = api.list_audit_events(account_id, envelope_id, callback=callback_function) 9918 9919 :param callback function: The callback function 9920 for asynchronous request. (optional) 9921 :param str account_id: The external account number (int) or account ID Guid. (required) 9922 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9923 :return: EnvelopeAuditEventResponse 9924 If the method is called asynchronously, 9925 returns the request thread. 9926 """ 9927 kwargs['_return_http_data_only'] = True 9928 if kwargs.get('callback'): 9929 return self.list_audit_events_with_http_info(account_id, envelope_id, **kwargs) 9930 else: 9931 (data) = self.list_audit_events_with_http_info(account_id, envelope_id, **kwargs) 9932 return data 9933 9934 def list_audit_events_with_http_info(self, account_id, envelope_id, **kwargs): 9935 """ 9936 Gets the envelope audit events for an envelope. 9937 Gets the envelope audit events for the specified envelope. 9938 This method makes a synchronous HTTP request by default. To make an 9939 asynchronous HTTP request, please define a `callback` function 9940 to be invoked when receiving the response. 9941 >>> def callback_function(response): 9942 >>> pprint(response) 9943 >>> 9944 >>> thread = api.list_audit_events_with_http_info(account_id, envelope_id, callback=callback_function) 9945 9946 :param callback function: The callback function 9947 for asynchronous request. (optional) 9948 :param str account_id: The external account number (int) or account ID Guid. (required) 9949 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9950 :return: EnvelopeAuditEventResponse 9951 If the method is called asynchronously, 9952 returns the request thread. 9953 """ 9954 9955 all_params = ['account_id', 'envelope_id'] 9956 all_params.append('callback') 9957 all_params.append('_return_http_data_only') 9958 all_params.append('_preload_content') 9959 all_params.append('_request_timeout') 9960 9961 params = locals() 9962 for key, val in iteritems(params['kwargs']): 9963 if key not in all_params: 9964 raise TypeError( 9965 "Got an unexpected keyword argument '%s'" 9966 " to method list_audit_events" % key 9967 ) 9968 params[key] = val 9969 del params['kwargs'] 9970 # verify the required parameter 'account_id' is set 9971 if ('account_id' not in params) or (params['account_id'] is None): 9972 raise ValueError("Missing the required parameter `account_id` when calling `list_audit_events`") 9973 # verify the required parameter 'envelope_id' is set 9974 if ('envelope_id' not in params) or (params['envelope_id'] is None): 9975 raise ValueError("Missing the required parameter `envelope_id` when calling `list_audit_events`") 9976 9977 9978 collection_formats = {} 9979 9980 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/audit_events'.replace('{format}', 'json') 9981 path_params = {} 9982 if 'account_id' in params: 9983 path_params['accountId'] = params['account_id'] 9984 if 'envelope_id' in params: 9985 path_params['envelopeId'] = params['envelope_id'] 9986 9987 query_params = {} 9988 9989 header_params = {} 9990 9991 form_params = [] 9992 local_var_files = {} 9993 9994 body_params = None 9995 # HTTP header `Accept` 9996 header_params['Accept'] = self.api_client.\ 9997 select_header_accept(['application/json']) 9998 9999 # Authentication setting 10000 auth_settings = [] 10001 10002 return self.api_client.call_api(resource_path, 'GET', 10003 path_params, 10004 query_params, 10005 header_params, 10006 body=body_params, 10007 post_params=form_params, 10008 files=local_var_files, 10009 response_type='EnvelopeAuditEventResponse', 10010 auth_settings=auth_settings, 10011 callback=params.get('callback'), 10012 _return_http_data_only=params.get('_return_http_data_only'), 10013 _preload_content=params.get('_preload_content', True), 10014 _request_timeout=params.get('_request_timeout'), 10015 collection_formats=collection_formats) 10016 10017 def list_custom_fields(self, account_id, envelope_id, **kwargs): 10018 """ 10019 Gets the custom field information for the specified envelope. 10020 Retrieves the custom field information for the specified envelope. You can use these fields in the envelopes for your account to record information about the envelope, help search for envelopes, and track information. The envelope custom fields are shown in the Envelope Settings section when a user is creating an envelope in the DocuSign member console. The envelope custom fields are not seen by the envelope recipients. There are two types of envelope custom fields, text, and list. A text custom field lets the sender enter the value for the field. With a list custom field, the sender selects the value of the field from a pre-made list. 10021 This method makes a synchronous HTTP request by default. To make an 10022 asynchronous HTTP request, please define a `callback` function 10023 to be invoked when receiving the response. 10024 >>> def callback_function(response): 10025 >>> pprint(response) 10026 >>> 10027 >>> thread = api.list_custom_fields(account_id, envelope_id, callback=callback_function) 10028 10029 :param callback function: The callback function 10030 for asynchronous request. (optional) 10031 :param str account_id: The external account number (int) or account ID Guid. (required) 10032 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10033 :return: CustomFieldsEnvelope 10034 If the method is called asynchronously, 10035 returns the request thread. 10036 """ 10037 kwargs['_return_http_data_only'] = True 10038 if kwargs.get('callback'): 10039 return self.list_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 10040 else: 10041 (data) = self.list_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 10042 return data 10043 10044 def list_custom_fields_with_http_info(self, account_id, envelope_id, **kwargs): 10045 """ 10046 Gets the custom field information for the specified envelope. 10047 Retrieves the custom field information for the specified envelope. You can use these fields in the envelopes for your account to record information about the envelope, help search for envelopes, and track information. The envelope custom fields are shown in the Envelope Settings section when a user is creating an envelope in the DocuSign member console. The envelope custom fields are not seen by the envelope recipients. There are two types of envelope custom fields, text, and list. A text custom field lets the sender enter the value for the field. With a list custom field, the sender selects the value of the field from a pre-made list. 10048 This method makes a synchronous HTTP request by default. To make an 10049 asynchronous HTTP request, please define a `callback` function 10050 to be invoked when receiving the response. 10051 >>> def callback_function(response): 10052 >>> pprint(response) 10053 >>> 10054 >>> thread = api.list_custom_fields_with_http_info(account_id, envelope_id, callback=callback_function) 10055 10056 :param callback function: The callback function 10057 for asynchronous request. (optional) 10058 :param str account_id: The external account number (int) or account ID Guid. (required) 10059 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10060 :return: CustomFieldsEnvelope 10061 If the method is called asynchronously, 10062 returns the request thread. 10063 """ 10064 10065 all_params = ['account_id', 'envelope_id'] 10066 all_params.append('callback') 10067 all_params.append('_return_http_data_only') 10068 all_params.append('_preload_content') 10069 all_params.append('_request_timeout') 10070 10071 params = locals() 10072 for key, val in iteritems(params['kwargs']): 10073 if key not in all_params: 10074 raise TypeError( 10075 "Got an unexpected keyword argument '%s'" 10076 " to method list_custom_fields" % key 10077 ) 10078 params[key] = val 10079 del params['kwargs'] 10080 # verify the required parameter 'account_id' is set 10081 if ('account_id' not in params) or (params['account_id'] is None): 10082 raise ValueError("Missing the required parameter `account_id` when calling `list_custom_fields`") 10083 # verify the required parameter 'envelope_id' is set 10084 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10085 raise ValueError("Missing the required parameter `envelope_id` when calling `list_custom_fields`") 10086 10087 10088 collection_formats = {} 10089 10090 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/custom_fields'.replace('{format}', 'json') 10091 path_params = {} 10092 if 'account_id' in params: 10093 path_params['accountId'] = params['account_id'] 10094 if 'envelope_id' in params: 10095 path_params['envelopeId'] = params['envelope_id'] 10096 10097 query_params = {} 10098 10099 header_params = {} 10100 10101 form_params = [] 10102 local_var_files = {} 10103 10104 body_params = None 10105 # HTTP header `Accept` 10106 header_params['Accept'] = self.api_client.\ 10107 select_header_accept(['application/json']) 10108 10109 # Authentication setting 10110 auth_settings = [] 10111 10112 return self.api_client.call_api(resource_path, 'GET', 10113 path_params, 10114 query_params, 10115 header_params, 10116 body=body_params, 10117 post_params=form_params, 10118 files=local_var_files, 10119 response_type='CustomFieldsEnvelope', 10120 auth_settings=auth_settings, 10121 callback=params.get('callback'), 10122 _return_http_data_only=params.get('_return_http_data_only'), 10123 _preload_content=params.get('_preload_content', True), 10124 _request_timeout=params.get('_request_timeout'), 10125 collection_formats=collection_formats) 10126 10127 def list_document_fields(self, account_id, document_id, envelope_id, **kwargs): 10128 """ 10129 Gets the custom document fields from an existing envelope document. 10130 Retrieves the custom document field information from an existing envelope document. 10131 This method makes a synchronous HTTP request by default. To make an 10132 asynchronous HTTP request, please define a `callback` function 10133 to be invoked when receiving the response. 10134 >>> def callback_function(response): 10135 >>> pprint(response) 10136 >>> 10137 >>> thread = api.list_document_fields(account_id, document_id, envelope_id, callback=callback_function) 10138 10139 :param callback function: The callback function 10140 for asynchronous request. (optional) 10141 :param str account_id: The external account number (int) or account ID Guid. (required) 10142 :param str document_id: The ID of the document being accessed. (required) 10143 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10144 :return: DocumentFieldsInformation 10145 If the method is called asynchronously, 10146 returns the request thread. 10147 """ 10148 kwargs['_return_http_data_only'] = True 10149 if kwargs.get('callback'): 10150 return self.list_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 10151 else: 10152 (data) = self.list_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 10153 return data 10154 10155 def list_document_fields_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 10156 """ 10157 Gets the custom document fields from an existing envelope document. 10158 Retrieves the custom document field information from an existing envelope document. 10159 This method makes a synchronous HTTP request by default. To make an 10160 asynchronous HTTP request, please define a `callback` function 10161 to be invoked when receiving the response. 10162 >>> def callback_function(response): 10163 >>> pprint(response) 10164 >>> 10165 >>> thread = api.list_document_fields_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 10166 10167 :param callback function: The callback function 10168 for asynchronous request. (optional) 10169 :param str account_id: The external account number (int) or account ID Guid. (required) 10170 :param str document_id: The ID of the document being accessed. (required) 10171 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10172 :return: DocumentFieldsInformation 10173 If the method is called asynchronously, 10174 returns the request thread. 10175 """ 10176 10177 all_params = ['account_id', 'document_id', 'envelope_id'] 10178 all_params.append('callback') 10179 all_params.append('_return_http_data_only') 10180 all_params.append('_preload_content') 10181 all_params.append('_request_timeout') 10182 10183 params = locals() 10184 for key, val in iteritems(params['kwargs']): 10185 if key not in all_params: 10186 raise TypeError( 10187 "Got an unexpected keyword argument '%s'" 10188 " to method list_document_fields" % key 10189 ) 10190 params[key] = val 10191 del params['kwargs'] 10192 # verify the required parameter 'account_id' is set 10193 if ('account_id' not in params) or (params['account_id'] is None): 10194 raise ValueError("Missing the required parameter `account_id` when calling `list_document_fields`") 10195 # verify the required parameter 'document_id' is set 10196 if ('document_id' not in params) or (params['document_id'] is None): 10197 raise ValueError("Missing the required parameter `document_id` when calling `list_document_fields`") 10198 # verify the required parameter 'envelope_id' is set 10199 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10200 raise ValueError("Missing the required parameter `envelope_id` when calling `list_document_fields`") 10201 10202 10203 collection_formats = {} 10204 10205 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/fields'.replace('{format}', 'json') 10206 path_params = {} 10207 if 'account_id' in params: 10208 path_params['accountId'] = params['account_id'] 10209 if 'document_id' in params: 10210 path_params['documentId'] = params['document_id'] 10211 if 'envelope_id' in params: 10212 path_params['envelopeId'] = params['envelope_id'] 10213 10214 query_params = {} 10215 10216 header_params = {} 10217 10218 form_params = [] 10219 local_var_files = {} 10220 10221 body_params = None 10222 # HTTP header `Accept` 10223 header_params['Accept'] = self.api_client.\ 10224 select_header_accept(['application/json']) 10225 10226 # Authentication setting 10227 auth_settings = [] 10228 10229 return self.api_client.call_api(resource_path, 'GET', 10230 path_params, 10231 query_params, 10232 header_params, 10233 body=body_params, 10234 post_params=form_params, 10235 files=local_var_files, 10236 response_type='DocumentFieldsInformation', 10237 auth_settings=auth_settings, 10238 callback=params.get('callback'), 10239 _return_http_data_only=params.get('_return_http_data_only'), 10240 _preload_content=params.get('_preload_content', True), 10241 _request_timeout=params.get('_request_timeout'), 10242 collection_formats=collection_formats) 10243 10244 def list_documents(self, account_id, envelope_id, **kwargs): 10245 """ 10246 Gets a list of envelope documents. 10247 Retrieves a list of documents associated with the specified envelope. 10248 This method makes a synchronous HTTP request by default. To make an 10249 asynchronous HTTP request, please define a `callback` function 10250 to be invoked when receiving the response. 10251 >>> def callback_function(response): 10252 >>> pprint(response) 10253 >>> 10254 >>> thread = api.list_documents(account_id, envelope_id, callback=callback_function) 10255 10256 :param callback function: The callback function 10257 for asynchronous request. (optional) 10258 :param str account_id: The external account number (int) or account ID Guid. (required) 10259 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10260 :param str documents_by_userid: 10261 :param str include_docgen_formfields: 10262 :param str include_document_size: 10263 :param str include_metadata: 10264 :param str include_tabs: 10265 :param str recipient_id: 10266 :param str shared_user_id: 10267 :return: EnvelopeDocumentsResult 10268 If the method is called asynchronously, 10269 returns the request thread. 10270 """ 10271 kwargs['_return_http_data_only'] = True 10272 if kwargs.get('callback'): 10273 return self.list_documents_with_http_info(account_id, envelope_id, **kwargs) 10274 else: 10275 (data) = self.list_documents_with_http_info(account_id, envelope_id, **kwargs) 10276 return data 10277 10278 def list_documents_with_http_info(self, account_id, envelope_id, **kwargs): 10279 """ 10280 Gets a list of envelope documents. 10281 Retrieves a list of documents associated with the specified envelope. 10282 This method makes a synchronous HTTP request by default. To make an 10283 asynchronous HTTP request, please define a `callback` function 10284 to be invoked when receiving the response. 10285 >>> def callback_function(response): 10286 >>> pprint(response) 10287 >>> 10288 >>> thread = api.list_documents_with_http_info(account_id, envelope_id, callback=callback_function) 10289 10290 :param callback function: The callback function 10291 for asynchronous request. (optional) 10292 :param str account_id: The external account number (int) or account ID Guid. (required) 10293 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10294 :param str documents_by_userid: 10295 :param str include_docgen_formfields: 10296 :param str include_document_size: 10297 :param str include_metadata: 10298 :param str include_tabs: 10299 :param str recipient_id: 10300 :param str shared_user_id: 10301 :return: EnvelopeDocumentsResult 10302 If the method is called asynchronously, 10303 returns the request thread. 10304 """ 10305 10306 all_params = ['account_id', 'envelope_id', 'documents_by_userid', 'include_docgen_formfields', 'include_document_size', 'include_metadata', 'include_tabs', 'recipient_id', 'shared_user_id'] 10307 all_params.append('callback') 10308 all_params.append('_return_http_data_only') 10309 all_params.append('_preload_content') 10310 all_params.append('_request_timeout') 10311 10312 params = locals() 10313 for key, val in iteritems(params['kwargs']): 10314 if key not in all_params: 10315 raise TypeError( 10316 "Got an unexpected keyword argument '%s'" 10317 " to method list_documents" % key 10318 ) 10319 params[key] = val 10320 del params['kwargs'] 10321 # verify the required parameter 'account_id' is set 10322 if ('account_id' not in params) or (params['account_id'] is None): 10323 raise ValueError("Missing the required parameter `account_id` when calling `list_documents`") 10324 # verify the required parameter 'envelope_id' is set 10325 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10326 raise ValueError("Missing the required parameter `envelope_id` when calling `list_documents`") 10327 10328 10329 collection_formats = {} 10330 10331 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents'.replace('{format}', 'json') 10332 path_params = {} 10333 if 'account_id' in params: 10334 path_params['accountId'] = params['account_id'] 10335 if 'envelope_id' in params: 10336 path_params['envelopeId'] = params['envelope_id'] 10337 10338 query_params = {} 10339 if 'documents_by_userid' in params: 10340 query_params['documents_by_userid'] = params['documents_by_userid'] 10341 if 'include_docgen_formfields' in params: 10342 query_params['include_docgen_formfields'] = params['include_docgen_formfields'] 10343 if 'include_document_size' in params: 10344 query_params['include_document_size'] = params['include_document_size'] 10345 if 'include_metadata' in params: 10346 query_params['include_metadata'] = params['include_metadata'] 10347 if 'include_tabs' in params: 10348 query_params['include_tabs'] = params['include_tabs'] 10349 if 'recipient_id' in params: 10350 query_params['recipient_id'] = params['recipient_id'] 10351 if 'shared_user_id' in params: 10352 query_params['shared_user_id'] = params['shared_user_id'] 10353 10354 header_params = {} 10355 10356 form_params = [] 10357 local_var_files = {} 10358 10359 body_params = None 10360 # HTTP header `Accept` 10361 header_params['Accept'] = self.api_client.\ 10362 select_header_accept(['application/json']) 10363 10364 # Authentication setting 10365 auth_settings = [] 10366 10367 return self.api_client.call_api(resource_path, 'GET', 10368 path_params, 10369 query_params, 10370 header_params, 10371 body=body_params, 10372 post_params=form_params, 10373 files=local_var_files, 10374 response_type='EnvelopeDocumentsResult', 10375 auth_settings=auth_settings, 10376 callback=params.get('callback'), 10377 _return_http_data_only=params.get('_return_http_data_only'), 10378 _preload_content=params.get('_preload_content', True), 10379 _request_timeout=params.get('_request_timeout'), 10380 collection_formats=collection_formats) 10381 10382 def list_recipients(self, account_id, envelope_id, **kwargs): 10383 """ 10384 Gets the status of recipients for an envelope. 10385 Retrieves the status of all recipients in a single envelope and identifies the current recipient in the routing list. The `currentRoutingOrder` property of the response contains the `routingOrder` value of the current recipient indicating that the envelope has been sent to the recipient, but the recipient has not completed their actions. 10386 This method makes a synchronous HTTP request by default. To make an 10387 asynchronous HTTP request, please define a `callback` function 10388 to be invoked when receiving the response. 10389 >>> def callback_function(response): 10390 >>> pprint(response) 10391 >>> 10392 >>> thread = api.list_recipients(account_id, envelope_id, callback=callback_function) 10393 10394 :param callback function: The callback function 10395 for asynchronous request. (optional) 10396 :param str account_id: The external account number (int) or account ID Guid. (required) 10397 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10398 :param str include_anchor_tab_locations: When set to **true** and `include_tabs` is set to **true**, all tabs with anchor tab properties are included in the response. 10399 :param str include_extended: When set to **true**, the extended properties are included in the response. 10400 :param str include_metadata: 10401 :param str include_tabs: When set to **true**, the tab information associated with the recipient is included in the response. 10402 :return: Recipients 10403 If the method is called asynchronously, 10404 returns the request thread. 10405 """ 10406 kwargs['_return_http_data_only'] = True 10407 if kwargs.get('callback'): 10408 return self.list_recipients_with_http_info(account_id, envelope_id, **kwargs) 10409 else: 10410 (data) = self.list_recipients_with_http_info(account_id, envelope_id, **kwargs) 10411 return data 10412 10413 def list_recipients_with_http_info(self, account_id, envelope_id, **kwargs): 10414 """ 10415 Gets the status of recipients for an envelope. 10416 Retrieves the status of all recipients in a single envelope and identifies the current recipient in the routing list. The `currentRoutingOrder` property of the response contains the `routingOrder` value of the current recipient indicating that the envelope has been sent to the recipient, but the recipient has not completed their actions. 10417 This method makes a synchronous HTTP request by default. To make an 10418 asynchronous HTTP request, please define a `callback` function 10419 to be invoked when receiving the response. 10420 >>> def callback_function(response): 10421 >>> pprint(response) 10422 >>> 10423 >>> thread = api.list_recipients_with_http_info(account_id, envelope_id, callback=callback_function) 10424 10425 :param callback function: The callback function 10426 for asynchronous request. (optional) 10427 :param str account_id: The external account number (int) or account ID Guid. (required) 10428 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10429 :param str include_anchor_tab_locations: When set to **true** and `include_tabs` is set to **true**, all tabs with anchor tab properties are included in the response. 10430 :param str include_extended: When set to **true**, the extended properties are included in the response. 10431 :param str include_metadata: 10432 :param str include_tabs: When set to **true**, the tab information associated with the recipient is included in the response. 10433 :return: Recipients 10434 If the method is called asynchronously, 10435 returns the request thread. 10436 """ 10437 10438 all_params = ['account_id', 'envelope_id', 'include_anchor_tab_locations', 'include_extended', 'include_metadata', 'include_tabs'] 10439 all_params.append('callback') 10440 all_params.append('_return_http_data_only') 10441 all_params.append('_preload_content') 10442 all_params.append('_request_timeout') 10443 10444 params = locals() 10445 for key, val in iteritems(params['kwargs']): 10446 if key not in all_params: 10447 raise TypeError( 10448 "Got an unexpected keyword argument '%s'" 10449 " to method list_recipients" % key 10450 ) 10451 params[key] = val 10452 del params['kwargs'] 10453 # verify the required parameter 'account_id' is set 10454 if ('account_id' not in params) or (params['account_id'] is None): 10455 raise ValueError("Missing the required parameter `account_id` when calling `list_recipients`") 10456 # verify the required parameter 'envelope_id' is set 10457 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10458 raise ValueError("Missing the required parameter `envelope_id` when calling `list_recipients`") 10459 10460 10461 collection_formats = {} 10462 10463 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients'.replace('{format}', 'json') 10464 path_params = {} 10465 if 'account_id' in params: 10466 path_params['accountId'] = params['account_id'] 10467 if 'envelope_id' in params: 10468 path_params['envelopeId'] = params['envelope_id'] 10469 10470 query_params = {} 10471 if 'include_anchor_tab_locations' in params: 10472 query_params['include_anchor_tab_locations'] = params['include_anchor_tab_locations'] 10473 if 'include_extended' in params: 10474 query_params['include_extended'] = params['include_extended'] 10475 if 'include_metadata' in params: 10476 query_params['include_metadata'] = params['include_metadata'] 10477 if 'include_tabs' in params: 10478 query_params['include_tabs'] = params['include_tabs'] 10479 10480 header_params = {} 10481 10482 form_params = [] 10483 local_var_files = {} 10484 10485 body_params = None 10486 # HTTP header `Accept` 10487 header_params['Accept'] = self.api_client.\ 10488 select_header_accept(['application/json']) 10489 10490 # Authentication setting 10491 auth_settings = [] 10492 10493 return self.api_client.call_api(resource_path, 'GET', 10494 path_params, 10495 query_params, 10496 header_params, 10497 body=body_params, 10498 post_params=form_params, 10499 files=local_var_files, 10500 response_type='Recipients', 10501 auth_settings=auth_settings, 10502 callback=params.get('callback'), 10503 _return_http_data_only=params.get('_return_http_data_only'), 10504 _preload_content=params.get('_preload_content', True), 10505 _request_timeout=params.get('_request_timeout'), 10506 collection_formats=collection_formats) 10507 10508 def list_status(self, account_id, **kwargs): 10509 """ 10510 Gets the envelope status for the specified envelopes. 10511 Retrieves the envelope status for the specified envelopes. 10512 This method makes a synchronous HTTP request by default. To make an 10513 asynchronous HTTP request, please define a `callback` function 10514 to be invoked when receiving the response. 10515 >>> def callback_function(response): 10516 >>> pprint(response) 10517 >>> 10518 >>> thread = api.list_status(account_id, callback=callback_function) 10519 10520 :param callback function: The callback function 10521 for asynchronous request. (optional) 10522 :param str account_id: The external account number (int) or account ID Guid. (required) 10523 :param str ac_status: 10524 :param str block: 10525 :param str count: 10526 :param str email: 10527 :param str envelope_ids: 10528 :param str from_date: 10529 :param str from_to_status: 10530 :param str start_position: 10531 :param str status: 10532 :param str to_date: 10533 :param str transaction_ids: 10534 :param str user_name: 10535 :param EnvelopeIdsRequest envelope_ids_request: 10536 :return: EnvelopesInformation 10537 If the method is called asynchronously, 10538 returns the request thread. 10539 """ 10540 kwargs['_return_http_data_only'] = True 10541 if kwargs.get('callback'): 10542 return self.list_status_with_http_info(account_id, **kwargs) 10543 else: 10544 (data) = self.list_status_with_http_info(account_id, **kwargs) 10545 return data 10546 10547 def list_status_with_http_info(self, account_id, **kwargs): 10548 """ 10549 Gets the envelope status for the specified envelopes. 10550 Retrieves the envelope status for the specified envelopes. 10551 This method makes a synchronous HTTP request by default. To make an 10552 asynchronous HTTP request, please define a `callback` function 10553 to be invoked when receiving the response. 10554 >>> def callback_function(response): 10555 >>> pprint(response) 10556 >>> 10557 >>> thread = api.list_status_with_http_info(account_id, callback=callback_function) 10558 10559 :param callback function: The callback function 10560 for asynchronous request. (optional) 10561 :param str account_id: The external account number (int) or account ID Guid. (required) 10562 :param str ac_status: 10563 :param str block: 10564 :param str count: 10565 :param str email: 10566 :param str envelope_ids: 10567 :param str from_date: 10568 :param str from_to_status: 10569 :param str start_position: 10570 :param str status: 10571 :param str to_date: 10572 :param str transaction_ids: 10573 :param str user_name: 10574 :param EnvelopeIdsRequest envelope_ids_request: 10575 :return: EnvelopesInformation 10576 If the method is called asynchronously, 10577 returns the request thread. 10578 """ 10579 10580 all_params = ['account_id', 'ac_status', 'block', 'count', 'email', 'envelope_ids', 'from_date', 'from_to_status', 'start_position', 'status', 'to_date', 'transaction_ids', 'user_name', 'envelope_ids_request'] 10581 all_params.append('callback') 10582 all_params.append('_return_http_data_only') 10583 all_params.append('_preload_content') 10584 all_params.append('_request_timeout') 10585 10586 params = locals() 10587 for key, val in iteritems(params['kwargs']): 10588 if key not in all_params: 10589 raise TypeError( 10590 "Got an unexpected keyword argument '%s'" 10591 " to method list_status" % key 10592 ) 10593 params[key] = val 10594 del params['kwargs'] 10595 # verify the required parameter 'account_id' is set 10596 if ('account_id' not in params) or (params['account_id'] is None): 10597 raise ValueError("Missing the required parameter `account_id` when calling `list_status`") 10598 10599 10600 collection_formats = {} 10601 10602 resource_path = '/v2.1/accounts/{accountId}/envelopes/status'.replace('{format}', 'json') 10603 path_params = {} 10604 if 'account_id' in params: 10605 path_params['accountId'] = params['account_id'] 10606 10607 query_params = {} 10608 if 'ac_status' in params: 10609 query_params['ac_status'] = params['ac_status'] 10610 if 'block' in params: 10611 query_params['block'] = params['block'] 10612 if 'count' in params: 10613 query_params['count'] = params['count'] 10614 if 'email' in params: 10615 query_params['email'] = params['email'] 10616 if 'envelope_ids' in params: 10617 query_params['envelope_ids'] = params['envelope_ids'] 10618 if 'from_date' in params: 10619 query_params['from_date'] = params['from_date'] 10620 if 'from_to_status' in params: 10621 query_params['from_to_status'] = params['from_to_status'] 10622 if 'start_position' in params: 10623 query_params['start_position'] = params['start_position'] 10624 if 'status' in params: 10625 query_params['status'] = params['status'] 10626 if 'to_date' in params: 10627 query_params['to_date'] = params['to_date'] 10628 if 'transaction_ids' in params: 10629 query_params['transaction_ids'] = params['transaction_ids'] 10630 if 'user_name' in params: 10631 query_params['user_name'] = params['user_name'] 10632 10633 header_params = {} 10634 10635 form_params = [] 10636 local_var_files = {} 10637 10638 body_params = None 10639 if 'envelope_ids_request' in params: 10640 body_params = params['envelope_ids_request'] 10641 # HTTP header `Accept` 10642 header_params['Accept'] = self.api_client.\ 10643 select_header_accept(['application/json']) 10644 10645 # Authentication setting 10646 auth_settings = [] 10647 10648 return self.api_client.call_api(resource_path, 'PUT', 10649 path_params, 10650 query_params, 10651 header_params, 10652 body=body_params, 10653 post_params=form_params, 10654 files=local_var_files, 10655 response_type='EnvelopesInformation', 10656 auth_settings=auth_settings, 10657 callback=params.get('callback'), 10658 _return_http_data_only=params.get('_return_http_data_only'), 10659 _preload_content=params.get('_preload_content', True), 10660 _request_timeout=params.get('_request_timeout'), 10661 collection_formats=collection_formats) 10662 10663 def list_status_changes(self, account_id, **kwargs): 10664 """ 10665 Gets status changes for one or more envelopes. 10666 Retrieves envelope status changes for all envelopes. You can modify the information returned by adding query strings to limit the request to check between certain dates and times, or for certain envelopes, or for certain status codes. It is recommended that you use one or more of the query strings in order to limit the size of the response. ### Important: Unless you are requesting the status for specific envelopes (using the `envelopeIds` or `transactionIds` properties), you must add a set the `from_date` property in the request. Getting envelope status using `transactionIds` is useful for offline signing situations where it can be used determine if an envelope was created or not, for the cases where a network connection was lost, before the envelope status could be returned. ### Request Envelope Status Notes ### The REST API GET /envelopes call uses certain filters to find results. In some cases requests are check for \"any status change\" instead of the just the single status requested. In these cases, more envelopes might be returned by the request than otherwise would be. For example, for a request with the begin date is set to Jan 1st, an end date set to Jan 7th and the status qualifier (`from_to_status`) set to `Delivered` — the response set might contain envelopes that were created during that time period, but not delivered during the time period. To avoid unnecessary database queries, the DocuSign system checks requests to ensure that the added filters will not result in a zero-size response before acting on the request. The following table shows the valid envelope statuses (in the Valid Current Statuses column) for the status qualifiers in the request. If the status and status qualifiers in the API request do not contain any of the values shown in the valid current statuses column, then an empty list is returned. For example, a request with a status qualifier (from_to_status) of `Delivered` and a status of \"`Created`,`Sent`\", DocuSign will always return an empty list. This is because the request essentially translates to: find the envelopes that were delivered between the begin and end dates that have a current status of `Created` or `Sent`, and since an envelope that has been delivered can never have a status of `Created` or `Sent`, a zero-size response would be generated. In this case, DocuSign does not run the request, but just returns the empty list. Client applications should check that the statuses they are requesting make sense for a given status qualifier. 10667 This method makes a synchronous HTTP request by default. To make an 10668 asynchronous HTTP request, please define a `callback` function 10669 to be invoked when receiving the response. 10670 >>> def callback_function(response): 10671 >>> pprint(response) 10672 >>> 10673 >>> thread = api.list_status_changes(account_id, callback=callback_function) 10674 10675 :param callback function: The callback function 10676 for asynchronous request. (optional) 10677 :param str account_id: The external account number (int) or account ID Guid. (required) 10678 :param str ac_status: Specifies the Authoritative Copy Status for the envelopes. The possible values are: Unknown, Original, Transferred, AuthoritativeCopy, AuthoritativeCopyExportPending, AuthoritativeCopyExported, DepositPending, Deposited, DepositedEO, or DepositFailed. 10679 :param str block: 10680 :param str cdse_mode: 10681 :param str continuation_token: 10682 :param str count: 10683 :param str custom_field: This specifies the envelope custom field name and value searched for in the envelope information. The value portion of the query can use partial strings by adding '%' (percent sign) around the custom field query value. Example 1: If you have an envelope custom field called \"Region\" and you want to search for all envelopes where the value is \"West\" you would use the query: `?custom_field=Region=West`. Example 2: To search for envelopes where the `ApplicationID` custom field has the value or partial value of \"DocuSign\" in field, the query would be: `?custom_field=ApplicationId=%DocuSign%` This would find envelopes where the custom field value is \"DocuSign for Salesforce\" or \"DocuSign envelope.\" 10684 :param str email: 10685 :param str envelope_ids: 10686 :param str exclude: 10687 :param str folder_ids: 10688 :param str folder_types: 10689 :param str from_date: The date/time setting that specifies the date/time when the request begins checking for status changes for envelopes in the account. This is required unless 'envelopeId's are used. 10690 :param str from_to_status: This is the status type checked for in the `from_date`/`to_date` period. If `changed` is specified, then envelopes that changed status during the period are found. If for example, `created` is specified, then envelopes created during the period are found. Default is `changed`. Possible values are: Voided, Changed, Created, Deleted, Sent, Delivered, Signed, Completed, Declined, TimedOut and Processing. 10691 :param str include: 10692 :param str include_purge_information: 10693 :param str intersecting_folder_ids: 10694 :param str last_queried_date: 10695 :param str order: 10696 :param str order_by: 10697 :param str powerformids: 10698 :param str query_budget: 10699 :param str requester_date_format: 10700 :param str search_mode: 10701 :param str search_text: 10702 :param str start_position: 10703 :param str status: The list of current statuses to include in the response. By default, all envelopes found are returned. If values are specified, then of the envelopes found, only those with the current status specified are returned in the results. Possible values are: Voided, Created, Deleted, Sent, Delivered, Signed, Completed, Declined, TimedOut and Processing. 10704 :param str to_date: Optional date/time setting that specifies the date/time when the request stops for status changes for envelopes in the account. If no entry, the system uses the time of the call as the `to_date`. 10705 :param str transaction_ids: If included in the query string, this is a comma separated list of envelope `transactionId`s. If included in the `request_body`, this is a list of envelope `transactionId`s. ###### Note: `transactionId`s are only valid in the DocuSign system for seven days. 10706 :param str user_filter: 10707 :param str user_id: 10708 :param str user_name: 10709 :return: EnvelopesInformation 10710 If the method is called asynchronously, 10711 returns the request thread. 10712 """ 10713 kwargs['_return_http_data_only'] = True 10714 if kwargs.get('callback'): 10715 return self.list_status_changes_with_http_info(account_id, **kwargs) 10716 else: 10717 (data) = self.list_status_changes_with_http_info(account_id, **kwargs) 10718 return data 10719 10720 def list_status_changes_with_http_info(self, account_id, **kwargs): 10721 """ 10722 Gets status changes for one or more envelopes. 10723 Retrieves envelope status changes for all envelopes. You can modify the information returned by adding query strings to limit the request to check between certain dates and times, or for certain envelopes, or for certain status codes. It is recommended that you use one or more of the query strings in order to limit the size of the response. ### Important: Unless you are requesting the status for specific envelopes (using the `envelopeIds` or `transactionIds` properties), you must add a set the `from_date` property in the request. Getting envelope status using `transactionIds` is useful for offline signing situations where it can be used determine if an envelope was created or not, for the cases where a network connection was lost, before the envelope status could be returned. ### Request Envelope Status Notes ### The REST API GET /envelopes call uses certain filters to find results. In some cases requests are check for \"any status change\" instead of the just the single status requested. In these cases, more envelopes might be returned by the request than otherwise would be. For example, for a request with the begin date is set to Jan 1st, an end date set to Jan 7th and the status qualifier (`from_to_status`) set to `Delivered` — the response set might contain envelopes that were created during that time period, but not delivered during the time period. To avoid unnecessary database queries, the DocuSign system checks requests to ensure that the added filters will not result in a zero-size response before acting on the request. The following table shows the valid envelope statuses (in the Valid Current Statuses column) for the status qualifiers in the request. If the status and status qualifiers in the API request do not contain any of the values shown in the valid current statuses column, then an empty list is returned. For example, a request with a status qualifier (from_to_status) of `Delivered` and a status of \"`Created`,`Sent`\", DocuSign will always return an empty list. This is because the request essentially translates to: find the envelopes that were delivered between the begin and end dates that have a current status of `Created` or `Sent`, and since an envelope that has been delivered can never have a status of `Created` or `Sent`, a zero-size response would be generated. In this case, DocuSign does not run the request, but just returns the empty list. Client applications should check that the statuses they are requesting make sense for a given status qualifier. 10724 This method makes a synchronous HTTP request by default. To make an 10725 asynchronous HTTP request, please define a `callback` function 10726 to be invoked when receiving the response. 10727 >>> def callback_function(response): 10728 >>> pprint(response) 10729 >>> 10730 >>> thread = api.list_status_changes_with_http_info(account_id, callback=callback_function) 10731 10732 :param callback function: The callback function 10733 for asynchronous request. (optional) 10734 :param str account_id: The external account number (int) or account ID Guid. (required) 10735 :param str ac_status: Specifies the Authoritative Copy Status for the envelopes. The possible values are: Unknown, Original, Transferred, AuthoritativeCopy, AuthoritativeCopyExportPending, AuthoritativeCopyExported, DepositPending, Deposited, DepositedEO, or DepositFailed. 10736 :param str block: 10737 :param str cdse_mode: 10738 :param str continuation_token: 10739 :param str count: 10740 :param str custom_field: This specifies the envelope custom field name and value searched for in the envelope information. The value portion of the query can use partial strings by adding '%' (percent sign) around the custom field query value. Example 1: If you have an envelope custom field called \"Region\" and you want to search for all envelopes where the value is \"West\" you would use the query: `?custom_field=Region=West`. Example 2: To search for envelopes where the `ApplicationID` custom field has the value or partial value of \"DocuSign\" in field, the query would be: `?custom_field=ApplicationId=%DocuSign%` This would find envelopes where the custom field value is \"DocuSign for Salesforce\" or \"DocuSign envelope.\" 10741 :param str email: 10742 :param str envelope_ids: 10743 :param str exclude: 10744 :param str folder_ids: 10745 :param str folder_types: 10746 :param str from_date: The date/time setting that specifies the date/time when the request begins checking for status changes for envelopes in the account. This is required unless 'envelopeId's are used. 10747 :param str from_to_status: This is the status type checked for in the `from_date`/`to_date` period. If `changed` is specified, then envelopes that changed status during the period are found. If for example, `created` is specified, then envelopes created during the period are found. Default is `changed`. Possible values are: Voided, Changed, Created, Deleted, Sent, Delivered, Signed, Completed, Declined, TimedOut and Processing. 10748 :param str include: 10749 :param str include_purge_information: 10750 :param str intersecting_folder_ids: 10751 :param str last_queried_date: 10752 :param str order: 10753 :param str order_by: 10754 :param str powerformids: 10755 :param str query_budget: 10756 :param str requester_date_format: 10757 :param str search_mode: 10758 :param str search_text: 10759 :param str start_position: 10760 :param str status: The list of current statuses to include in the response. By default, all envelopes found are returned. If values are specified, then of the envelopes found, only those with the current status specified are returned in the results. Possible values are: Voided, Created, Deleted, Sent, Delivered, Signed, Completed, Declined, TimedOut and Processing. 10761 :param str to_date: Optional date/time setting that specifies the date/time when the request stops for status changes for envelopes in the account. If no entry, the system uses the time of the call as the `to_date`. 10762 :param str transaction_ids: If included in the query string, this is a comma separated list of envelope `transactionId`s. If included in the `request_body`, this is a list of envelope `transactionId`s. ###### Note: `transactionId`s are only valid in the DocuSign system for seven days. 10763 :param str user_filter: 10764 :param str user_id: 10765 :param str user_name: 10766 :return: EnvelopesInformation 10767 If the method is called asynchronously, 10768 returns the request thread. 10769 """ 10770 10771 all_params = ['account_id', 'ac_status', 'block', 'cdse_mode', 'continuation_token', 'count', 'custom_field', 'email', 'envelope_ids', 'exclude', 'folder_ids', 'folder_types', 'from_date', 'from_to_status', 'include', 'include_purge_information', 'intersecting_folder_ids', 'last_queried_date', 'order', 'order_by', 'powerformids', 'query_budget', 'requester_date_format', 'search_mode', 'search_text', 'start_position', 'status', 'to_date', 'transaction_ids', 'user_filter', 'user_id', 'user_name'] 10772 all_params.append('callback') 10773 all_params.append('_return_http_data_only') 10774 all_params.append('_preload_content') 10775 all_params.append('_request_timeout') 10776 10777 params = locals() 10778 for key, val in iteritems(params['kwargs']): 10779 if key not in all_params: 10780 raise TypeError( 10781 "Got an unexpected keyword argument '%s'" 10782 " to method list_status_changes" % key 10783 ) 10784 params[key] = val 10785 del params['kwargs'] 10786 # verify the required parameter 'account_id' is set 10787 if ('account_id' not in params) or (params['account_id'] is None): 10788 raise ValueError("Missing the required parameter `account_id` when calling `list_status_changes`") 10789 10790 10791 collection_formats = {} 10792 10793 resource_path = '/v2.1/accounts/{accountId}/envelopes'.replace('{format}', 'json') 10794 path_params = {} 10795 if 'account_id' in params: 10796 path_params['accountId'] = params['account_id'] 10797 10798 query_params = {} 10799 if 'ac_status' in params: 10800 query_params['ac_status'] = params['ac_status'] 10801 if 'block' in params: 10802 query_params['block'] = params['block'] 10803 if 'cdse_mode' in params: 10804 query_params['cdse_mode'] = params['cdse_mode'] 10805 if 'continuation_token' in params: 10806 query_params['continuation_token'] = params['continuation_token'] 10807 if 'count' in params: 10808 query_params['count'] = params['count'] 10809 if 'custom_field' in params: 10810 query_params['custom_field'] = params['custom_field'] 10811 if 'email' in params: 10812 query_params['email'] = params['email'] 10813 if 'envelope_ids' in params: 10814 query_params['envelope_ids'] = params['envelope_ids'] 10815 if 'exclude' in params: 10816 query_params['exclude'] = params['exclude'] 10817 if 'folder_ids' in params: 10818 query_params['folder_ids'] = params['folder_ids'] 10819 if 'folder_types' in params: 10820 query_params['folder_types'] = params['folder_types'] 10821 if 'from_date' in params: 10822 query_params['from_date'] = params['from_date'] 10823 if 'from_to_status' in params: 10824 query_params['from_to_status'] = params['from_to_status'] 10825 if 'include' in params: 10826 query_params['include'] = params['include'] 10827 if 'include_purge_information' in params: 10828 query_params['include_purge_information'] = params['include_purge_information'] 10829 if 'intersecting_folder_ids' in params: 10830 query_params['intersecting_folder_ids'] = params['intersecting_folder_ids'] 10831 if 'last_queried_date' in params: 10832 query_params['last_queried_date'] = params['last_queried_date'] 10833 if 'order' in params: 10834 query_params['order'] = params['order'] 10835 if 'order_by' in params: 10836 query_params['order_by'] = params['order_by'] 10837 if 'powerformids' in params: 10838 query_params['powerformids'] = params['powerformids'] 10839 if 'query_budget' in params: 10840 query_params['query_budget'] = params['query_budget'] 10841 if 'requester_date_format' in params: 10842 query_params['requester_date_format'] = params['requester_date_format'] 10843 if 'search_mode' in params: 10844 query_params['search_mode'] = params['search_mode'] 10845 if 'search_text' in params: 10846 query_params['search_text'] = params['search_text'] 10847 if 'start_position' in params: 10848 query_params['start_position'] = params['start_position'] 10849 if 'status' in params: 10850 query_params['status'] = params['status'] 10851 if 'to_date' in params: 10852 query_params['to_date'] = params['to_date'] 10853 if 'transaction_ids' in params: 10854 query_params['transaction_ids'] = params['transaction_ids'] 10855 if 'user_filter' in params: 10856 query_params['user_filter'] = params['user_filter'] 10857 if 'user_id' in params: 10858 query_params['user_id'] = params['user_id'] 10859 if 'user_name' in params: 10860 query_params['user_name'] = params['user_name'] 10861 10862 header_params = {} 10863 10864 form_params = [] 10865 local_var_files = {} 10866 10867 body_params = None 10868 # HTTP header `Accept` 10869 header_params['Accept'] = self.api_client.\ 10870 select_header_accept(['application/json']) 10871 10872 # Authentication setting 10873 auth_settings = [] 10874 10875 return self.api_client.call_api(resource_path, 'GET', 10876 path_params, 10877 query_params, 10878 header_params, 10879 body=body_params, 10880 post_params=form_params, 10881 files=local_var_files, 10882 response_type='EnvelopesInformation', 10883 auth_settings=auth_settings, 10884 callback=params.get('callback'), 10885 _return_http_data_only=params.get('_return_http_data_only'), 10886 _preload_content=params.get('_preload_content', True), 10887 _request_timeout=params.get('_request_timeout'), 10888 collection_formats=collection_formats) 10889 10890 def list_tabs(self, account_id, envelope_id, recipient_id, **kwargs): 10891 """ 10892 Gets the tabs information for a signer or sign-in-person recipient in an envelope. 10893 Retrieves information about the tabs associated with a recipient in a draft envelope. 10894 This method makes a synchronous HTTP request by default. To make an 10895 asynchronous HTTP request, please define a `callback` function 10896 to be invoked when receiving the response. 10897 >>> def callback_function(response): 10898 >>> pprint(response) 10899 >>> 10900 >>> thread = api.list_tabs(account_id, envelope_id, recipient_id, callback=callback_function) 10901 10902 :param callback function: The callback function 10903 for asynchronous request. (optional) 10904 :param str account_id: The external account number (int) or account ID Guid. (required) 10905 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10906 :param str recipient_id: The ID of the recipient being accessed. (required) 10907 :param str include_anchor_tab_locations: When set to **true**, all tabs with anchor tab properties are included in the response. 10908 :param str include_metadata: 10909 :return: Tabs 10910 If the method is called asynchronously, 10911 returns the request thread. 10912 """ 10913 kwargs['_return_http_data_only'] = True 10914 if kwargs.get('callback'): 10915 return self.list_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 10916 else: 10917 (data) = self.list_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 10918 return data 10919 10920 def list_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 10921 """ 10922 Gets the tabs information for a signer or sign-in-person recipient in an envelope. 10923 Retrieves information about the tabs associated with a recipient in a draft envelope. 10924 This method makes a synchronous HTTP request by default. To make an 10925 asynchronous HTTP request, please define a `callback` function 10926 to be invoked when receiving the response. 10927 >>> def callback_function(response): 10928 >>> pprint(response) 10929 >>> 10930 >>> thread = api.list_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 10931 10932 :param callback function: The callback function 10933 for asynchronous request. (optional) 10934 :param str account_id: The external account number (int) or account ID Guid. (required) 10935 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10936 :param str recipient_id: The ID of the recipient being accessed. (required) 10937 :param str include_anchor_tab_locations: When set to **true**, all tabs with anchor tab properties are included in the response. 10938 :param str include_metadata: 10939 :return: Tabs 10940 If the method is called asynchronously, 10941 returns the request thread. 10942 """ 10943 10944 all_params = ['account_id', 'envelope_id', 'recipient_id', 'include_anchor_tab_locations', 'include_metadata'] 10945 all_params.append('callback') 10946 all_params.append('_return_http_data_only') 10947 all_params.append('_preload_content') 10948 all_params.append('_request_timeout') 10949 10950 params = locals() 10951 for key, val in iteritems(params['kwargs']): 10952 if key not in all_params: 10953 raise TypeError( 10954 "Got an unexpected keyword argument '%s'" 10955 " to method list_tabs" % key 10956 ) 10957 params[key] = val 10958 del params['kwargs'] 10959 # verify the required parameter 'account_id' is set 10960 if ('account_id' not in params) or (params['account_id'] is None): 10961 raise ValueError("Missing the required parameter `account_id` when calling `list_tabs`") 10962 # verify the required parameter 'envelope_id' is set 10963 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10964 raise ValueError("Missing the required parameter `envelope_id` when calling `list_tabs`") 10965 # verify the required parameter 'recipient_id' is set 10966 if ('recipient_id' not in params) or (params['recipient_id'] is None): 10967 raise ValueError("Missing the required parameter `recipient_id` when calling `list_tabs`") 10968 10969 10970 collection_formats = {} 10971 10972 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/tabs'.replace('{format}', 'json') 10973 path_params = {} 10974 if 'account_id' in params: 10975 path_params['accountId'] = params['account_id'] 10976 if 'envelope_id' in params: 10977 path_params['envelopeId'] = params['envelope_id'] 10978 if 'recipient_id' in params: 10979 path_params['recipientId'] = params['recipient_id'] 10980 10981 query_params = {} 10982 if 'include_anchor_tab_locations' in params: 10983 query_params['include_anchor_tab_locations'] = params['include_anchor_tab_locations'] 10984 if 'include_metadata' in params: 10985 query_params['include_metadata'] = params['include_metadata'] 10986 10987 header_params = {} 10988 10989 form_params = [] 10990 local_var_files = {} 10991 10992 body_params = None 10993 # HTTP header `Accept` 10994 header_params['Accept'] = self.api_client.\ 10995 select_header_accept(['application/json']) 10996 10997 # Authentication setting 10998 auth_settings = [] 10999 11000 return self.api_client.call_api(resource_path, 'GET', 11001 path_params, 11002 query_params, 11003 header_params, 11004 body=body_params, 11005 post_params=form_params, 11006 files=local_var_files, 11007 response_type='Tabs', 11008 auth_settings=auth_settings, 11009 callback=params.get('callback'), 11010 _return_http_data_only=params.get('_return_http_data_only'), 11011 _preload_content=params.get('_preload_content', True), 11012 _request_timeout=params.get('_request_timeout'), 11013 collection_formats=collection_formats) 11014 11015 def list_templates(self, account_id, envelope_id, **kwargs): 11016 """ 11017 Get List of Templates used in an Envelope 11018 This returns a list of the server-side templates, their name and ID, used in an envelope. 11019 This method makes a synchronous HTTP request by default. To make an 11020 asynchronous HTTP request, please define a `callback` function 11021 to be invoked when receiving the response. 11022 >>> def callback_function(response): 11023 >>> pprint(response) 11024 >>> 11025 >>> thread = api.list_templates(account_id, envelope_id, callback=callback_function) 11026 11027 :param callback function: The callback function 11028 for asynchronous request. (optional) 11029 :param str account_id: The external account number (int) or account ID Guid. (required) 11030 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11031 :param str include: The possible values are: matching_applied - This returns template matching information for the template. 11032 :return: TemplateInformation 11033 If the method is called asynchronously, 11034 returns the request thread. 11035 """ 11036 kwargs['_return_http_data_only'] = True 11037 if kwargs.get('callback'): 11038 return self.list_templates_with_http_info(account_id, envelope_id, **kwargs) 11039 else: 11040 (data) = self.list_templates_with_http_info(account_id, envelope_id, **kwargs) 11041 return data 11042 11043 def list_templates_with_http_info(self, account_id, envelope_id, **kwargs): 11044 """ 11045 Get List of Templates used in an Envelope 11046 This returns a list of the server-side templates, their name and ID, used in an envelope. 11047 This method makes a synchronous HTTP request by default. To make an 11048 asynchronous HTTP request, please define a `callback` function 11049 to be invoked when receiving the response. 11050 >>> def callback_function(response): 11051 >>> pprint(response) 11052 >>> 11053 >>> thread = api.list_templates_with_http_info(account_id, envelope_id, callback=callback_function) 11054 11055 :param callback function: The callback function 11056 for asynchronous request. (optional) 11057 :param str account_id: The external account number (int) or account ID Guid. (required) 11058 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11059 :param str include: The possible values are: matching_applied - This returns template matching information for the template. 11060 :return: TemplateInformation 11061 If the method is called asynchronously, 11062 returns the request thread. 11063 """ 11064 11065 all_params = ['account_id', 'envelope_id', 'include'] 11066 all_params.append('callback') 11067 all_params.append('_return_http_data_only') 11068 all_params.append('_preload_content') 11069 all_params.append('_request_timeout') 11070 11071 params = locals() 11072 for key, val in iteritems(params['kwargs']): 11073 if key not in all_params: 11074 raise TypeError( 11075 "Got an unexpected keyword argument '%s'" 11076 " to method list_templates" % key 11077 ) 11078 params[key] = val 11079 del params['kwargs'] 11080 # verify the required parameter 'account_id' is set 11081 if ('account_id' not in params) or (params['account_id'] is None): 11082 raise ValueError("Missing the required parameter `account_id` when calling `list_templates`") 11083 # verify the required parameter 'envelope_id' is set 11084 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11085 raise ValueError("Missing the required parameter `envelope_id` when calling `list_templates`") 11086 11087 11088 collection_formats = {} 11089 11090 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/templates'.replace('{format}', 'json') 11091 path_params = {} 11092 if 'account_id' in params: 11093 path_params['accountId'] = params['account_id'] 11094 if 'envelope_id' in params: 11095 path_params['envelopeId'] = params['envelope_id'] 11096 11097 query_params = {} 11098 if 'include' in params: 11099 query_params['include'] = params['include'] 11100 11101 header_params = {} 11102 11103 form_params = [] 11104 local_var_files = {} 11105 11106 body_params = None 11107 # HTTP header `Accept` 11108 header_params['Accept'] = self.api_client.\ 11109 select_header_accept(['application/json']) 11110 11111 # Authentication setting 11112 auth_settings = [] 11113 11114 return self.api_client.call_api(resource_path, 'GET', 11115 path_params, 11116 query_params, 11117 header_params, 11118 body=body_params, 11119 post_params=form_params, 11120 files=local_var_files, 11121 response_type='TemplateInformation', 11122 auth_settings=auth_settings, 11123 callback=params.get('callback'), 11124 _return_http_data_only=params.get('_return_http_data_only'), 11125 _preload_content=params.get('_preload_content', True), 11126 _request_timeout=params.get('_request_timeout'), 11127 collection_formats=collection_formats) 11128 11129 def list_templates_for_document(self, account_id, document_id, envelope_id, **kwargs): 11130 """ 11131 Gets the templates associated with a document in an existing envelope. 11132 Retrieves the templates associated with a document in the specified envelope. 11133 This method makes a synchronous HTTP request by default. To make an 11134 asynchronous HTTP request, please define a `callback` function 11135 to be invoked when receiving the response. 11136 >>> def callback_function(response): 11137 >>> pprint(response) 11138 >>> 11139 >>> thread = api.list_templates_for_document(account_id, document_id, envelope_id, callback=callback_function) 11140 11141 :param callback function: The callback function 11142 for asynchronous request. (optional) 11143 :param str account_id: The external account number (int) or account ID Guid. (required) 11144 :param str document_id: The ID of the document being accessed. (required) 11145 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11146 :param str include: 11147 :return: TemplateInformation 11148 If the method is called asynchronously, 11149 returns the request thread. 11150 """ 11151 kwargs['_return_http_data_only'] = True 11152 if kwargs.get('callback'): 11153 return self.list_templates_for_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 11154 else: 11155 (data) = self.list_templates_for_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 11156 return data 11157 11158 def list_templates_for_document_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 11159 """ 11160 Gets the templates associated with a document in an existing envelope. 11161 Retrieves the templates associated with a document in the specified envelope. 11162 This method makes a synchronous HTTP request by default. To make an 11163 asynchronous HTTP request, please define a `callback` function 11164 to be invoked when receiving the response. 11165 >>> def callback_function(response): 11166 >>> pprint(response) 11167 >>> 11168 >>> thread = api.list_templates_for_document_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 11169 11170 :param callback function: The callback function 11171 for asynchronous request. (optional) 11172 :param str account_id: The external account number (int) or account ID Guid. (required) 11173 :param str document_id: The ID of the document being accessed. (required) 11174 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11175 :param str include: 11176 :return: TemplateInformation 11177 If the method is called asynchronously, 11178 returns the request thread. 11179 """ 11180 11181 all_params = ['account_id', 'document_id', 'envelope_id', 'include'] 11182 all_params.append('callback') 11183 all_params.append('_return_http_data_only') 11184 all_params.append('_preload_content') 11185 all_params.append('_request_timeout') 11186 11187 params = locals() 11188 for key, val in iteritems(params['kwargs']): 11189 if key not in all_params: 11190 raise TypeError( 11191 "Got an unexpected keyword argument '%s'" 11192 " to method list_templates_for_document" % key 11193 ) 11194 params[key] = val 11195 del params['kwargs'] 11196 # verify the required parameter 'account_id' is set 11197 if ('account_id' not in params) or (params['account_id'] is None): 11198 raise ValueError("Missing the required parameter `account_id` when calling `list_templates_for_document`") 11199 # verify the required parameter 'document_id' is set 11200 if ('document_id' not in params) or (params['document_id'] is None): 11201 raise ValueError("Missing the required parameter `document_id` when calling `list_templates_for_document`") 11202 # verify the required parameter 'envelope_id' is set 11203 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11204 raise ValueError("Missing the required parameter `envelope_id` when calling `list_templates_for_document`") 11205 11206 11207 collection_formats = {} 11208 11209 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/templates'.replace('{format}', 'json') 11210 path_params = {} 11211 if 'account_id' in params: 11212 path_params['accountId'] = params['account_id'] 11213 if 'document_id' in params: 11214 path_params['documentId'] = params['document_id'] 11215 if 'envelope_id' in params: 11216 path_params['envelopeId'] = params['envelope_id'] 11217 11218 query_params = {} 11219 if 'include' in params: 11220 query_params['include'] = params['include'] 11221 11222 header_params = {} 11223 11224 form_params = [] 11225 local_var_files = {} 11226 11227 body_params = None 11228 # HTTP header `Accept` 11229 header_params['Accept'] = self.api_client.\ 11230 select_header_accept(['application/json']) 11231 11232 # Authentication setting 11233 auth_settings = [] 11234 11235 return self.api_client.call_api(resource_path, 'GET', 11236 path_params, 11237 query_params, 11238 header_params, 11239 body=body_params, 11240 post_params=form_params, 11241 files=local_var_files, 11242 response_type='TemplateInformation', 11243 auth_settings=auth_settings, 11244 callback=params.get('callback'), 11245 _return_http_data_only=params.get('_return_http_data_only'), 11246 _preload_content=params.get('_preload_content', True), 11247 _request_timeout=params.get('_request_timeout'), 11248 collection_formats=collection_formats) 11249 11250 def put_attachment(self, account_id, attachment_id, envelope_id, **kwargs): 11251 """ 11252 Add an attachment to a DRAFT or IN-PROCESS envelope. 11253 Adds an attachment to a draft or in-process envelope. 11254 This method makes a synchronous HTTP request by default. To make an 11255 asynchronous HTTP request, please define a `callback` function 11256 to be invoked when receiving the response. 11257 >>> def callback_function(response): 11258 >>> pprint(response) 11259 >>> 11260 >>> thread = api.put_attachment(account_id, attachment_id, envelope_id, callback=callback_function) 11261 11262 :param callback function: The callback function 11263 for asynchronous request. (optional) 11264 :param str account_id: The external account number (int) or account ID Guid. (required) 11265 :param str attachment_id: (required) 11266 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11267 :param Attachment attachment: 11268 :return: EnvelopeAttachmentsResult 11269 If the method is called asynchronously, 11270 returns the request thread. 11271 """ 11272 kwargs['_return_http_data_only'] = True 11273 if kwargs.get('callback'): 11274 return self.put_attachment_with_http_info(account_id, attachment_id, envelope_id, **kwargs) 11275 else: 11276 (data) = self.put_attachment_with_http_info(account_id, attachment_id, envelope_id, **kwargs) 11277 return data 11278 11279 def put_attachment_with_http_info(self, account_id, attachment_id, envelope_id, **kwargs): 11280 """ 11281 Add an attachment to a DRAFT or IN-PROCESS envelope. 11282 Adds an attachment to a draft or in-process envelope. 11283 This method makes a synchronous HTTP request by default. To make an 11284 asynchronous HTTP request, please define a `callback` function 11285 to be invoked when receiving the response. 11286 >>> def callback_function(response): 11287 >>> pprint(response) 11288 >>> 11289 >>> thread = api.put_attachment_with_http_info(account_id, attachment_id, envelope_id, callback=callback_function) 11290 11291 :param callback function: The callback function 11292 for asynchronous request. (optional) 11293 :param str account_id: The external account number (int) or account ID Guid. (required) 11294 :param str attachment_id: (required) 11295 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11296 :param Attachment attachment: 11297 :return: EnvelopeAttachmentsResult 11298 If the method is called asynchronously, 11299 returns the request thread. 11300 """ 11301 11302 all_params = ['account_id', 'attachment_id', 'envelope_id', 'attachment'] 11303 all_params.append('callback') 11304 all_params.append('_return_http_data_only') 11305 all_params.append('_preload_content') 11306 all_params.append('_request_timeout') 11307 11308 params = locals() 11309 for key, val in iteritems(params['kwargs']): 11310 if key not in all_params: 11311 raise TypeError( 11312 "Got an unexpected keyword argument '%s'" 11313 " to method put_attachment" % key 11314 ) 11315 params[key] = val 11316 del params['kwargs'] 11317 # verify the required parameter 'account_id' is set 11318 if ('account_id' not in params) or (params['account_id'] is None): 11319 raise ValueError("Missing the required parameter `account_id` when calling `put_attachment`") 11320 # verify the required parameter 'attachment_id' is set 11321 if ('attachment_id' not in params) or (params['attachment_id'] is None): 11322 raise ValueError("Missing the required parameter `attachment_id` when calling `put_attachment`") 11323 # verify the required parameter 'envelope_id' is set 11324 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11325 raise ValueError("Missing the required parameter `envelope_id` when calling `put_attachment`") 11326 11327 11328 collection_formats = {} 11329 11330 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments/{attachmentId}'.replace('{format}', 'json') 11331 path_params = {} 11332 if 'account_id' in params: 11333 path_params['accountId'] = params['account_id'] 11334 if 'attachment_id' in params: 11335 path_params['attachmentId'] = params['attachment_id'] 11336 if 'envelope_id' in params: 11337 path_params['envelopeId'] = params['envelope_id'] 11338 11339 query_params = {} 11340 11341 header_params = {} 11342 11343 form_params = [] 11344 local_var_files = {} 11345 11346 body_params = None 11347 if 'attachment' in params: 11348 body_params = params['attachment'] 11349 # HTTP header `Accept` 11350 header_params['Accept'] = self.api_client.\ 11351 select_header_accept(['application/json']) 11352 11353 # Authentication setting 11354 auth_settings = [] 11355 11356 return self.api_client.call_api(resource_path, 'PUT', 11357 path_params, 11358 query_params, 11359 header_params, 11360 body=body_params, 11361 post_params=form_params, 11362 files=local_var_files, 11363 response_type='EnvelopeAttachmentsResult', 11364 auth_settings=auth_settings, 11365 callback=params.get('callback'), 11366 _return_http_data_only=params.get('_return_http_data_only'), 11367 _preload_content=params.get('_preload_content', True), 11368 _request_timeout=params.get('_request_timeout'), 11369 collection_formats=collection_formats) 11370 11371 def put_attachments(self, account_id, envelope_id, **kwargs): 11372 """ 11373 Add one or more attachments to a DRAFT or IN-PROCESS envelope. 11374 Adds one or more attachments to a draft or in-process envelope. Envelope attachments are files that an application can include in an envelope. They are not converted to PDF. Envelope attachments are available only through the API. There is no user interface in the DocuSign web application for them. For a list of supported file formats, see [Supported File Formats](https://support.docusign.com/guides/ndse-user-guide-supported-file-formats). 11375 This method makes a synchronous HTTP request by default. To make an 11376 asynchronous HTTP request, please define a `callback` function 11377 to be invoked when receiving the response. 11378 >>> def callback_function(response): 11379 >>> pprint(response) 11380 >>> 11381 >>> thread = api.put_attachments(account_id, envelope_id, callback=callback_function) 11382 11383 :param callback function: The callback function 11384 for asynchronous request. (optional) 11385 :param str account_id: The external account number (int) or account ID Guid. (required) 11386 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11387 :param EnvelopeAttachmentsRequest envelope_attachments_request: 11388 :return: EnvelopeAttachmentsResult 11389 If the method is called asynchronously, 11390 returns the request thread. 11391 """ 11392 kwargs['_return_http_data_only'] = True 11393 if kwargs.get('callback'): 11394 return self.put_attachments_with_http_info(account_id, envelope_id, **kwargs) 11395 else: 11396 (data) = self.put_attachments_with_http_info(account_id, envelope_id, **kwargs) 11397 return data 11398 11399 def put_attachments_with_http_info(self, account_id, envelope_id, **kwargs): 11400 """ 11401 Add one or more attachments to a DRAFT or IN-PROCESS envelope. 11402 Adds one or more attachments to a draft or in-process envelope. Envelope attachments are files that an application can include in an envelope. They are not converted to PDF. Envelope attachments are available only through the API. There is no user interface in the DocuSign web application for them. For a list of supported file formats, see [Supported File Formats](https://support.docusign.com/guides/ndse-user-guide-supported-file-formats). 11403 This method makes a synchronous HTTP request by default. To make an 11404 asynchronous HTTP request, please define a `callback` function 11405 to be invoked when receiving the response. 11406 >>> def callback_function(response): 11407 >>> pprint(response) 11408 >>> 11409 >>> thread = api.put_attachments_with_http_info(account_id, envelope_id, callback=callback_function) 11410 11411 :param callback function: The callback function 11412 for asynchronous request. (optional) 11413 :param str account_id: The external account number (int) or account ID Guid. (required) 11414 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11415 :param EnvelopeAttachmentsRequest envelope_attachments_request: 11416 :return: EnvelopeAttachmentsResult 11417 If the method is called asynchronously, 11418 returns the request thread. 11419 """ 11420 11421 all_params = ['account_id', 'envelope_id', 'envelope_attachments_request'] 11422 all_params.append('callback') 11423 all_params.append('_return_http_data_only') 11424 all_params.append('_preload_content') 11425 all_params.append('_request_timeout') 11426 11427 params = locals() 11428 for key, val in iteritems(params['kwargs']): 11429 if key not in all_params: 11430 raise TypeError( 11431 "Got an unexpected keyword argument '%s'" 11432 " to method put_attachments" % key 11433 ) 11434 params[key] = val 11435 del params['kwargs'] 11436 # verify the required parameter 'account_id' is set 11437 if ('account_id' not in params) or (params['account_id'] is None): 11438 raise ValueError("Missing the required parameter `account_id` when calling `put_attachments`") 11439 # verify the required parameter 'envelope_id' is set 11440 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11441 raise ValueError("Missing the required parameter `envelope_id` when calling `put_attachments`") 11442 11443 11444 collection_formats = {} 11445 11446 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments'.replace('{format}', 'json') 11447 path_params = {} 11448 if 'account_id' in params: 11449 path_params['accountId'] = params['account_id'] 11450 if 'envelope_id' in params: 11451 path_params['envelopeId'] = params['envelope_id'] 11452 11453 query_params = {} 11454 11455 header_params = {} 11456 11457 form_params = [] 11458 local_var_files = {} 11459 11460 body_params = None 11461 if 'envelope_attachments_request' in params: 11462 body_params = params['envelope_attachments_request'] 11463 # HTTP header `Accept` 11464 header_params['Accept'] = self.api_client.\ 11465 select_header_accept(['application/json']) 11466 11467 # Authentication setting 11468 auth_settings = [] 11469 11470 return self.api_client.call_api(resource_path, 'PUT', 11471 path_params, 11472 query_params, 11473 header_params, 11474 body=body_params, 11475 post_params=form_params, 11476 files=local_var_files, 11477 response_type='EnvelopeAttachmentsResult', 11478 auth_settings=auth_settings, 11479 callback=params.get('callback'), 11480 _return_http_data_only=params.get('_return_http_data_only'), 11481 _preload_content=params.get('_preload_content', True), 11482 _request_timeout=params.get('_request_timeout'), 11483 collection_formats=collection_formats) 11484 11485 def rotate_document_page(self, account_id, document_id, envelope_id, page_number, **kwargs): 11486 """ 11487 Rotates page image from an envelope for display. 11488 Rotates page image from an envelope for display. The page image can be rotated to the left or right. 11489 This method makes a synchronous HTTP request by default. To make an 11490 asynchronous HTTP request, please define a `callback` function 11491 to be invoked when receiving the response. 11492 >>> def callback_function(response): 11493 >>> pprint(response) 11494 >>> 11495 >>> thread = api.rotate_document_page(account_id, document_id, envelope_id, page_number, callback=callback_function) 11496 11497 :param callback function: The callback function 11498 for asynchronous request. (optional) 11499 :param str account_id: The external account number (int) or account ID Guid. (required) 11500 :param str document_id: The ID of the document being accessed. (required) 11501 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11502 :param str page_number: The page number being accessed. (required) 11503 :param PageRequest page_request: 11504 :return: None 11505 If the method is called asynchronously, 11506 returns the request thread. 11507 """ 11508 kwargs['_return_http_data_only'] = True 11509 if kwargs.get('callback'): 11510 return self.rotate_document_page_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 11511 else: 11512 (data) = self.rotate_document_page_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 11513 return data 11514 11515 def rotate_document_page_with_http_info(self, account_id, document_id, envelope_id, page_number, **kwargs): 11516 """ 11517 Rotates page image from an envelope for display. 11518 Rotates page image from an envelope for display. The page image can be rotated to the left or right. 11519 This method makes a synchronous HTTP request by default. To make an 11520 asynchronous HTTP request, please define a `callback` function 11521 to be invoked when receiving the response. 11522 >>> def callback_function(response): 11523 >>> pprint(response) 11524 >>> 11525 >>> thread = api.rotate_document_page_with_http_info(account_id, document_id, envelope_id, page_number, callback=callback_function) 11526 11527 :param callback function: The callback function 11528 for asynchronous request. (optional) 11529 :param str account_id: The external account number (int) or account ID Guid. (required) 11530 :param str document_id: The ID of the document being accessed. (required) 11531 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11532 :param str page_number: The page number being accessed. (required) 11533 :param PageRequest page_request: 11534 :return: None 11535 If the method is called asynchronously, 11536 returns the request thread. 11537 """ 11538 11539 all_params = ['account_id', 'document_id', 'envelope_id', 'page_number', 'page_request'] 11540 all_params.append('callback') 11541 all_params.append('_return_http_data_only') 11542 all_params.append('_preload_content') 11543 all_params.append('_request_timeout') 11544 11545 params = locals() 11546 for key, val in iteritems(params['kwargs']): 11547 if key not in all_params: 11548 raise TypeError( 11549 "Got an unexpected keyword argument '%s'" 11550 " to method rotate_document_page" % key 11551 ) 11552 params[key] = val 11553 del params['kwargs'] 11554 # verify the required parameter 'account_id' is set 11555 if ('account_id' not in params) or (params['account_id'] is None): 11556 raise ValueError("Missing the required parameter `account_id` when calling `rotate_document_page`") 11557 # verify the required parameter 'document_id' is set 11558 if ('document_id' not in params) or (params['document_id'] is None): 11559 raise ValueError("Missing the required parameter `document_id` when calling `rotate_document_page`") 11560 # verify the required parameter 'envelope_id' is set 11561 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11562 raise ValueError("Missing the required parameter `envelope_id` when calling `rotate_document_page`") 11563 # verify the required parameter 'page_number' is set 11564 if ('page_number' not in params) or (params['page_number'] is None): 11565 raise ValueError("Missing the required parameter `page_number` when calling `rotate_document_page`") 11566 11567 11568 collection_formats = {} 11569 11570 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/pages/{pageNumber}/page_image'.replace('{format}', 'json') 11571 path_params = {} 11572 if 'account_id' in params: 11573 path_params['accountId'] = params['account_id'] 11574 if 'document_id' in params: 11575 path_params['documentId'] = params['document_id'] 11576 if 'envelope_id' in params: 11577 path_params['envelopeId'] = params['envelope_id'] 11578 if 'page_number' in params: 11579 path_params['pageNumber'] = params['page_number'] 11580 11581 query_params = {} 11582 11583 header_params = {} 11584 11585 form_params = [] 11586 local_var_files = {} 11587 11588 body_params = None 11589 if 'page_request' in params: 11590 body_params = params['page_request'] 11591 # HTTP header `Accept` 11592 header_params['Accept'] = self.api_client.\ 11593 select_header_accept(['application/json']) 11594 11595 # Authentication setting 11596 auth_settings = [] 11597 11598 return self.api_client.call_api(resource_path, 'PUT', 11599 path_params, 11600 query_params, 11601 header_params, 11602 body=body_params, 11603 post_params=form_params, 11604 files=local_var_files, 11605 response_type=None, 11606 auth_settings=auth_settings, 11607 callback=params.get('callback'), 11608 _return_http_data_only=params.get('_return_http_data_only'), 11609 _preload_content=params.get('_preload_content', True), 11610 _request_timeout=params.get('_request_timeout'), 11611 collection_formats=collection_formats) 11612 11613 def update(self, account_id, envelope_id, **kwargs): 11614 """ 11615 Send Draft Envelope/Void Envelope/Move/Purge Envelope/Modify draft 11616 The Put Envelopes endpoint provides the following functionality: * Sends the specified single draft envelope. Add {\"status\":\"sent\"} to the request body to send the envelope. * Voids the specified in-process envelope. Add {\"status\":\"voided\", \"voidedReason\":\"The reason for voiding the envelope\"} to the request body to void the envelope. * Replaces the current email subject and message for a draft envelope. Add {\"emailSubject\":\"subject\", \"emailBlurb\":\"message\"} to the request body to modify the subject and message. * Place the envelope documents and envelope metadata in a purge queue so that this information is removed from the DocuSign system. Add {\"purgeState\":\"purge type\"} to the request body. *Additional information on purging documents* The purge request can only be used for completed envelopes that are not marked as the authoritative copy. The requesting user must have permission to purge documents and must be the sender (the requesting user can act as the sender using Send On Behalf Of). ###### Note: If you have set the Document Retention policy on your account, envelope documents are automatically placed in the purge queue and the warning emails are sent at the end of the retention period. ###### Note: You can set the Document Retention policy in the Classic DocuSign Experience by specifying the number of days to retain documents. ###### Note: Setting a Document Retention policy is the same as setting a schedule for purging documents. When the purge request is initiated the envelope documents, or documents and envelope metadata, are placed in a purge queue for deletion in 14 days. A warning email notification is sent to the sender and recipients associated with the envelope, notifying them that the envelope documents will be deleted in 14 days and providing a link to the documents. A second email is sent 7 days later with the same message. At the end of the 14-day period, the envelope documents are deleted from the system. If `purgeState=\"documents_queued\"` is used in the request, then only the documents are deleted and any corresponding attachments and tabs remain in the DocuSign system. If `purgeState= \"documents_and_metadata_queued\"` is used in the request, then the documents, attachments, and tabs are deleted. 11617 This method makes a synchronous HTTP request by default. To make an 11618 asynchronous HTTP request, please define a `callback` function 11619 to be invoked when receiving the response. 11620 >>> def callback_function(response): 11621 >>> pprint(response) 11622 >>> 11623 >>> thread = api.update(account_id, envelope_id, callback=callback_function) 11624 11625 :param callback function: The callback function 11626 for asynchronous request. (optional) 11627 :param str account_id: The external account number (int) or account ID Guid. (required) 11628 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11629 :param str advanced_update: When set to **true**, allows the caller to update recipients, tabs, custom fields, notification, email settings and other envelope attributes. 11630 :param str recycle_on_void: 11631 :param str resend_envelope: When set to **true**, sends the specified envelope again. 11632 :param Envelope envelope: 11633 :return: EnvelopeUpdateSummary 11634 If the method is called asynchronously, 11635 returns the request thread. 11636 """ 11637 kwargs['_return_http_data_only'] = True 11638 if kwargs.get('callback'): 11639 return self.update_with_http_info(account_id, envelope_id, **kwargs) 11640 else: 11641 (data) = self.update_with_http_info(account_id, envelope_id, **kwargs) 11642 return data 11643 11644 def update_with_http_info(self, account_id, envelope_id, **kwargs): 11645 """ 11646 Send Draft Envelope/Void Envelope/Move/Purge Envelope/Modify draft 11647 The Put Envelopes endpoint provides the following functionality: * Sends the specified single draft envelope. Add {\"status\":\"sent\"} to the request body to send the envelope. * Voids the specified in-process envelope. Add {\"status\":\"voided\", \"voidedReason\":\"The reason for voiding the envelope\"} to the request body to void the envelope. * Replaces the current email subject and message for a draft envelope. Add {\"emailSubject\":\"subject\", \"emailBlurb\":\"message\"} to the request body to modify the subject and message. * Place the envelope documents and envelope metadata in a purge queue so that this information is removed from the DocuSign system. Add {\"purgeState\":\"purge type\"} to the request body. *Additional information on purging documents* The purge request can only be used for completed envelopes that are not marked as the authoritative copy. The requesting user must have permission to purge documents and must be the sender (the requesting user can act as the sender using Send On Behalf Of). ###### Note: If you have set the Document Retention policy on your account, envelope documents are automatically placed in the purge queue and the warning emails are sent at the end of the retention period. ###### Note: You can set the Document Retention policy in the Classic DocuSign Experience by specifying the number of days to retain documents. ###### Note: Setting a Document Retention policy is the same as setting a schedule for purging documents. When the purge request is initiated the envelope documents, or documents and envelope metadata, are placed in a purge queue for deletion in 14 days. A warning email notification is sent to the sender and recipients associated with the envelope, notifying them that the envelope documents will be deleted in 14 days and providing a link to the documents. A second email is sent 7 days later with the same message. At the end of the 14-day period, the envelope documents are deleted from the system. If `purgeState=\"documents_queued\"` is used in the request, then only the documents are deleted and any corresponding attachments and tabs remain in the DocuSign system. If `purgeState= \"documents_and_metadata_queued\"` is used in the request, then the documents, attachments, and tabs are deleted. 11648 This method makes a synchronous HTTP request by default. To make an 11649 asynchronous HTTP request, please define a `callback` function 11650 to be invoked when receiving the response. 11651 >>> def callback_function(response): 11652 >>> pprint(response) 11653 >>> 11654 >>> thread = api.update_with_http_info(account_id, envelope_id, callback=callback_function) 11655 11656 :param callback function: The callback function 11657 for asynchronous request. (optional) 11658 :param str account_id: The external account number (int) or account ID Guid. (required) 11659 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11660 :param str advanced_update: When set to **true**, allows the caller to update recipients, tabs, custom fields, notification, email settings and other envelope attributes. 11661 :param str recycle_on_void: 11662 :param str resend_envelope: When set to **true**, sends the specified envelope again. 11663 :param Envelope envelope: 11664 :return: EnvelopeUpdateSummary 11665 If the method is called asynchronously, 11666 returns the request thread. 11667 """ 11668 11669 all_params = ['account_id', 'envelope_id', 'advanced_update', 'recycle_on_void', 'resend_envelope', 'envelope'] 11670 all_params.append('callback') 11671 all_params.append('_return_http_data_only') 11672 all_params.append('_preload_content') 11673 all_params.append('_request_timeout') 11674 11675 params = locals() 11676 for key, val in iteritems(params['kwargs']): 11677 if key not in all_params: 11678 raise TypeError( 11679 "Got an unexpected keyword argument '%s'" 11680 " to method update" % key 11681 ) 11682 params[key] = val 11683 del params['kwargs'] 11684 # verify the required parameter 'account_id' is set 11685 if ('account_id' not in params) or (params['account_id'] is None): 11686 raise ValueError("Missing the required parameter `account_id` when calling `update`") 11687 # verify the required parameter 'envelope_id' is set 11688 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11689 raise ValueError("Missing the required parameter `envelope_id` when calling `update`") 11690 11691 11692 collection_formats = {} 11693 11694 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}'.replace('{format}', 'json') 11695 path_params = {} 11696 if 'account_id' in params: 11697 path_params['accountId'] = params['account_id'] 11698 if 'envelope_id' in params: 11699 path_params['envelopeId'] = params['envelope_id'] 11700 11701 query_params = {} 11702 if 'advanced_update' in params: 11703 query_params['advanced_update'] = params['advanced_update'] 11704 if 'recycle_on_void' in params: 11705 query_params['recycle_on_void'] = params['recycle_on_void'] 11706 if 'resend_envelope' in params: 11707 query_params['resend_envelope'] = params['resend_envelope'] 11708 11709 header_params = {} 11710 11711 form_params = [] 11712 local_var_files = {} 11713 11714 body_params = None 11715 if 'envelope' in params: 11716 body_params = params['envelope'] 11717 # HTTP header `Accept` 11718 header_params['Accept'] = self.api_client.\ 11719 select_header_accept(['application/json']) 11720 11721 # Authentication setting 11722 auth_settings = [] 11723 11724 return self.api_client.call_api(resource_path, 'PUT', 11725 path_params, 11726 query_params, 11727 header_params, 11728 body=body_params, 11729 post_params=form_params, 11730 files=local_var_files, 11731 response_type='EnvelopeUpdateSummary', 11732 auth_settings=auth_settings, 11733 callback=params.get('callback'), 11734 _return_http_data_only=params.get('_return_http_data_only'), 11735 _preload_content=params.get('_preload_content', True), 11736 _request_timeout=params.get('_request_timeout'), 11737 collection_formats=collection_formats) 11738 11739 def update_chunked_upload(self, account_id, chunked_upload_id, **kwargs): 11740 """ 11741 Integrity-Check and Commit a ChunkedUpload, readying it for use elsewhere. 11742 This method checks the integrity of a chunked upload and then commits it. When this request is successful, the chunked upload is then ready to be referenced in other API calls. If the request is unsuccessful, ensure that you have uploaded all of the parts by using the Update method. **Note:** After you commit a chunked upload, it no longer accepts additional parts. 11743 This method makes a synchronous HTTP request by default. To make an 11744 asynchronous HTTP request, please define a `callback` function 11745 to be invoked when receiving the response. 11746 >>> def callback_function(response): 11747 >>> pprint(response) 11748 >>> 11749 >>> thread = api.update_chunked_upload(account_id, chunked_upload_id, callback=callback_function) 11750 11751 :param callback function: The callback function 11752 for asynchronous request. (optional) 11753 :param str account_id: The external account number (int) or account ID Guid. (required) 11754 :param str chunked_upload_id: (required) 11755 :param str action: 11756 :return: ChunkedUploadResponse 11757 If the method is called asynchronously, 11758 returns the request thread. 11759 """ 11760 kwargs['_return_http_data_only'] = True 11761 if kwargs.get('callback'): 11762 return self.update_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 11763 else: 11764 (data) = self.update_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 11765 return data 11766 11767 def update_chunked_upload_with_http_info(self, account_id, chunked_upload_id, **kwargs): 11768 """ 11769 Integrity-Check and Commit a ChunkedUpload, readying it for use elsewhere. 11770 This method checks the integrity of a chunked upload and then commits it. When this request is successful, the chunked upload is then ready to be referenced in other API calls. If the request is unsuccessful, ensure that you have uploaded all of the parts by using the Update method. **Note:** After you commit a chunked upload, it no longer accepts additional parts. 11771 This method makes a synchronous HTTP request by default. To make an 11772 asynchronous HTTP request, please define a `callback` function 11773 to be invoked when receiving the response. 11774 >>> def callback_function(response): 11775 >>> pprint(response) 11776 >>> 11777 >>> thread = api.update_chunked_upload_with_http_info(account_id, chunked_upload_id, callback=callback_function) 11778 11779 :param callback function: The callback function 11780 for asynchronous request. (optional) 11781 :param str account_id: The external account number (int) or account ID Guid. (required) 11782 :param str chunked_upload_id: (required) 11783 :param str action: 11784 :return: ChunkedUploadResponse 11785 If the method is called asynchronously, 11786 returns the request thread. 11787 """ 11788 11789 all_params = ['account_id', 'chunked_upload_id', 'action'] 11790 all_params.append('callback') 11791 all_params.append('_return_http_data_only') 11792 all_params.append('_preload_content') 11793 all_params.append('_request_timeout') 11794 11795 params = locals() 11796 for key, val in iteritems(params['kwargs']): 11797 if key not in all_params: 11798 raise TypeError( 11799 "Got an unexpected keyword argument '%s'" 11800 " to method update_chunked_upload" % key 11801 ) 11802 params[key] = val 11803 del params['kwargs'] 11804 # verify the required parameter 'account_id' is set 11805 if ('account_id' not in params) or (params['account_id'] is None): 11806 raise ValueError("Missing the required parameter `account_id` when calling `update_chunked_upload`") 11807 # verify the required parameter 'chunked_upload_id' is set 11808 if ('chunked_upload_id' not in params) or (params['chunked_upload_id'] is None): 11809 raise ValueError("Missing the required parameter `chunked_upload_id` when calling `update_chunked_upload`") 11810 11811 11812 collection_formats = {} 11813 11814 resource_path = '/v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}'.replace('{format}', 'json') 11815 path_params = {} 11816 if 'account_id' in params: 11817 path_params['accountId'] = params['account_id'] 11818 if 'chunked_upload_id' in params: 11819 path_params['chunkedUploadId'] = params['chunked_upload_id'] 11820 11821 query_params = {} 11822 if 'action' in params: 11823 query_params['action'] = params['action'] 11824 11825 header_params = {} 11826 11827 form_params = [] 11828 local_var_files = {} 11829 11830 body_params = None 11831 # HTTP header `Accept` 11832 header_params['Accept'] = self.api_client.\ 11833 select_header_accept(['application/json']) 11834 11835 # Authentication setting 11836 auth_settings = [] 11837 11838 return self.api_client.call_api(resource_path, 'PUT', 11839 path_params, 11840 query_params, 11841 header_params, 11842 body=body_params, 11843 post_params=form_params, 11844 files=local_var_files, 11845 response_type='ChunkedUploadResponse', 11846 auth_settings=auth_settings, 11847 callback=params.get('callback'), 11848 _return_http_data_only=params.get('_return_http_data_only'), 11849 _preload_content=params.get('_preload_content', True), 11850 _request_timeout=params.get('_request_timeout'), 11851 collection_formats=collection_formats) 11852 11853 def update_chunked_upload_part(self, account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs): 11854 """ 11855 Add a chunk, a chunk 'part', to an existing ChunkedUpload. 11856 Adds a chunk or part to an existing chunked upload. After you use the Create method to initiate a new chunked upload and upload the first part, use this method to upload subsequent parts. For simplicity, DocuSign recommends that you upload the parts in their sequential order ( 1,2, 3, 4, etc.). The Create method adds the first part and assigns it the `sequence` value `0`. As a result, DocuSign recommends that you start with a `sequence` value of `1` when you use this method, and continue uploading parts contiguously until you have uploaded the entirety of the original content to DocuSign. Example: ``` PUT /v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}/1 PUT /v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}/2 PUT /v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}/3 ``` **Note:** You cannot replace a part that DocuSign has already received, or add parts to a chunked upload that is already successfully committed. 11857 This method makes a synchronous HTTP request by default. To make an 11858 asynchronous HTTP request, please define a `callback` function 11859 to be invoked when receiving the response. 11860 >>> def callback_function(response): 11861 >>> pprint(response) 11862 >>> 11863 >>> thread = api.update_chunked_upload_part(account_id, chunked_upload_id, chunked_upload_part_seq, callback=callback_function) 11864 11865 :param callback function: The callback function 11866 for asynchronous request. (optional) 11867 :param str account_id: The external account number (int) or account ID Guid. (required) 11868 :param str chunked_upload_id: (required) 11869 :param str chunked_upload_part_seq: (required) 11870 :param ChunkedUploadRequest chunked_upload_request: 11871 :return: ChunkedUploadResponse 11872 If the method is called asynchronously, 11873 returns the request thread. 11874 """ 11875 kwargs['_return_http_data_only'] = True 11876 if kwargs.get('callback'): 11877 return self.update_chunked_upload_part_with_http_info(account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs) 11878 else: 11879 (data) = self.update_chunked_upload_part_with_http_info(account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs) 11880 return data 11881 11882 def update_chunked_upload_part_with_http_info(self, account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs): 11883 """ 11884 Add a chunk, a chunk 'part', to an existing ChunkedUpload. 11885 Adds a chunk or part to an existing chunked upload. After you use the Create method to initiate a new chunked upload and upload the first part, use this method to upload subsequent parts. For simplicity, DocuSign recommends that you upload the parts in their sequential order ( 1,2, 3, 4, etc.). The Create method adds the first part and assigns it the `sequence` value `0`. As a result, DocuSign recommends that you start with a `sequence` value of `1` when you use this method, and continue uploading parts contiguously until you have uploaded the entirety of the original content to DocuSign. Example: ``` PUT /v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}/1 PUT /v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}/2 PUT /v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}/3 ``` **Note:** You cannot replace a part that DocuSign has already received, or add parts to a chunked upload that is already successfully committed. 11886 This method makes a synchronous HTTP request by default. To make an 11887 asynchronous HTTP request, please define a `callback` function 11888 to be invoked when receiving the response. 11889 >>> def callback_function(response): 11890 >>> pprint(response) 11891 >>> 11892 >>> thread = api.update_chunked_upload_part_with_http_info(account_id, chunked_upload_id, chunked_upload_part_seq, callback=callback_function) 11893 11894 :param callback function: The callback function 11895 for asynchronous request. (optional) 11896 :param str account_id: The external account number (int) or account ID Guid. (required) 11897 :param str chunked_upload_id: (required) 11898 :param str chunked_upload_part_seq: (required) 11899 :param ChunkedUploadRequest chunked_upload_request: 11900 :return: ChunkedUploadResponse 11901 If the method is called asynchronously, 11902 returns the request thread. 11903 """ 11904 11905 all_params = ['account_id', 'chunked_upload_id', 'chunked_upload_part_seq', 'chunked_upload_request'] 11906 all_params.append('callback') 11907 all_params.append('_return_http_data_only') 11908 all_params.append('_preload_content') 11909 all_params.append('_request_timeout') 11910 11911 params = locals() 11912 for key, val in iteritems(params['kwargs']): 11913 if key not in all_params: 11914 raise TypeError( 11915 "Got an unexpected keyword argument '%s'" 11916 " to method update_chunked_upload_part" % key 11917 ) 11918 params[key] = val 11919 del params['kwargs'] 11920 # verify the required parameter 'account_id' is set 11921 if ('account_id' not in params) or (params['account_id'] is None): 11922 raise ValueError("Missing the required parameter `account_id` when calling `update_chunked_upload_part`") 11923 # verify the required parameter 'chunked_upload_id' is set 11924 if ('chunked_upload_id' not in params) or (params['chunked_upload_id'] is None): 11925 raise ValueError("Missing the required parameter `chunked_upload_id` when calling `update_chunked_upload_part`") 11926 # verify the required parameter 'chunked_upload_part_seq' is set 11927 if ('chunked_upload_part_seq' not in params) or (params['chunked_upload_part_seq'] is None): 11928 raise ValueError("Missing the required parameter `chunked_upload_part_seq` when calling `update_chunked_upload_part`") 11929 11930 11931 collection_formats = {} 11932 11933 resource_path = '/v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}/{chunkedUploadPartSeq}'.replace('{format}', 'json') 11934 path_params = {} 11935 if 'account_id' in params: 11936 path_params['accountId'] = params['account_id'] 11937 if 'chunked_upload_id' in params: 11938 path_params['chunkedUploadId'] = params['chunked_upload_id'] 11939 if 'chunked_upload_part_seq' in params: 11940 path_params['chunkedUploadPartSeq'] = params['chunked_upload_part_seq'] 11941 11942 query_params = {} 11943 11944 header_params = {} 11945 11946 form_params = [] 11947 local_var_files = {} 11948 11949 body_params = None 11950 if 'chunked_upload_request' in params: 11951 body_params = params['chunked_upload_request'] 11952 # HTTP header `Accept` 11953 header_params['Accept'] = self.api_client.\ 11954 select_header_accept(['application/json']) 11955 11956 # Authentication setting 11957 auth_settings = [] 11958 11959 return self.api_client.call_api(resource_path, 'PUT', 11960 path_params, 11961 query_params, 11962 header_params, 11963 body=body_params, 11964 post_params=form_params, 11965 files=local_var_files, 11966 response_type='ChunkedUploadResponse', 11967 auth_settings=auth_settings, 11968 callback=params.get('callback'), 11969 _return_http_data_only=params.get('_return_http_data_only'), 11970 _preload_content=params.get('_preload_content', True), 11971 _request_timeout=params.get('_request_timeout'), 11972 collection_formats=collection_formats) 11973 11974 def update_custom_fields(self, account_id, envelope_id, **kwargs): 11975 """ 11976 Updates envelope custom fields in an envelope. 11977 Updates the envelope custom fields in draft and in-process envelopes. Each custom field used in an envelope must have a unique name. 11978 This method makes a synchronous HTTP request by default. To make an 11979 asynchronous HTTP request, please define a `callback` function 11980 to be invoked when receiving the response. 11981 >>> def callback_function(response): 11982 >>> pprint(response) 11983 >>> 11984 >>> thread = api.update_custom_fields(account_id, envelope_id, callback=callback_function) 11985 11986 :param callback function: The callback function 11987 for asynchronous request. (optional) 11988 :param str account_id: The external account number (int) or account ID Guid. (required) 11989 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11990 :param CustomFields custom_fields: 11991 :return: CustomFields 11992 If the method is called asynchronously, 11993 returns the request thread. 11994 """ 11995 kwargs['_return_http_data_only'] = True 11996 if kwargs.get('callback'): 11997 return self.update_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 11998 else: 11999 (data) = self.update_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 12000 return data 12001 12002 def update_custom_fields_with_http_info(self, account_id, envelope_id, **kwargs): 12003 """ 12004 Updates envelope custom fields in an envelope. 12005 Updates the envelope custom fields in draft and in-process envelopes. Each custom field used in an envelope must have a unique name. 12006 This method makes a synchronous HTTP request by default. To make an 12007 asynchronous HTTP request, please define a `callback` function 12008 to be invoked when receiving the response. 12009 >>> def callback_function(response): 12010 >>> pprint(response) 12011 >>> 12012 >>> thread = api.update_custom_fields_with_http_info(account_id, envelope_id, callback=callback_function) 12013 12014 :param callback function: The callback function 12015 for asynchronous request. (optional) 12016 :param str account_id: The external account number (int) or account ID Guid. (required) 12017 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12018 :param CustomFields custom_fields: 12019 :return: CustomFields 12020 If the method is called asynchronously, 12021 returns the request thread. 12022 """ 12023 12024 all_params = ['account_id', 'envelope_id', 'custom_fields'] 12025 all_params.append('callback') 12026 all_params.append('_return_http_data_only') 12027 all_params.append('_preload_content') 12028 all_params.append('_request_timeout') 12029 12030 params = locals() 12031 for key, val in iteritems(params['kwargs']): 12032 if key not in all_params: 12033 raise TypeError( 12034 "Got an unexpected keyword argument '%s'" 12035 " to method update_custom_fields" % key 12036 ) 12037 params[key] = val 12038 del params['kwargs'] 12039 # verify the required parameter 'account_id' is set 12040 if ('account_id' not in params) or (params['account_id'] is None): 12041 raise ValueError("Missing the required parameter `account_id` when calling `update_custom_fields`") 12042 # verify the required parameter 'envelope_id' is set 12043 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12044 raise ValueError("Missing the required parameter `envelope_id` when calling `update_custom_fields`") 12045 12046 12047 collection_formats = {} 12048 12049 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/custom_fields'.replace('{format}', 'json') 12050 path_params = {} 12051 if 'account_id' in params: 12052 path_params['accountId'] = params['account_id'] 12053 if 'envelope_id' in params: 12054 path_params['envelopeId'] = params['envelope_id'] 12055 12056 query_params = {} 12057 12058 header_params = {} 12059 12060 form_params = [] 12061 local_var_files = {} 12062 12063 body_params = None 12064 if 'custom_fields' in params: 12065 body_params = params['custom_fields'] 12066 # HTTP header `Accept` 12067 header_params['Accept'] = self.api_client.\ 12068 select_header_accept(['application/json']) 12069 12070 # Authentication setting 12071 auth_settings = [] 12072 12073 return self.api_client.call_api(resource_path, 'PUT', 12074 path_params, 12075 query_params, 12076 header_params, 12077 body=body_params, 12078 post_params=form_params, 12079 files=local_var_files, 12080 response_type='CustomFields', 12081 auth_settings=auth_settings, 12082 callback=params.get('callback'), 12083 _return_http_data_only=params.get('_return_http_data_only'), 12084 _preload_content=params.get('_preload_content', True), 12085 _request_timeout=params.get('_request_timeout'), 12086 collection_formats=collection_formats) 12087 12088 def update_document(self, account_id, document_id, envelope_id, document_file_bytes, **kwargs): 12089 """ 12090 Adds a document to an existing draft envelope. 12091 Adds a document to an existing draft envelope. 12092 This method makes a synchronous HTTP request by default. To make an 12093 asynchronous HTTP request, please define a `callback` function 12094 to be invoked when receiving the response. 12095 >>> def callback_function(response): 12096 >>> pprint(response) 12097 >>> 12098 >>> thread = api.update_document(account_id, document_id, envelope_id, document_file_bytes, callback=callback_function) 12099 12100 :param callback function: The callback function 12101 for asynchronous request. (optional) 12102 :param str account_id: The external account number (int) or account ID Guid. (required) 12103 :param str document_id: The ID of the document being accessed. (required) 12104 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12105 :param str document_file_bytes: Updated document content. (required) 12106 :return: EnvelopeDocument 12107 If the method is called asynchronously, 12108 returns the request thread. 12109 """ 12110 kwargs['_return_http_data_only'] = True 12111 if kwargs.get('callback'): 12112 return self.update_document_with_http_info(account_id, document_id, envelope_id, document_file_bytes, **kwargs) 12113 else: 12114 (data) = self.update_document_with_http_info(account_id, document_id, envelope_id, document_file_bytes, **kwargs) 12115 return data 12116 12117 def update_document_with_http_info(self, account_id, document_id, envelope_id, document_file_bytes, **kwargs): 12118 """ 12119 Adds a document to an existing draft envelope. 12120 Adds a document to an existing draft envelope. 12121 This method makes a synchronous HTTP request by default. To make an 12122 asynchronous HTTP request, please define a `callback` function 12123 to be invoked when receiving the response. 12124 >>> def callback_function(response): 12125 >>> pprint(response) 12126 >>> 12127 >>> thread = api.update_document_with_http_info(account_id, document_id, envelope_id, document_file_bytes, callback=callback_function) 12128 12129 :param callback function: The callback function 12130 for asynchronous request. (optional) 12131 :param str account_id: The external account number (int) or account ID Guid. (required) 12132 :param str document_id: The ID of the document being accessed. (required) 12133 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12134 :param str document_file_bytes: Updated document content. (required) 12135 :return: EnvelopeDocument 12136 If the method is called asynchronously, 12137 returns the request thread. 12138 """ 12139 12140 all_params = ['account_id', 'document_id', 'envelope_id', 'document_file_bytes'] 12141 all_params.append('callback') 12142 all_params.append('_return_http_data_only') 12143 all_params.append('_preload_content') 12144 all_params.append('_request_timeout') 12145 12146 params = locals() 12147 for key, val in iteritems(params['kwargs']): 12148 if key not in all_params: 12149 raise TypeError( 12150 "Got an unexpected keyword argument '%s'" 12151 " to method update_document" % key 12152 ) 12153 params[key] = val 12154 del params['kwargs'] 12155 # verify the required parameter 'account_id' is set 12156 if ('account_id' not in params) or (params['account_id'] is None): 12157 raise ValueError("Missing the required parameter `account_id` when calling `update_document`") 12158 # verify the required parameter 'document_id' is set 12159 if ('document_id' not in params) or (params['document_id'] is None): 12160 raise ValueError("Missing the required parameter `document_id` when calling `update_document`") 12161 # verify the required parameter 'envelope_id' is set 12162 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12163 raise ValueError("Missing the required parameter `envelope_id` when calling `update_document`") 12164 # verify the required parameter 'document_file_bytes' is set 12165 if ('document_file_bytes' not in params) or (params['document_file_bytes'] is None): 12166 raise ValueError("Missing the required parameter `document_file_bytes` when calling `update_document`") 12167 12168 12169 collection_formats = {} 12170 12171 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}'.replace('{format}', 'json') 12172 path_params = {} 12173 if 'account_id' in params: 12174 path_params['accountId'] = params['account_id'] 12175 if 'document_id' in params: 12176 path_params['documentId'] = params['document_id'] 12177 if 'envelope_id' in params: 12178 path_params['envelopeId'] = params['envelope_id'] 12179 12180 query_params = {} 12181 12182 header_params = {} 12183 12184 form_params = [] 12185 local_var_files = {} 12186 12187 body_params = None 12188 if 'document_file_bytes' in params: 12189 body_params = params['document_file_bytes'] 12190 # HTTP header `Accept` 12191 header_params['Accept'] = self.api_client.\ 12192 select_header_accept(['application/json']) 12193 12194 # HTTP header `Content-Type` 12195 header_params['Content-Type'] = self.api_client.\ 12196 select_header_content_type(['application/pdf']) 12197 12198 # Authentication setting 12199 auth_settings = [] 12200 12201 return self.api_client.call_api(resource_path, 'PUT', 12202 path_params, 12203 query_params, 12204 header_params, 12205 body=body_params, 12206 post_params=form_params, 12207 files=local_var_files, 12208 response_type='EnvelopeDocument', 12209 auth_settings=auth_settings, 12210 callback=params.get('callback'), 12211 _return_http_data_only=params.get('_return_http_data_only'), 12212 _preload_content=params.get('_preload_content', True), 12213 _request_timeout=params.get('_request_timeout'), 12214 collection_formats=collection_formats) 12215 12216 def update_document_fields(self, account_id, document_id, envelope_id, **kwargs): 12217 """ 12218 Updates existing custom document fields in an existing envelope document. 12219 Updates existing custom document fields in an existing envelope document. 12220 This method makes a synchronous HTTP request by default. To make an 12221 asynchronous HTTP request, please define a `callback` function 12222 to be invoked when receiving the response. 12223 >>> def callback_function(response): 12224 >>> pprint(response) 12225 >>> 12226 >>> thread = api.update_document_fields(account_id, document_id, envelope_id, callback=callback_function) 12227 12228 :param callback function: The callback function 12229 for asynchronous request. (optional) 12230 :param str account_id: The external account number (int) or account ID Guid. (required) 12231 :param str document_id: The ID of the document being accessed. (required) 12232 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12233 :param DocumentFieldsInformation document_fields_information: 12234 :return: DocumentFieldsInformation 12235 If the method is called asynchronously, 12236 returns the request thread. 12237 """ 12238 kwargs['_return_http_data_only'] = True 12239 if kwargs.get('callback'): 12240 return self.update_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 12241 else: 12242 (data) = self.update_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 12243 return data 12244 12245 def update_document_fields_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 12246 """ 12247 Updates existing custom document fields in an existing envelope document. 12248 Updates existing custom document fields in an existing envelope document. 12249 This method makes a synchronous HTTP request by default. To make an 12250 asynchronous HTTP request, please define a `callback` function 12251 to be invoked when receiving the response. 12252 >>> def callback_function(response): 12253 >>> pprint(response) 12254 >>> 12255 >>> thread = api.update_document_fields_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 12256 12257 :param callback function: The callback function 12258 for asynchronous request. (optional) 12259 :param str account_id: The external account number (int) or account ID Guid. (required) 12260 :param str document_id: The ID of the document being accessed. (required) 12261 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12262 :param DocumentFieldsInformation document_fields_information: 12263 :return: DocumentFieldsInformation 12264 If the method is called asynchronously, 12265 returns the request thread. 12266 """ 12267 12268 all_params = ['account_id', 'document_id', 'envelope_id', 'document_fields_information'] 12269 all_params.append('callback') 12270 all_params.append('_return_http_data_only') 12271 all_params.append('_preload_content') 12272 all_params.append('_request_timeout') 12273 12274 params = locals() 12275 for key, val in iteritems(params['kwargs']): 12276 if key not in all_params: 12277 raise TypeError( 12278 "Got an unexpected keyword argument '%s'" 12279 " to method update_document_fields" % key 12280 ) 12281 params[key] = val 12282 del params['kwargs'] 12283 # verify the required parameter 'account_id' is set 12284 if ('account_id' not in params) or (params['account_id'] is None): 12285 raise ValueError("Missing the required parameter `account_id` when calling `update_document_fields`") 12286 # verify the required parameter 'document_id' is set 12287 if ('document_id' not in params) or (params['document_id'] is None): 12288 raise ValueError("Missing the required parameter `document_id` when calling `update_document_fields`") 12289 # verify the required parameter 'envelope_id' is set 12290 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12291 raise ValueError("Missing the required parameter `envelope_id` when calling `update_document_fields`") 12292 12293 12294 collection_formats = {} 12295 12296 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/fields'.replace('{format}', 'json') 12297 path_params = {} 12298 if 'account_id' in params: 12299 path_params['accountId'] = params['account_id'] 12300 if 'document_id' in params: 12301 path_params['documentId'] = params['document_id'] 12302 if 'envelope_id' in params: 12303 path_params['envelopeId'] = params['envelope_id'] 12304 12305 query_params = {} 12306 12307 header_params = {} 12308 12309 form_params = [] 12310 local_var_files = {} 12311 12312 body_params = None 12313 if 'document_fields_information' in params: 12314 body_params = params['document_fields_information'] 12315 # HTTP header `Accept` 12316 header_params['Accept'] = self.api_client.\ 12317 select_header_accept(['application/json']) 12318 12319 # Authentication setting 12320 auth_settings = [] 12321 12322 return self.api_client.call_api(resource_path, 'PUT', 12323 path_params, 12324 query_params, 12325 header_params, 12326 body=body_params, 12327 post_params=form_params, 12328 files=local_var_files, 12329 response_type='DocumentFieldsInformation', 12330 auth_settings=auth_settings, 12331 callback=params.get('callback'), 12332 _return_http_data_only=params.get('_return_http_data_only'), 12333 _preload_content=params.get('_preload_content', True), 12334 _request_timeout=params.get('_request_timeout'), 12335 collection_formats=collection_formats) 12336 12337 def update_document_tabs(self, account_id, document_id, envelope_id, **kwargs): 12338 """ 12339 Updates the tabs for an envelope document 12340 Updates tabs in the document specified by `documentId` in the envelope specified by `envelopeId`. 12341 This method makes a synchronous HTTP request by default. To make an 12342 asynchronous HTTP request, please define a `callback` function 12343 to be invoked when receiving the response. 12344 >>> def callback_function(response): 12345 >>> pprint(response) 12346 >>> 12347 >>> thread = api.update_document_tabs(account_id, document_id, envelope_id, callback=callback_function) 12348 12349 :param callback function: The callback function 12350 for asynchronous request. (optional) 12351 :param str account_id: The external account number (int) or account ID Guid. (required) 12352 :param str document_id: The ID of the document being accessed. (required) 12353 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12354 :param Tabs tabs: 12355 :return: Tabs 12356 If the method is called asynchronously, 12357 returns the request thread. 12358 """ 12359 kwargs['_return_http_data_only'] = True 12360 if kwargs.get('callback'): 12361 return self.update_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 12362 else: 12363 (data) = self.update_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 12364 return data 12365 12366 def update_document_tabs_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 12367 """ 12368 Updates the tabs for an envelope document 12369 Updates tabs in the document specified by `documentId` in the envelope specified by `envelopeId`. 12370 This method makes a synchronous HTTP request by default. To make an 12371 asynchronous HTTP request, please define a `callback` function 12372 to be invoked when receiving the response. 12373 >>> def callback_function(response): 12374 >>> pprint(response) 12375 >>> 12376 >>> thread = api.update_document_tabs_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 12377 12378 :param callback function: The callback function 12379 for asynchronous request. (optional) 12380 :param str account_id: The external account number (int) or account ID Guid. (required) 12381 :param str document_id: The ID of the document being accessed. (required) 12382 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12383 :param Tabs tabs: 12384 :return: Tabs 12385 If the method is called asynchronously, 12386 returns the request thread. 12387 """ 12388 12389 all_params = ['account_id', 'document_id', 'envelope_id', 'tabs'] 12390 all_params.append('callback') 12391 all_params.append('_return_http_data_only') 12392 all_params.append('_preload_content') 12393 all_params.append('_request_timeout') 12394 12395 params = locals() 12396 for key, val in iteritems(params['kwargs']): 12397 if key not in all_params: 12398 raise TypeError( 12399 "Got an unexpected keyword argument '%s'" 12400 " to method update_document_tabs" % key 12401 ) 12402 params[key] = val 12403 del params['kwargs'] 12404 # verify the required parameter 'account_id' is set 12405 if ('account_id' not in params) or (params['account_id'] is None): 12406 raise ValueError("Missing the required parameter `account_id` when calling `update_document_tabs`") 12407 # verify the required parameter 'document_id' is set 12408 if ('document_id' not in params) or (params['document_id'] is None): 12409 raise ValueError("Missing the required parameter `document_id` when calling `update_document_tabs`") 12410 # verify the required parameter 'envelope_id' is set 12411 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12412 raise ValueError("Missing the required parameter `envelope_id` when calling `update_document_tabs`") 12413 12414 12415 collection_formats = {} 12416 12417 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/tabs'.replace('{format}', 'json') 12418 path_params = {} 12419 if 'account_id' in params: 12420 path_params['accountId'] = params['account_id'] 12421 if 'document_id' in params: 12422 path_params['documentId'] = params['document_id'] 12423 if 'envelope_id' in params: 12424 path_params['envelopeId'] = params['envelope_id'] 12425 12426 query_params = {} 12427 12428 header_params = {} 12429 12430 form_params = [] 12431 local_var_files = {} 12432 12433 body_params = None 12434 if 'tabs' in params: 12435 body_params = params['tabs'] 12436 # HTTP header `Accept` 12437 header_params['Accept'] = self.api_client.\ 12438 select_header_accept(['application/json']) 12439 12440 # Authentication setting 12441 auth_settings = [] 12442 12443 return self.api_client.call_api(resource_path, 'PUT', 12444 path_params, 12445 query_params, 12446 header_params, 12447 body=body_params, 12448 post_params=form_params, 12449 files=local_var_files, 12450 response_type='Tabs', 12451 auth_settings=auth_settings, 12452 callback=params.get('callback'), 12453 _return_http_data_only=params.get('_return_http_data_only'), 12454 _preload_content=params.get('_preload_content', True), 12455 _request_timeout=params.get('_request_timeout'), 12456 collection_formats=collection_formats) 12457 12458 def update_documents(self, account_id, envelope_id, **kwargs): 12459 """ 12460 Adds one or more documents to an existing envelope document. 12461 Adds one or more documents to an existing envelope document. 12462 This method makes a synchronous HTTP request by default. To make an 12463 asynchronous HTTP request, please define a `callback` function 12464 to be invoked when receiving the response. 12465 >>> def callback_function(response): 12466 >>> pprint(response) 12467 >>> 12468 >>> thread = api.update_documents(account_id, envelope_id, callback=callback_function) 12469 12470 :param callback function: The callback function 12471 for asynchronous request. (optional) 12472 :param str account_id: The external account number (int) or account ID Guid. (required) 12473 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12474 :param EnvelopeDefinition envelope_definition: 12475 :return: EnvelopeDocumentsResult 12476 If the method is called asynchronously, 12477 returns the request thread. 12478 """ 12479 kwargs['_return_http_data_only'] = True 12480 if kwargs.get('callback'): 12481 return self.update_documents_with_http_info(account_id, envelope_id, **kwargs) 12482 else: 12483 (data) = self.update_documents_with_http_info(account_id, envelope_id, **kwargs) 12484 return data 12485 12486 def update_documents_with_http_info(self, account_id, envelope_id, **kwargs): 12487 """ 12488 Adds one or more documents to an existing envelope document. 12489 Adds one or more documents to an existing envelope document. 12490 This method makes a synchronous HTTP request by default. To make an 12491 asynchronous HTTP request, please define a `callback` function 12492 to be invoked when receiving the response. 12493 >>> def callback_function(response): 12494 >>> pprint(response) 12495 >>> 12496 >>> thread = api.update_documents_with_http_info(account_id, envelope_id, callback=callback_function) 12497 12498 :param callback function: The callback function 12499 for asynchronous request. (optional) 12500 :param str account_id: The external account number (int) or account ID Guid. (required) 12501 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12502 :param EnvelopeDefinition envelope_definition: 12503 :return: EnvelopeDocumentsResult 12504 If the method is called asynchronously, 12505 returns the request thread. 12506 """ 12507 12508 all_params = ['account_id', 'envelope_id', 'envelope_definition'] 12509 all_params.append('callback') 12510 all_params.append('_return_http_data_only') 12511 all_params.append('_preload_content') 12512 all_params.append('_request_timeout') 12513 12514 params = locals() 12515 for key, val in iteritems(params['kwargs']): 12516 if key not in all_params: 12517 raise TypeError( 12518 "Got an unexpected keyword argument '%s'" 12519 " to method update_documents" % key 12520 ) 12521 params[key] = val 12522 del params['kwargs'] 12523 # verify the required parameter 'account_id' is set 12524 if ('account_id' not in params) or (params['account_id'] is None): 12525 raise ValueError("Missing the required parameter `account_id` when calling `update_documents`") 12526 # verify the required parameter 'envelope_id' is set 12527 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12528 raise ValueError("Missing the required parameter `envelope_id` when calling `update_documents`") 12529 12530 12531 collection_formats = {} 12532 12533 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents'.replace('{format}', 'json') 12534 path_params = {} 12535 if 'account_id' in params: 12536 path_params['accountId'] = params['account_id'] 12537 if 'envelope_id' in params: 12538 path_params['envelopeId'] = params['envelope_id'] 12539 12540 query_params = {} 12541 12542 header_params = {} 12543 12544 form_params = [] 12545 local_var_files = {} 12546 12547 body_params = None 12548 if 'envelope_definition' in params: 12549 body_params = params['envelope_definition'] 12550 # HTTP header `Accept` 12551 header_params['Accept'] = self.api_client.\ 12552 select_header_accept(['application/json']) 12553 12554 # Authentication setting 12555 auth_settings = [] 12556 12557 return self.api_client.call_api(resource_path, 'PUT', 12558 path_params, 12559 query_params, 12560 header_params, 12561 body=body_params, 12562 post_params=form_params, 12563 files=local_var_files, 12564 response_type='EnvelopeDocumentsResult', 12565 auth_settings=auth_settings, 12566 callback=params.get('callback'), 12567 _return_http_data_only=params.get('_return_http_data_only'), 12568 _preload_content=params.get('_preload_content', True), 12569 _request_timeout=params.get('_request_timeout'), 12570 collection_formats=collection_formats) 12571 12572 def update_email_settings(self, account_id, envelope_id, **kwargs): 12573 """ 12574 Updates the email setting overrides for an envelope. 12575 Updates the existing email override settings for the specified envelope. Note that modifying email settings will only affect email communications that occur after the modification was made. This can also be used to delete an individual email override setting by using an empty string for the value to be deleted. 12576 This method makes a synchronous HTTP request by default. To make an 12577 asynchronous HTTP request, please define a `callback` function 12578 to be invoked when receiving the response. 12579 >>> def callback_function(response): 12580 >>> pprint(response) 12581 >>> 12582 >>> thread = api.update_email_settings(account_id, envelope_id, callback=callback_function) 12583 12584 :param callback function: The callback function 12585 for asynchronous request. (optional) 12586 :param str account_id: The external account number (int) or account ID Guid. (required) 12587 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12588 :param EmailSettings email_settings: 12589 :return: EmailSettings 12590 If the method is called asynchronously, 12591 returns the request thread. 12592 """ 12593 kwargs['_return_http_data_only'] = True 12594 if kwargs.get('callback'): 12595 return self.update_email_settings_with_http_info(account_id, envelope_id, **kwargs) 12596 else: 12597 (data) = self.update_email_settings_with_http_info(account_id, envelope_id, **kwargs) 12598 return data 12599 12600 def update_email_settings_with_http_info(self, account_id, envelope_id, **kwargs): 12601 """ 12602 Updates the email setting overrides for an envelope. 12603 Updates the existing email override settings for the specified envelope. Note that modifying email settings will only affect email communications that occur after the modification was made. This can also be used to delete an individual email override setting by using an empty string for the value to be deleted. 12604 This method makes a synchronous HTTP request by default. To make an 12605 asynchronous HTTP request, please define a `callback` function 12606 to be invoked when receiving the response. 12607 >>> def callback_function(response): 12608 >>> pprint(response) 12609 >>> 12610 >>> thread = api.update_email_settings_with_http_info(account_id, envelope_id, callback=callback_function) 12611 12612 :param callback function: The callback function 12613 for asynchronous request. (optional) 12614 :param str account_id: The external account number (int) or account ID Guid. (required) 12615 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12616 :param EmailSettings email_settings: 12617 :return: EmailSettings 12618 If the method is called asynchronously, 12619 returns the request thread. 12620 """ 12621 12622 all_params = ['account_id', 'envelope_id', 'email_settings'] 12623 all_params.append('callback') 12624 all_params.append('_return_http_data_only') 12625 all_params.append('_preload_content') 12626 all_params.append('_request_timeout') 12627 12628 params = locals() 12629 for key, val in iteritems(params['kwargs']): 12630 if key not in all_params: 12631 raise TypeError( 12632 "Got an unexpected keyword argument '%s'" 12633 " to method update_email_settings" % key 12634 ) 12635 params[key] = val 12636 del params['kwargs'] 12637 # verify the required parameter 'account_id' is set 12638 if ('account_id' not in params) or (params['account_id'] is None): 12639 raise ValueError("Missing the required parameter `account_id` when calling `update_email_settings`") 12640 # verify the required parameter 'envelope_id' is set 12641 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12642 raise ValueError("Missing the required parameter `envelope_id` when calling `update_email_settings`") 12643 12644 12645 collection_formats = {} 12646 12647 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/email_settings'.replace('{format}', 'json') 12648 path_params = {} 12649 if 'account_id' in params: 12650 path_params['accountId'] = params['account_id'] 12651 if 'envelope_id' in params: 12652 path_params['envelopeId'] = params['envelope_id'] 12653 12654 query_params = {} 12655 12656 header_params = {} 12657 12658 form_params = [] 12659 local_var_files = {} 12660 12661 body_params = None 12662 if 'email_settings' in params: 12663 body_params = params['email_settings'] 12664 # HTTP header `Accept` 12665 header_params['Accept'] = self.api_client.\ 12666 select_header_accept(['application/json']) 12667 12668 # Authentication setting 12669 auth_settings = [] 12670 12671 return self.api_client.call_api(resource_path, 'PUT', 12672 path_params, 12673 query_params, 12674 header_params, 12675 body=body_params, 12676 post_params=form_params, 12677 files=local_var_files, 12678 response_type='EmailSettings', 12679 auth_settings=auth_settings, 12680 callback=params.get('callback'), 12681 _return_http_data_only=params.get('_return_http_data_only'), 12682 _preload_content=params.get('_preload_content', True), 12683 _request_timeout=params.get('_request_timeout'), 12684 collection_formats=collection_formats) 12685 12686 def update_envelope_delayed_routing_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 12687 """ 12688 Updates the delayed routing rules for an envelope's workflow step definition. 12689 This method makes a synchronous HTTP request by default. To make an 12690 asynchronous HTTP request, please define a `callback` function 12691 to be invoked when receiving the response. 12692 >>> def callback_function(response): 12693 >>> pprint(response) 12694 >>> 12695 >>> thread = api.update_envelope_delayed_routing_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 12696 12697 :param callback function: The callback function 12698 for asynchronous request. (optional) 12699 :param str account_id: The external account number (int) or account ID Guid. (required) 12700 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12701 :param str workflow_step_id: (required) 12702 :param DelayedRouting delayed_routing: 12703 :return: DelayedRouting 12704 If the method is called asynchronously, 12705 returns the request thread. 12706 """ 12707 kwargs['_return_http_data_only'] = True 12708 if kwargs.get('callback'): 12709 return self.update_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 12710 else: 12711 (data) = self.update_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 12712 return data 12713 12714 def update_envelope_delayed_routing_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 12715 """ 12716 Updates the delayed routing rules for an envelope's workflow step definition. 12717 This method makes a synchronous HTTP request by default. To make an 12718 asynchronous HTTP request, please define a `callback` function 12719 to be invoked when receiving the response. 12720 >>> def callback_function(response): 12721 >>> pprint(response) 12722 >>> 12723 >>> thread = api.update_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 12724 12725 :param callback function: The callback function 12726 for asynchronous request. (optional) 12727 :param str account_id: The external account number (int) or account ID Guid. (required) 12728 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12729 :param str workflow_step_id: (required) 12730 :param DelayedRouting delayed_routing: 12731 :return: DelayedRouting 12732 If the method is called asynchronously, 12733 returns the request thread. 12734 """ 12735 12736 all_params = ['account_id', 'envelope_id', 'workflow_step_id', 'delayed_routing'] 12737 all_params.append('callback') 12738 all_params.append('_return_http_data_only') 12739 all_params.append('_preload_content') 12740 all_params.append('_request_timeout') 12741 12742 params = locals() 12743 for key, val in iteritems(params['kwargs']): 12744 if key not in all_params: 12745 raise TypeError( 12746 "Got an unexpected keyword argument '%s'" 12747 " to method update_envelope_delayed_routing_definition" % key 12748 ) 12749 params[key] = val 12750 del params['kwargs'] 12751 # verify the required parameter 'account_id' is set 12752 if ('account_id' not in params) or (params['account_id'] is None): 12753 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_delayed_routing_definition`") 12754 # verify the required parameter 'envelope_id' is set 12755 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12756 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_delayed_routing_definition`") 12757 # verify the required parameter 'workflow_step_id' is set 12758 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 12759 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_envelope_delayed_routing_definition`") 12760 12761 12762 collection_formats = {} 12763 12764 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 12765 path_params = {} 12766 if 'account_id' in params: 12767 path_params['accountId'] = params['account_id'] 12768 if 'envelope_id' in params: 12769 path_params['envelopeId'] = params['envelope_id'] 12770 if 'workflow_step_id' in params: 12771 path_params['workflowStepId'] = params['workflow_step_id'] 12772 12773 query_params = {} 12774 12775 header_params = {} 12776 12777 form_params = [] 12778 local_var_files = {} 12779 12780 body_params = None 12781 if 'delayed_routing' in params: 12782 body_params = params['delayed_routing'] 12783 # HTTP header `Accept` 12784 header_params['Accept'] = self.api_client.\ 12785 select_header_accept(['application/json']) 12786 12787 # Authentication setting 12788 auth_settings = [] 12789 12790 return self.api_client.call_api(resource_path, 'PUT', 12791 path_params, 12792 query_params, 12793 header_params, 12794 body=body_params, 12795 post_params=form_params, 12796 files=local_var_files, 12797 response_type='DelayedRouting', 12798 auth_settings=auth_settings, 12799 callback=params.get('callback'), 12800 _return_http_data_only=params.get('_return_http_data_only'), 12801 _preload_content=params.get('_preload_content', True), 12802 _request_timeout=params.get('_request_timeout'), 12803 collection_formats=collection_formats) 12804 12805 def update_envelope_doc_gen_form_fields(self, account_id, envelope_id, **kwargs): 12806 """ 12807 Updates formfields for an envelope 12808 This method makes a synchronous HTTP request by default. To make an 12809 asynchronous HTTP request, please define a `callback` function 12810 to be invoked when receiving the response. 12811 >>> def callback_function(response): 12812 >>> pprint(response) 12813 >>> 12814 >>> thread = api.update_envelope_doc_gen_form_fields(account_id, envelope_id, callback=callback_function) 12815 12816 :param callback function: The callback function 12817 for asynchronous request. (optional) 12818 :param str account_id: The external account number (int) or account ID Guid. (required) 12819 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12820 :param str update_docgen_formfields_only: 12821 :param DocGenFormFieldRequest doc_gen_form_field_request: 12822 :return: DocGenFormFieldResponse 12823 If the method is called asynchronously, 12824 returns the request thread. 12825 """ 12826 kwargs['_return_http_data_only'] = True 12827 if kwargs.get('callback'): 12828 return self.update_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, **kwargs) 12829 else: 12830 (data) = self.update_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, **kwargs) 12831 return data 12832 12833 def update_envelope_doc_gen_form_fields_with_http_info(self, account_id, envelope_id, **kwargs): 12834 """ 12835 Updates formfields for an envelope 12836 This method makes a synchronous HTTP request by default. To make an 12837 asynchronous HTTP request, please define a `callback` function 12838 to be invoked when receiving the response. 12839 >>> def callback_function(response): 12840 >>> pprint(response) 12841 >>> 12842 >>> thread = api.update_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, callback=callback_function) 12843 12844 :param callback function: The callback function 12845 for asynchronous request. (optional) 12846 :param str account_id: The external account number (int) or account ID Guid. (required) 12847 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12848 :param str update_docgen_formfields_only: 12849 :param DocGenFormFieldRequest doc_gen_form_field_request: 12850 :return: DocGenFormFieldResponse 12851 If the method is called asynchronously, 12852 returns the request thread. 12853 """ 12854 12855 all_params = ['account_id', 'envelope_id', 'update_docgen_formfields_only', 'doc_gen_form_field_request'] 12856 all_params.append('callback') 12857 all_params.append('_return_http_data_only') 12858 all_params.append('_preload_content') 12859 all_params.append('_request_timeout') 12860 12861 params = locals() 12862 for key, val in iteritems(params['kwargs']): 12863 if key not in all_params: 12864 raise TypeError( 12865 "Got an unexpected keyword argument '%s'" 12866 " to method update_envelope_doc_gen_form_fields" % key 12867 ) 12868 params[key] = val 12869 del params['kwargs'] 12870 # verify the required parameter 'account_id' is set 12871 if ('account_id' not in params) or (params['account_id'] is None): 12872 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_doc_gen_form_fields`") 12873 # verify the required parameter 'envelope_id' is set 12874 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12875 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_doc_gen_form_fields`") 12876 12877 12878 collection_formats = {} 12879 12880 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/docGenFormFields'.replace('{format}', 'json') 12881 path_params = {} 12882 if 'account_id' in params: 12883 path_params['accountId'] = params['account_id'] 12884 if 'envelope_id' in params: 12885 path_params['envelopeId'] = params['envelope_id'] 12886 12887 query_params = {} 12888 if 'update_docgen_formfields_only' in params: 12889 query_params['update_docgen_formfields_only'] = params['update_docgen_formfields_only'] 12890 12891 header_params = {} 12892 12893 form_params = [] 12894 local_var_files = {} 12895 12896 body_params = None 12897 if 'doc_gen_form_field_request' in params: 12898 body_params = params['doc_gen_form_field_request'] 12899 # HTTP header `Accept` 12900 header_params['Accept'] = self.api_client.\ 12901 select_header_accept(['application/json']) 12902 12903 # Authentication setting 12904 auth_settings = [] 12905 12906 return self.api_client.call_api(resource_path, 'PUT', 12907 path_params, 12908 query_params, 12909 header_params, 12910 body=body_params, 12911 post_params=form_params, 12912 files=local_var_files, 12913 response_type='DocGenFormFieldResponse', 12914 auth_settings=auth_settings, 12915 callback=params.get('callback'), 12916 _return_http_data_only=params.get('_return_http_data_only'), 12917 _preload_content=params.get('_preload_content', True), 12918 _request_timeout=params.get('_request_timeout'), 12919 collection_formats=collection_formats) 12920 12921 def update_envelope_scheduled_sending_definition(self, account_id, envelope_id, **kwargs): 12922 """ 12923 Updates the scheduled sending rules for an envelope's workflow definition. 12924 This method makes a synchronous HTTP request by default. To make an 12925 asynchronous HTTP request, please define a `callback` function 12926 to be invoked when receiving the response. 12927 >>> def callback_function(response): 12928 >>> pprint(response) 12929 >>> 12930 >>> thread = api.update_envelope_scheduled_sending_definition(account_id, envelope_id, callback=callback_function) 12931 12932 :param callback function: The callback function 12933 for asynchronous request. (optional) 12934 :param str account_id: The external account number (int) or account ID Guid. (required) 12935 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12936 :param ScheduledSending scheduled_sending: 12937 :return: ScheduledSending 12938 If the method is called asynchronously, 12939 returns the request thread. 12940 """ 12941 kwargs['_return_http_data_only'] = True 12942 if kwargs.get('callback'): 12943 return self.update_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 12944 else: 12945 (data) = self.update_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 12946 return data 12947 12948 def update_envelope_scheduled_sending_definition_with_http_info(self, account_id, envelope_id, **kwargs): 12949 """ 12950 Updates the scheduled sending rules for an envelope's workflow definition. 12951 This method makes a synchronous HTTP request by default. To make an 12952 asynchronous HTTP request, please define a `callback` function 12953 to be invoked when receiving the response. 12954 >>> def callback_function(response): 12955 >>> pprint(response) 12956 >>> 12957 >>> thread = api.update_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, callback=callback_function) 12958 12959 :param callback function: The callback function 12960 for asynchronous request. (optional) 12961 :param str account_id: The external account number (int) or account ID Guid. (required) 12962 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12963 :param ScheduledSending scheduled_sending: 12964 :return: ScheduledSending 12965 If the method is called asynchronously, 12966 returns the request thread. 12967 """ 12968 12969 all_params = ['account_id', 'envelope_id', 'scheduled_sending'] 12970 all_params.append('callback') 12971 all_params.append('_return_http_data_only') 12972 all_params.append('_preload_content') 12973 all_params.append('_request_timeout') 12974 12975 params = locals() 12976 for key, val in iteritems(params['kwargs']): 12977 if key not in all_params: 12978 raise TypeError( 12979 "Got an unexpected keyword argument '%s'" 12980 " to method update_envelope_scheduled_sending_definition" % key 12981 ) 12982 params[key] = val 12983 del params['kwargs'] 12984 # verify the required parameter 'account_id' is set 12985 if ('account_id' not in params) or (params['account_id'] is None): 12986 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_scheduled_sending_definition`") 12987 # verify the required parameter 'envelope_id' is set 12988 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12989 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_scheduled_sending_definition`") 12990 12991 12992 collection_formats = {} 12993 12994 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/scheduledSending'.replace('{format}', 'json') 12995 path_params = {} 12996 if 'account_id' in params: 12997 path_params['accountId'] = params['account_id'] 12998 if 'envelope_id' in params: 12999 path_params['envelopeId'] = params['envelope_id'] 13000 13001 query_params = {} 13002 13003 header_params = {} 13004 13005 form_params = [] 13006 local_var_files = {} 13007 13008 body_params = None 13009 if 'scheduled_sending' in params: 13010 body_params = params['scheduled_sending'] 13011 # HTTP header `Accept` 13012 header_params['Accept'] = self.api_client.\ 13013 select_header_accept(['application/json']) 13014 13015 # Authentication setting 13016 auth_settings = [] 13017 13018 return self.api_client.call_api(resource_path, 'PUT', 13019 path_params, 13020 query_params, 13021 header_params, 13022 body=body_params, 13023 post_params=form_params, 13024 files=local_var_files, 13025 response_type='ScheduledSending', 13026 auth_settings=auth_settings, 13027 callback=params.get('callback'), 13028 _return_http_data_only=params.get('_return_http_data_only'), 13029 _preload_content=params.get('_preload_content', True), 13030 _request_timeout=params.get('_request_timeout'), 13031 collection_formats=collection_formats) 13032 13033 def update_envelope_transfer_rule(self, account_id, envelope_transfer_rule_id, **kwargs): 13034 """ 13035 Update an envelope transfer rule for an account. 13036 This method changes the status of an envelope transfer rule. You use this method to change whether or not the rule is enabled. You must include the `envelopeTransferRuleId` both as a query parameter, and in the request body. **Note:** You cannot change any other information about the envelope transfer rule. Only Administrators can update an envelope transfer rule. In addition, to use envelope transfer rules, the **Transfer Custody** feature must be enabled for your account. 13037 This method makes a synchronous HTTP request by default. To make an 13038 asynchronous HTTP request, please define a `callback` function 13039 to be invoked when receiving the response. 13040 >>> def callback_function(response): 13041 >>> pprint(response) 13042 >>> 13043 >>> thread = api.update_envelope_transfer_rule(account_id, envelope_transfer_rule_id, callback=callback_function) 13044 13045 :param callback function: The callback function 13046 for asynchronous request. (optional) 13047 :param str account_id: The external account number (int) or account ID Guid. (required) 13048 :param str envelope_transfer_rule_id: (required) 13049 :param EnvelopeTransferRule envelope_transfer_rule: 13050 :return: EnvelopeTransferRule 13051 If the method is called asynchronously, 13052 returns the request thread. 13053 """ 13054 kwargs['_return_http_data_only'] = True 13055 if kwargs.get('callback'): 13056 return self.update_envelope_transfer_rule_with_http_info(account_id, envelope_transfer_rule_id, **kwargs) 13057 else: 13058 (data) = self.update_envelope_transfer_rule_with_http_info(account_id, envelope_transfer_rule_id, **kwargs) 13059 return data 13060 13061 def update_envelope_transfer_rule_with_http_info(self, account_id, envelope_transfer_rule_id, **kwargs): 13062 """ 13063 Update an envelope transfer rule for an account. 13064 This method changes the status of an envelope transfer rule. You use this method to change whether or not the rule is enabled. You must include the `envelopeTransferRuleId` both as a query parameter, and in the request body. **Note:** You cannot change any other information about the envelope transfer rule. Only Administrators can update an envelope transfer rule. In addition, to use envelope transfer rules, the **Transfer Custody** feature must be enabled for your account. 13065 This method makes a synchronous HTTP request by default. To make an 13066 asynchronous HTTP request, please define a `callback` function 13067 to be invoked when receiving the response. 13068 >>> def callback_function(response): 13069 >>> pprint(response) 13070 >>> 13071 >>> thread = api.update_envelope_transfer_rule_with_http_info(account_id, envelope_transfer_rule_id, callback=callback_function) 13072 13073 :param callback function: The callback function 13074 for asynchronous request. (optional) 13075 :param str account_id: The external account number (int) or account ID Guid. (required) 13076 :param str envelope_transfer_rule_id: (required) 13077 :param EnvelopeTransferRule envelope_transfer_rule: 13078 :return: EnvelopeTransferRule 13079 If the method is called asynchronously, 13080 returns the request thread. 13081 """ 13082 13083 all_params = ['account_id', 'envelope_transfer_rule_id', 'envelope_transfer_rule'] 13084 all_params.append('callback') 13085 all_params.append('_return_http_data_only') 13086 all_params.append('_preload_content') 13087 all_params.append('_request_timeout') 13088 13089 params = locals() 13090 for key, val in iteritems(params['kwargs']): 13091 if key not in all_params: 13092 raise TypeError( 13093 "Got an unexpected keyword argument '%s'" 13094 " to method update_envelope_transfer_rule" % key 13095 ) 13096 params[key] = val 13097 del params['kwargs'] 13098 # verify the required parameter 'account_id' is set 13099 if ('account_id' not in params) or (params['account_id'] is None): 13100 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_transfer_rule`") 13101 # verify the required parameter 'envelope_transfer_rule_id' is set 13102 if ('envelope_transfer_rule_id' not in params) or (params['envelope_transfer_rule_id'] is None): 13103 raise ValueError("Missing the required parameter `envelope_transfer_rule_id` when calling `update_envelope_transfer_rule`") 13104 13105 13106 collection_formats = {} 13107 13108 resource_path = '/v2.1/accounts/{accountId}/envelopes/transfer_rules/{envelopeTransferRuleId}'.replace('{format}', 'json') 13109 path_params = {} 13110 if 'account_id' in params: 13111 path_params['accountId'] = params['account_id'] 13112 if 'envelope_transfer_rule_id' in params: 13113 path_params['envelopeTransferRuleId'] = params['envelope_transfer_rule_id'] 13114 13115 query_params = {} 13116 13117 header_params = {} 13118 13119 form_params = [] 13120 local_var_files = {} 13121 13122 body_params = None 13123 if 'envelope_transfer_rule' in params: 13124 body_params = params['envelope_transfer_rule'] 13125 # HTTP header `Accept` 13126 header_params['Accept'] = self.api_client.\ 13127 select_header_accept(['application/json']) 13128 13129 # Authentication setting 13130 auth_settings = [] 13131 13132 return self.api_client.call_api(resource_path, 'PUT', 13133 path_params, 13134 query_params, 13135 header_params, 13136 body=body_params, 13137 post_params=form_params, 13138 files=local_var_files, 13139 response_type='EnvelopeTransferRule', 13140 auth_settings=auth_settings, 13141 callback=params.get('callback'), 13142 _return_http_data_only=params.get('_return_http_data_only'), 13143 _preload_content=params.get('_preload_content', True), 13144 _request_timeout=params.get('_request_timeout'), 13145 collection_formats=collection_formats) 13146 13147 def update_envelope_transfer_rules(self, account_id, **kwargs): 13148 """ 13149 Update envelope transfer rules for an account. 13150 This method changes the status for one or more envelope transfer rules based on the `envelopeTransferRuleId`s in the request body. You use this method to change whether or not the rules are enabled. **Note:** You cannot change any other information about the envelope transfer rule. Only Administrators can update envelope transfer rules. In addition, to use envelope transfer rules, the **Transfer Custody** feature must be enabled for your account. 13151 This method makes a synchronous HTTP request by default. To make an 13152 asynchronous HTTP request, please define a `callback` function 13153 to be invoked when receiving the response. 13154 >>> def callback_function(response): 13155 >>> pprint(response) 13156 >>> 13157 >>> thread = api.update_envelope_transfer_rules(account_id, callback=callback_function) 13158 13159 :param callback function: The callback function 13160 for asynchronous request. (optional) 13161 :param str account_id: The external account number (int) or account ID Guid. (required) 13162 :param EnvelopeTransferRuleInformation envelope_transfer_rule_information: 13163 :return: EnvelopeTransferRuleInformation 13164 If the method is called asynchronously, 13165 returns the request thread. 13166 """ 13167 kwargs['_return_http_data_only'] = True 13168 if kwargs.get('callback'): 13169 return self.update_envelope_transfer_rules_with_http_info(account_id, **kwargs) 13170 else: 13171 (data) = self.update_envelope_transfer_rules_with_http_info(account_id, **kwargs) 13172 return data 13173 13174 def update_envelope_transfer_rules_with_http_info(self, account_id, **kwargs): 13175 """ 13176 Update envelope transfer rules for an account. 13177 This method changes the status for one or more envelope transfer rules based on the `envelopeTransferRuleId`s in the request body. You use this method to change whether or not the rules are enabled. **Note:** You cannot change any other information about the envelope transfer rule. Only Administrators can update envelope transfer rules. In addition, to use envelope transfer rules, the **Transfer Custody** feature must be enabled for your account. 13178 This method makes a synchronous HTTP request by default. To make an 13179 asynchronous HTTP request, please define a `callback` function 13180 to be invoked when receiving the response. 13181 >>> def callback_function(response): 13182 >>> pprint(response) 13183 >>> 13184 >>> thread = api.update_envelope_transfer_rules_with_http_info(account_id, callback=callback_function) 13185 13186 :param callback function: The callback function 13187 for asynchronous request. (optional) 13188 :param str account_id: The external account number (int) or account ID Guid. (required) 13189 :param EnvelopeTransferRuleInformation envelope_transfer_rule_information: 13190 :return: EnvelopeTransferRuleInformation 13191 If the method is called asynchronously, 13192 returns the request thread. 13193 """ 13194 13195 all_params = ['account_id', 'envelope_transfer_rule_information'] 13196 all_params.append('callback') 13197 all_params.append('_return_http_data_only') 13198 all_params.append('_preload_content') 13199 all_params.append('_request_timeout') 13200 13201 params = locals() 13202 for key, val in iteritems(params['kwargs']): 13203 if key not in all_params: 13204 raise TypeError( 13205 "Got an unexpected keyword argument '%s'" 13206 " to method update_envelope_transfer_rules" % key 13207 ) 13208 params[key] = val 13209 del params['kwargs'] 13210 # verify the required parameter 'account_id' is set 13211 if ('account_id' not in params) or (params['account_id'] is None): 13212 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_transfer_rules`") 13213 13214 13215 collection_formats = {} 13216 13217 resource_path = '/v2.1/accounts/{accountId}/envelopes/transfer_rules'.replace('{format}', 'json') 13218 path_params = {} 13219 if 'account_id' in params: 13220 path_params['accountId'] = params['account_id'] 13221 13222 query_params = {} 13223 13224 header_params = {} 13225 13226 form_params = [] 13227 local_var_files = {} 13228 13229 body_params = None 13230 if 'envelope_transfer_rule_information' in params: 13231 body_params = params['envelope_transfer_rule_information'] 13232 # HTTP header `Accept` 13233 header_params['Accept'] = self.api_client.\ 13234 select_header_accept(['application/json']) 13235 13236 # Authentication setting 13237 auth_settings = [] 13238 13239 return self.api_client.call_api(resource_path, 'PUT', 13240 path_params, 13241 query_params, 13242 header_params, 13243 body=body_params, 13244 post_params=form_params, 13245 files=local_var_files, 13246 response_type='EnvelopeTransferRuleInformation', 13247 auth_settings=auth_settings, 13248 callback=params.get('callback'), 13249 _return_http_data_only=params.get('_return_http_data_only'), 13250 _preload_content=params.get('_preload_content', True), 13251 _request_timeout=params.get('_request_timeout'), 13252 collection_formats=collection_formats) 13253 13254 def update_envelope_workflow_definition(self, account_id, envelope_id, **kwargs): 13255 """ 13256 Updates the envelope workflow definition for an envelope. 13257 Updates the specified envelope's workflow definition if it has one. 13258 This method makes a synchronous HTTP request by default. To make an 13259 asynchronous HTTP request, please define a `callback` function 13260 to be invoked when receiving the response. 13261 >>> def callback_function(response): 13262 >>> pprint(response) 13263 >>> 13264 >>> thread = api.update_envelope_workflow_definition(account_id, envelope_id, callback=callback_function) 13265 13266 :param callback function: The callback function 13267 for asynchronous request. (optional) 13268 :param str account_id: The external account number (int) or account ID Guid. (required) 13269 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13270 :param Workflow workflow: 13271 :return: Workflow 13272 If the method is called asynchronously, 13273 returns the request thread. 13274 """ 13275 kwargs['_return_http_data_only'] = True 13276 if kwargs.get('callback'): 13277 return self.update_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 13278 else: 13279 (data) = self.update_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 13280 return data 13281 13282 def update_envelope_workflow_definition_with_http_info(self, account_id, envelope_id, **kwargs): 13283 """ 13284 Updates the envelope workflow definition for an envelope. 13285 Updates the specified envelope's workflow definition if it has one. 13286 This method makes a synchronous HTTP request by default. To make an 13287 asynchronous HTTP request, please define a `callback` function 13288 to be invoked when receiving the response. 13289 >>> def callback_function(response): 13290 >>> pprint(response) 13291 >>> 13292 >>> thread = api.update_envelope_workflow_definition_with_http_info(account_id, envelope_id, callback=callback_function) 13293 13294 :param callback function: The callback function 13295 for asynchronous request. (optional) 13296 :param str account_id: The external account number (int) or account ID Guid. (required) 13297 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13298 :param Workflow workflow: 13299 :return: Workflow 13300 If the method is called asynchronously, 13301 returns the request thread. 13302 """ 13303 13304 all_params = ['account_id', 'envelope_id', 'workflow'] 13305 all_params.append('callback') 13306 all_params.append('_return_http_data_only') 13307 all_params.append('_preload_content') 13308 all_params.append('_request_timeout') 13309 13310 params = locals() 13311 for key, val in iteritems(params['kwargs']): 13312 if key not in all_params: 13313 raise TypeError( 13314 "Got an unexpected keyword argument '%s'" 13315 " to method update_envelope_workflow_definition" % key 13316 ) 13317 params[key] = val 13318 del params['kwargs'] 13319 # verify the required parameter 'account_id' is set 13320 if ('account_id' not in params) or (params['account_id'] is None): 13321 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_workflow_definition`") 13322 # verify the required parameter 'envelope_id' is set 13323 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13324 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_workflow_definition`") 13325 13326 13327 collection_formats = {} 13328 13329 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow'.replace('{format}', 'json') 13330 path_params = {} 13331 if 'account_id' in params: 13332 path_params['accountId'] = params['account_id'] 13333 if 'envelope_id' in params: 13334 path_params['envelopeId'] = params['envelope_id'] 13335 13336 query_params = {} 13337 13338 header_params = {} 13339 13340 form_params = [] 13341 local_var_files = {} 13342 13343 body_params = None 13344 if 'workflow' in params: 13345 body_params = params['workflow'] 13346 # HTTP header `Accept` 13347 header_params['Accept'] = self.api_client.\ 13348 select_header_accept(['application/json']) 13349 13350 # Authentication setting 13351 auth_settings = [] 13352 13353 return self.api_client.call_api(resource_path, 'PUT', 13354 path_params, 13355 query_params, 13356 header_params, 13357 body=body_params, 13358 post_params=form_params, 13359 files=local_var_files, 13360 response_type='Workflow', 13361 auth_settings=auth_settings, 13362 callback=params.get('callback'), 13363 _return_http_data_only=params.get('_return_http_data_only'), 13364 _preload_content=params.get('_preload_content', True), 13365 _request_timeout=params.get('_request_timeout'), 13366 collection_formats=collection_formats) 13367 13368 def update_envelope_workflow_step_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 13369 """ 13370 Updates the envelope workflow step definition for an envelope. 13371 This method makes a synchronous HTTP request by default. To make an 13372 asynchronous HTTP request, please define a `callback` function 13373 to be invoked when receiving the response. 13374 >>> def callback_function(response): 13375 >>> pprint(response) 13376 >>> 13377 >>> thread = api.update_envelope_workflow_step_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 13378 13379 :param callback function: The callback function 13380 for asynchronous request. (optional) 13381 :param str account_id: The external account number (int) or account ID Guid. (required) 13382 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13383 :param str workflow_step_id: (required) 13384 :param WorkflowStep workflow_step: 13385 :return: WorkflowStep 13386 If the method is called asynchronously, 13387 returns the request thread. 13388 """ 13389 kwargs['_return_http_data_only'] = True 13390 if kwargs.get('callback'): 13391 return self.update_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 13392 else: 13393 (data) = self.update_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 13394 return data 13395 13396 def update_envelope_workflow_step_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 13397 """ 13398 Updates the envelope workflow step definition for an envelope. 13399 This method makes a synchronous HTTP request by default. To make an 13400 asynchronous HTTP request, please define a `callback` function 13401 to be invoked when receiving the response. 13402 >>> def callback_function(response): 13403 >>> pprint(response) 13404 >>> 13405 >>> thread = api.update_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 13406 13407 :param callback function: The callback function 13408 for asynchronous request. (optional) 13409 :param str account_id: The external account number (int) or account ID Guid. (required) 13410 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13411 :param str workflow_step_id: (required) 13412 :param WorkflowStep workflow_step: 13413 :return: WorkflowStep 13414 If the method is called asynchronously, 13415 returns the request thread. 13416 """ 13417 13418 all_params = ['account_id', 'envelope_id', 'workflow_step_id', 'workflow_step'] 13419 all_params.append('callback') 13420 all_params.append('_return_http_data_only') 13421 all_params.append('_preload_content') 13422 all_params.append('_request_timeout') 13423 13424 params = locals() 13425 for key, val in iteritems(params['kwargs']): 13426 if key not in all_params: 13427 raise TypeError( 13428 "Got an unexpected keyword argument '%s'" 13429 " to method update_envelope_workflow_step_definition" % key 13430 ) 13431 params[key] = val 13432 del params['kwargs'] 13433 # verify the required parameter 'account_id' is set 13434 if ('account_id' not in params) or (params['account_id'] is None): 13435 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_workflow_step_definition`") 13436 # verify the required parameter 'envelope_id' is set 13437 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13438 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_workflow_step_definition`") 13439 # verify the required parameter 'workflow_step_id' is set 13440 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 13441 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_envelope_workflow_step_definition`") 13442 13443 13444 collection_formats = {} 13445 13446 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 13447 path_params = {} 13448 if 'account_id' in params: 13449 path_params['accountId'] = params['account_id'] 13450 if 'envelope_id' in params: 13451 path_params['envelopeId'] = params['envelope_id'] 13452 if 'workflow_step_id' in params: 13453 path_params['workflowStepId'] = params['workflow_step_id'] 13454 13455 query_params = {} 13456 13457 header_params = {} 13458 13459 form_params = [] 13460 local_var_files = {} 13461 13462 body_params = None 13463 if 'workflow_step' in params: 13464 body_params = params['workflow_step'] 13465 # HTTP header `Accept` 13466 header_params['Accept'] = self.api_client.\ 13467 select_header_accept(['application/json']) 13468 13469 # Authentication setting 13470 auth_settings = [] 13471 13472 return self.api_client.call_api(resource_path, 'PUT', 13473 path_params, 13474 query_params, 13475 header_params, 13476 body=body_params, 13477 post_params=form_params, 13478 files=local_var_files, 13479 response_type='WorkflowStep', 13480 auth_settings=auth_settings, 13481 callback=params.get('callback'), 13482 _return_http_data_only=params.get('_return_http_data_only'), 13483 _preload_content=params.get('_preload_content', True), 13484 _request_timeout=params.get('_request_timeout'), 13485 collection_formats=collection_formats) 13486 13487 def update_lock(self, account_id, envelope_id, **kwargs): 13488 """ 13489 Updates an envelope lock. 13490 Updates the lock duration time or update the `lockedByApp` property information for the specified envelope. The user and integrator key must match the user specified by the `lockByUser` property and integrator key information and the `X-DocuSign-Edit` header must be included or an error will be generated. 13491 This method makes a synchronous HTTP request by default. To make an 13492 asynchronous HTTP request, please define a `callback` function 13493 to be invoked when receiving the response. 13494 >>> def callback_function(response): 13495 >>> pprint(response) 13496 >>> 13497 >>> thread = api.update_lock(account_id, envelope_id, callback=callback_function) 13498 13499 :param callback function: The callback function 13500 for asynchronous request. (optional) 13501 :param str account_id: The external account number (int) or account ID Guid. (required) 13502 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13503 :param LockRequest lock_request: 13504 :return: LockInformation 13505 If the method is called asynchronously, 13506 returns the request thread. 13507 """ 13508 kwargs['_return_http_data_only'] = True 13509 if kwargs.get('callback'): 13510 return self.update_lock_with_http_info(account_id, envelope_id, **kwargs) 13511 else: 13512 (data) = self.update_lock_with_http_info(account_id, envelope_id, **kwargs) 13513 return data 13514 13515 def update_lock_with_http_info(self, account_id, envelope_id, **kwargs): 13516 """ 13517 Updates an envelope lock. 13518 Updates the lock duration time or update the `lockedByApp` property information for the specified envelope. The user and integrator key must match the user specified by the `lockByUser` property and integrator key information and the `X-DocuSign-Edit` header must be included or an error will be generated. 13519 This method makes a synchronous HTTP request by default. To make an 13520 asynchronous HTTP request, please define a `callback` function 13521 to be invoked when receiving the response. 13522 >>> def callback_function(response): 13523 >>> pprint(response) 13524 >>> 13525 >>> thread = api.update_lock_with_http_info(account_id, envelope_id, callback=callback_function) 13526 13527 :param callback function: The callback function 13528 for asynchronous request. (optional) 13529 :param str account_id: The external account number (int) or account ID Guid. (required) 13530 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13531 :param LockRequest lock_request: 13532 :return: LockInformation 13533 If the method is called asynchronously, 13534 returns the request thread. 13535 """ 13536 13537 all_params = ['account_id', 'envelope_id', 'lock_request'] 13538 all_params.append('callback') 13539 all_params.append('_return_http_data_only') 13540 all_params.append('_preload_content') 13541 all_params.append('_request_timeout') 13542 13543 params = locals() 13544 for key, val in iteritems(params['kwargs']): 13545 if key not in all_params: 13546 raise TypeError( 13547 "Got an unexpected keyword argument '%s'" 13548 " to method update_lock" % key 13549 ) 13550 params[key] = val 13551 del params['kwargs'] 13552 # verify the required parameter 'account_id' is set 13553 if ('account_id' not in params) or (params['account_id'] is None): 13554 raise ValueError("Missing the required parameter `account_id` when calling `update_lock`") 13555 # verify the required parameter 'envelope_id' is set 13556 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13557 raise ValueError("Missing the required parameter `envelope_id` when calling `update_lock`") 13558 13559 13560 collection_formats = {} 13561 13562 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/lock'.replace('{format}', 'json') 13563 path_params = {} 13564 if 'account_id' in params: 13565 path_params['accountId'] = params['account_id'] 13566 if 'envelope_id' in params: 13567 path_params['envelopeId'] = params['envelope_id'] 13568 13569 query_params = {} 13570 13571 header_params = {} 13572 13573 form_params = [] 13574 local_var_files = {} 13575 13576 body_params = None 13577 if 'lock_request' in params: 13578 body_params = params['lock_request'] 13579 # HTTP header `Accept` 13580 header_params['Accept'] = self.api_client.\ 13581 select_header_accept(['application/json']) 13582 13583 # Authentication setting 13584 auth_settings = [] 13585 13586 return self.api_client.call_api(resource_path, 'PUT', 13587 path_params, 13588 query_params, 13589 header_params, 13590 body=body_params, 13591 post_params=form_params, 13592 files=local_var_files, 13593 response_type='LockInformation', 13594 auth_settings=auth_settings, 13595 callback=params.get('callback'), 13596 _return_http_data_only=params.get('_return_http_data_only'), 13597 _preload_content=params.get('_preload_content', True), 13598 _request_timeout=params.get('_request_timeout'), 13599 collection_formats=collection_formats) 13600 13601 def update_notification_settings(self, account_id, envelope_id, **kwargs): 13602 """ 13603 Sets envelope notification (Reminders/Expirations) structure for an existing envelope. 13604 This method sets the notifications (reminders and expirations) for an existing envelope. The request body sends a structure containing reminders and expirations settings. It also specifies whether to use the settings specified in the request, or the account default notification settings for the envelope. Note that this request only specifies when notifications are sent; it does not initiate sending of email messages. 13605 This method makes a synchronous HTTP request by default. To make an 13606 asynchronous HTTP request, please define a `callback` function 13607 to be invoked when receiving the response. 13608 >>> def callback_function(response): 13609 >>> pprint(response) 13610 >>> 13611 >>> thread = api.update_notification_settings(account_id, envelope_id, callback=callback_function) 13612 13613 :param callback function: The callback function 13614 for asynchronous request. (optional) 13615 :param str account_id: The external account number (int) or account ID Guid. (required) 13616 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13617 :param EnvelopeNotificationRequest envelope_notification_request: 13618 :return: Notification 13619 If the method is called asynchronously, 13620 returns the request thread. 13621 """ 13622 kwargs['_return_http_data_only'] = True 13623 if kwargs.get('callback'): 13624 return self.update_notification_settings_with_http_info(account_id, envelope_id, **kwargs) 13625 else: 13626 (data) = self.update_notification_settings_with_http_info(account_id, envelope_id, **kwargs) 13627 return data 13628 13629 def update_notification_settings_with_http_info(self, account_id, envelope_id, **kwargs): 13630 """ 13631 Sets envelope notification (Reminders/Expirations) structure for an existing envelope. 13632 This method sets the notifications (reminders and expirations) for an existing envelope. The request body sends a structure containing reminders and expirations settings. It also specifies whether to use the settings specified in the request, or the account default notification settings for the envelope. Note that this request only specifies when notifications are sent; it does not initiate sending of email messages. 13633 This method makes a synchronous HTTP request by default. To make an 13634 asynchronous HTTP request, please define a `callback` function 13635 to be invoked when receiving the response. 13636 >>> def callback_function(response): 13637 >>> pprint(response) 13638 >>> 13639 >>> thread = api.update_notification_settings_with_http_info(account_id, envelope_id, callback=callback_function) 13640 13641 :param callback function: The callback function 13642 for asynchronous request. (optional) 13643 :param str account_id: The external account number (int) or account ID Guid. (required) 13644 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13645 :param EnvelopeNotificationRequest envelope_notification_request: 13646 :return: Notification 13647 If the method is called asynchronously, 13648 returns the request thread. 13649 """ 13650 13651 all_params = ['account_id', 'envelope_id', 'envelope_notification_request'] 13652 all_params.append('callback') 13653 all_params.append('_return_http_data_only') 13654 all_params.append('_preload_content') 13655 all_params.append('_request_timeout') 13656 13657 params = locals() 13658 for key, val in iteritems(params['kwargs']): 13659 if key not in all_params: 13660 raise TypeError( 13661 "Got an unexpected keyword argument '%s'" 13662 " to method update_notification_settings" % key 13663 ) 13664 params[key] = val 13665 del params['kwargs'] 13666 # verify the required parameter 'account_id' is set 13667 if ('account_id' not in params) or (params['account_id'] is None): 13668 raise ValueError("Missing the required parameter `account_id` when calling `update_notification_settings`") 13669 # verify the required parameter 'envelope_id' is set 13670 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13671 raise ValueError("Missing the required parameter `envelope_id` when calling `update_notification_settings`") 13672 13673 13674 collection_formats = {} 13675 13676 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/notification'.replace('{format}', 'json') 13677 path_params = {} 13678 if 'account_id' in params: 13679 path_params['accountId'] = params['account_id'] 13680 if 'envelope_id' in params: 13681 path_params['envelopeId'] = params['envelope_id'] 13682 13683 query_params = {} 13684 13685 header_params = {} 13686 13687 form_params = [] 13688 local_var_files = {} 13689 13690 body_params = None 13691 if 'envelope_notification_request' in params: 13692 body_params = params['envelope_notification_request'] 13693 # HTTP header `Accept` 13694 header_params['Accept'] = self.api_client.\ 13695 select_header_accept(['application/json']) 13696 13697 # Authentication setting 13698 auth_settings = [] 13699 13700 return self.api_client.call_api(resource_path, 'PUT', 13701 path_params, 13702 query_params, 13703 header_params, 13704 body=body_params, 13705 post_params=form_params, 13706 files=local_var_files, 13707 response_type='Notification', 13708 auth_settings=auth_settings, 13709 callback=params.get('callback'), 13710 _return_http_data_only=params.get('_return_http_data_only'), 13711 _preload_content=params.get('_preload_content', True), 13712 _request_timeout=params.get('_request_timeout'), 13713 collection_formats=collection_formats) 13714 13715 def update_recipient_document_visibility(self, account_id, envelope_id, recipient_id, **kwargs): 13716 """ 13717 Updates document visibility for the recipients 13718 This method updates document visibility for a recipient. **Note:** A document cannot be hidden from a recipient if the recipient has tabs assigned to them on the document. Carbon Copy, Certified Delivery (Needs to Sign), Editor, and Agent recipients can always see all documents. 13719 This method makes a synchronous HTTP request by default. To make an 13720 asynchronous HTTP request, please define a `callback` function 13721 to be invoked when receiving the response. 13722 >>> def callback_function(response): 13723 >>> pprint(response) 13724 >>> 13725 >>> thread = api.update_recipient_document_visibility(account_id, envelope_id, recipient_id, callback=callback_function) 13726 13727 :param callback function: The callback function 13728 for asynchronous request. (optional) 13729 :param str account_id: The external account number (int) or account ID Guid. (required) 13730 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13731 :param str recipient_id: The ID of the recipient being accessed. (required) 13732 :param DocumentVisibilityList document_visibility_list: 13733 :return: DocumentVisibilityList 13734 If the method is called asynchronously, 13735 returns the request thread. 13736 """ 13737 kwargs['_return_http_data_only'] = True 13738 if kwargs.get('callback'): 13739 return self.update_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13740 else: 13741 (data) = self.update_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13742 return data 13743 13744 def update_recipient_document_visibility_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 13745 """ 13746 Updates document visibility for the recipients 13747 This method updates document visibility for a recipient. **Note:** A document cannot be hidden from a recipient if the recipient has tabs assigned to them on the document. Carbon Copy, Certified Delivery (Needs to Sign), Editor, and Agent recipients can always see all documents. 13748 This method makes a synchronous HTTP request by default. To make an 13749 asynchronous HTTP request, please define a `callback` function 13750 to be invoked when receiving the response. 13751 >>> def callback_function(response): 13752 >>> pprint(response) 13753 >>> 13754 >>> thread = api.update_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 13755 13756 :param callback function: The callback function 13757 for asynchronous request. (optional) 13758 :param str account_id: The external account number (int) or account ID Guid. (required) 13759 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13760 :param str recipient_id: The ID of the recipient being accessed. (required) 13761 :param DocumentVisibilityList document_visibility_list: 13762 :return: DocumentVisibilityList 13763 If the method is called asynchronously, 13764 returns the request thread. 13765 """ 13766 13767 all_params = ['account_id', 'envelope_id', 'recipient_id', 'document_visibility_list'] 13768 all_params.append('callback') 13769 all_params.append('_return_http_data_only') 13770 all_params.append('_preload_content') 13771 all_params.append('_request_timeout') 13772 13773 params = locals() 13774 for key, val in iteritems(params['kwargs']): 13775 if key not in all_params: 13776 raise TypeError( 13777 "Got an unexpected keyword argument '%s'" 13778 " to method update_recipient_document_visibility" % key 13779 ) 13780 params[key] = val 13781 del params['kwargs'] 13782 # verify the required parameter 'account_id' is set 13783 if ('account_id' not in params) or (params['account_id'] is None): 13784 raise ValueError("Missing the required parameter `account_id` when calling `update_recipient_document_visibility`") 13785 # verify the required parameter 'envelope_id' is set 13786 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13787 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipient_document_visibility`") 13788 # verify the required parameter 'recipient_id' is set 13789 if ('recipient_id' not in params) or (params['recipient_id'] is None): 13790 raise ValueError("Missing the required parameter `recipient_id` when calling `update_recipient_document_visibility`") 13791 13792 13793 collection_formats = {} 13794 13795 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/document_visibility'.replace('{format}', 'json') 13796 path_params = {} 13797 if 'account_id' in params: 13798 path_params['accountId'] = params['account_id'] 13799 if 'envelope_id' in params: 13800 path_params['envelopeId'] = params['envelope_id'] 13801 if 'recipient_id' in params: 13802 path_params['recipientId'] = params['recipient_id'] 13803 13804 query_params = {} 13805 13806 header_params = {} 13807 13808 form_params = [] 13809 local_var_files = {} 13810 13811 body_params = None 13812 if 'document_visibility_list' in params: 13813 body_params = params['document_visibility_list'] 13814 # HTTP header `Accept` 13815 header_params['Accept'] = self.api_client.\ 13816 select_header_accept(['application/json']) 13817 13818 # Authentication setting 13819 auth_settings = [] 13820 13821 return self.api_client.call_api(resource_path, 'PUT', 13822 path_params, 13823 query_params, 13824 header_params, 13825 body=body_params, 13826 post_params=form_params, 13827 files=local_var_files, 13828 response_type='DocumentVisibilityList', 13829 auth_settings=auth_settings, 13830 callback=params.get('callback'), 13831 _return_http_data_only=params.get('_return_http_data_only'), 13832 _preload_content=params.get('_preload_content', True), 13833 _request_timeout=params.get('_request_timeout'), 13834 collection_formats=collection_formats) 13835 13836 def update_recipient_initials_image(self, account_id, envelope_id, recipient_id, **kwargs): 13837 """ 13838 Sets the initials image for an accountless signer. 13839 Updates the initials image for a signer that does not have a DocuSign account. The supported image formats for this file are: gif, png, jpeg, and bmp. The file size must be less than 200K. For the Authentication/Authorization for this call, the credentials must match the sender of the envelope, the recipient must be an accountless signer or in person signer. The account must have the `CanSendEnvelope` property set to **true** and the `ExpressSendOnly` property in `SendingUser` structure must be set to **false**. 13840 This method makes a synchronous HTTP request by default. To make an 13841 asynchronous HTTP request, please define a `callback` function 13842 to be invoked when receiving the response. 13843 >>> def callback_function(response): 13844 >>> pprint(response) 13845 >>> 13846 >>> thread = api.update_recipient_initials_image(account_id, envelope_id, recipient_id, callback=callback_function) 13847 13848 :param callback function: The callback function 13849 for asynchronous request. (optional) 13850 :param str account_id: The external account number (int) or account ID Guid. (required) 13851 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13852 :param str recipient_id: The ID of the recipient being accessed. (required) 13853 :return: None 13854 If the method is called asynchronously, 13855 returns the request thread. 13856 """ 13857 kwargs['_return_http_data_only'] = True 13858 if kwargs.get('callback'): 13859 return self.update_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13860 else: 13861 (data) = self.update_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13862 return data 13863 13864 def update_recipient_initials_image_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 13865 """ 13866 Sets the initials image for an accountless signer. 13867 Updates the initials image for a signer that does not have a DocuSign account. The supported image formats for this file are: gif, png, jpeg, and bmp. The file size must be less than 200K. For the Authentication/Authorization for this call, the credentials must match the sender of the envelope, the recipient must be an accountless signer or in person signer. The account must have the `CanSendEnvelope` property set to **true** and the `ExpressSendOnly` property in `SendingUser` structure must be set to **false**. 13868 This method makes a synchronous HTTP request by default. To make an 13869 asynchronous HTTP request, please define a `callback` function 13870 to be invoked when receiving the response. 13871 >>> def callback_function(response): 13872 >>> pprint(response) 13873 >>> 13874 >>> thread = api.update_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 13875 13876 :param callback function: The callback function 13877 for asynchronous request. (optional) 13878 :param str account_id: The external account number (int) or account ID Guid. (required) 13879 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13880 :param str recipient_id: The ID of the recipient being accessed. (required) 13881 :return: None 13882 If the method is called asynchronously, 13883 returns the request thread. 13884 """ 13885 13886 all_params = ['account_id', 'envelope_id', 'recipient_id'] 13887 all_params.append('callback') 13888 all_params.append('_return_http_data_only') 13889 all_params.append('_preload_content') 13890 all_params.append('_request_timeout') 13891 13892 params = locals() 13893 for key, val in iteritems(params['kwargs']): 13894 if key not in all_params: 13895 raise TypeError( 13896 "Got an unexpected keyword argument '%s'" 13897 " to method update_recipient_initials_image" % key 13898 ) 13899 params[key] = val 13900 del params['kwargs'] 13901 # verify the required parameter 'account_id' is set 13902 if ('account_id' not in params) or (params['account_id'] is None): 13903 raise ValueError("Missing the required parameter `account_id` when calling `update_recipient_initials_image`") 13904 # verify the required parameter 'envelope_id' is set 13905 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13906 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipient_initials_image`") 13907 # verify the required parameter 'recipient_id' is set 13908 if ('recipient_id' not in params) or (params['recipient_id'] is None): 13909 raise ValueError("Missing the required parameter `recipient_id` when calling `update_recipient_initials_image`") 13910 13911 13912 collection_formats = {} 13913 13914 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/initials_image'.replace('{format}', 'json') 13915 path_params = {} 13916 if 'account_id' in params: 13917 path_params['accountId'] = params['account_id'] 13918 if 'envelope_id' in params: 13919 path_params['envelopeId'] = params['envelope_id'] 13920 if 'recipient_id' in params: 13921 path_params['recipientId'] = params['recipient_id'] 13922 13923 query_params = {} 13924 13925 header_params = {} 13926 13927 form_params = [] 13928 local_var_files = {} 13929 13930 body_params = None 13931 # HTTP header `Accept` 13932 header_params['Accept'] = self.api_client.\ 13933 select_header_accept(['application/json']) 13934 13935 # HTTP header `Content-Type` 13936 header_params['Content-Type'] = self.api_client.\ 13937 select_header_content_type(['image/gif']) 13938 13939 # Authentication setting 13940 auth_settings = [] 13941 13942 return self.api_client.call_api(resource_path, 'PUT', 13943 path_params, 13944 query_params, 13945 header_params, 13946 body=body_params, 13947 post_params=form_params, 13948 files=local_var_files, 13949 response_type=None, 13950 auth_settings=auth_settings, 13951 callback=params.get('callback'), 13952 _return_http_data_only=params.get('_return_http_data_only'), 13953 _preload_content=params.get('_preload_content', True), 13954 _request_timeout=params.get('_request_timeout'), 13955 collection_formats=collection_formats) 13956 13957 def update_recipient_signature_image(self, account_id, envelope_id, recipient_id, **kwargs): 13958 """ 13959 Sets the signature image for an accountless signer. 13960 Updates the signature image for an accountless signer. The supported image formats for this file are: gif, png, jpeg, and bmp. The file size must be less than 200K. For the Authentication/Authorization for this call, the credentials must match the sender of the envelope, the recipient must be an accountless signer or in person signer. The account must have the `CanSendEnvelope` property set to **true** and the `ExpressSendOnly` property in `SendingUser` structure must be set to **false**. 13961 This method makes a synchronous HTTP request by default. To make an 13962 asynchronous HTTP request, please define a `callback` function 13963 to be invoked when receiving the response. 13964 >>> def callback_function(response): 13965 >>> pprint(response) 13966 >>> 13967 >>> thread = api.update_recipient_signature_image(account_id, envelope_id, recipient_id, callback=callback_function) 13968 13969 :param callback function: The callback function 13970 for asynchronous request. (optional) 13971 :param str account_id: The external account number (int) or account ID Guid. (required) 13972 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13973 :param str recipient_id: The ID of the recipient being accessed. (required) 13974 :return: None 13975 If the method is called asynchronously, 13976 returns the request thread. 13977 """ 13978 kwargs['_return_http_data_only'] = True 13979 if kwargs.get('callback'): 13980 return self.update_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13981 else: 13982 (data) = self.update_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13983 return data 13984 13985 def update_recipient_signature_image_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 13986 """ 13987 Sets the signature image for an accountless signer. 13988 Updates the signature image for an accountless signer. The supported image formats for this file are: gif, png, jpeg, and bmp. The file size must be less than 200K. For the Authentication/Authorization for this call, the credentials must match the sender of the envelope, the recipient must be an accountless signer or in person signer. The account must have the `CanSendEnvelope` property set to **true** and the `ExpressSendOnly` property in `SendingUser` structure must be set to **false**. 13989 This method makes a synchronous HTTP request by default. To make an 13990 asynchronous HTTP request, please define a `callback` function 13991 to be invoked when receiving the response. 13992 >>> def callback_function(response): 13993 >>> pprint(response) 13994 >>> 13995 >>> thread = api.update_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 13996 13997 :param callback function: The callback function 13998 for asynchronous request. (optional) 13999 :param str account_id: The external account number (int) or account ID Guid. (required) 14000 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14001 :param str recipient_id: The ID of the recipient being accessed. (required) 14002 :return: None 14003 If the method is called asynchronously, 14004 returns the request thread. 14005 """ 14006 14007 all_params = ['account_id', 'envelope_id', 'recipient_id'] 14008 all_params.append('callback') 14009 all_params.append('_return_http_data_only') 14010 all_params.append('_preload_content') 14011 all_params.append('_request_timeout') 14012 14013 params = locals() 14014 for key, val in iteritems(params['kwargs']): 14015 if key not in all_params: 14016 raise TypeError( 14017 "Got an unexpected keyword argument '%s'" 14018 " to method update_recipient_signature_image" % key 14019 ) 14020 params[key] = val 14021 del params['kwargs'] 14022 # verify the required parameter 'account_id' is set 14023 if ('account_id' not in params) or (params['account_id'] is None): 14024 raise ValueError("Missing the required parameter `account_id` when calling `update_recipient_signature_image`") 14025 # verify the required parameter 'envelope_id' is set 14026 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14027 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipient_signature_image`") 14028 # verify the required parameter 'recipient_id' is set 14029 if ('recipient_id' not in params) or (params['recipient_id'] is None): 14030 raise ValueError("Missing the required parameter `recipient_id` when calling `update_recipient_signature_image`") 14031 14032 14033 collection_formats = {} 14034 14035 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/signature_image'.replace('{format}', 'json') 14036 path_params = {} 14037 if 'account_id' in params: 14038 path_params['accountId'] = params['account_id'] 14039 if 'envelope_id' in params: 14040 path_params['envelopeId'] = params['envelope_id'] 14041 if 'recipient_id' in params: 14042 path_params['recipientId'] = params['recipient_id'] 14043 14044 query_params = {} 14045 14046 header_params = {} 14047 14048 form_params = [] 14049 local_var_files = {} 14050 14051 body_params = None 14052 # HTTP header `Accept` 14053 header_params['Accept'] = self.api_client.\ 14054 select_header_accept(['application/json']) 14055 14056 # HTTP header `Content-Type` 14057 header_params['Content-Type'] = self.api_client.\ 14058 select_header_content_type(['image/gif']) 14059 14060 # Authentication setting 14061 auth_settings = [] 14062 14063 return self.api_client.call_api(resource_path, 'PUT', 14064 path_params, 14065 query_params, 14066 header_params, 14067 body=body_params, 14068 post_params=form_params, 14069 files=local_var_files, 14070 response_type=None, 14071 auth_settings=auth_settings, 14072 callback=params.get('callback'), 14073 _return_http_data_only=params.get('_return_http_data_only'), 14074 _preload_content=params.get('_preload_content', True), 14075 _request_timeout=params.get('_request_timeout'), 14076 collection_formats=collection_formats) 14077 14078 def update_recipients(self, account_id, envelope_id, **kwargs): 14079 """ 14080 Updates recipients in a draft envelope or corrects recipient information for an in process envelope. 14081 Updates recipients in a draft envelope or corrects recipient information for an in process envelope. For draft envelopes, you can edit the following properties: `email`, `userName`, `routingOrder`, `faxNumber`, `deliveryMethod`, `accessCode`, and `requireIdLookup`. Once an envelope has been sent, you can only edit: `email`, `userName`, `signerName`, `routingOrder`, `faxNumber`, and `deliveryMethod`. You can also select to resend an envelope by using the `resend_envelope` option. If you send information for a recipient that does not already exist in a draft envelope, the recipient is added to the envelope (similar to the POST). 14082 This method makes a synchronous HTTP request by default. To make an 14083 asynchronous HTTP request, please define a `callback` function 14084 to be invoked when receiving the response. 14085 >>> def callback_function(response): 14086 >>> pprint(response) 14087 >>> 14088 >>> thread = api.update_recipients(account_id, envelope_id, callback=callback_function) 14089 14090 :param callback function: The callback function 14091 for asynchronous request. (optional) 14092 :param str account_id: The external account number (int) or account ID Guid. (required) 14093 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14094 :param str combine_same_order_recipients: 14095 :param str offline_signing: 14096 :param str resend_envelope: When set to **true**, resends the envelope if the new recipient's routing order is before or the same as the envelope's next recipient. 14097 :param Recipients recipients: 14098 :return: RecipientsUpdateSummary 14099 If the method is called asynchronously, 14100 returns the request thread. 14101 """ 14102 kwargs['_return_http_data_only'] = True 14103 if kwargs.get('callback'): 14104 return self.update_recipients_with_http_info(account_id, envelope_id, **kwargs) 14105 else: 14106 (data) = self.update_recipients_with_http_info(account_id, envelope_id, **kwargs) 14107 return data 14108 14109 def update_recipients_with_http_info(self, account_id, envelope_id, **kwargs): 14110 """ 14111 Updates recipients in a draft envelope or corrects recipient information for an in process envelope. 14112 Updates recipients in a draft envelope or corrects recipient information for an in process envelope. For draft envelopes, you can edit the following properties: `email`, `userName`, `routingOrder`, `faxNumber`, `deliveryMethod`, `accessCode`, and `requireIdLookup`. Once an envelope has been sent, you can only edit: `email`, `userName`, `signerName`, `routingOrder`, `faxNumber`, and `deliveryMethod`. You can also select to resend an envelope by using the `resend_envelope` option. If you send information for a recipient that does not already exist in a draft envelope, the recipient is added to the envelope (similar to the POST). 14113 This method makes a synchronous HTTP request by default. To make an 14114 asynchronous HTTP request, please define a `callback` function 14115 to be invoked when receiving the response. 14116 >>> def callback_function(response): 14117 >>> pprint(response) 14118 >>> 14119 >>> thread = api.update_recipients_with_http_info(account_id, envelope_id, callback=callback_function) 14120 14121 :param callback function: The callback function 14122 for asynchronous request. (optional) 14123 :param str account_id: The external account number (int) or account ID Guid. (required) 14124 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14125 :param str combine_same_order_recipients: 14126 :param str offline_signing: 14127 :param str resend_envelope: When set to **true**, resends the envelope if the new recipient's routing order is before or the same as the envelope's next recipient. 14128 :param Recipients recipients: 14129 :return: RecipientsUpdateSummary 14130 If the method is called asynchronously, 14131 returns the request thread. 14132 """ 14133 14134 all_params = ['account_id', 'envelope_id', 'combine_same_order_recipients', 'offline_signing', 'resend_envelope', 'recipients'] 14135 all_params.append('callback') 14136 all_params.append('_return_http_data_only') 14137 all_params.append('_preload_content') 14138 all_params.append('_request_timeout') 14139 14140 params = locals() 14141 for key, val in iteritems(params['kwargs']): 14142 if key not in all_params: 14143 raise TypeError( 14144 "Got an unexpected keyword argument '%s'" 14145 " to method update_recipients" % key 14146 ) 14147 params[key] = val 14148 del params['kwargs'] 14149 # verify the required parameter 'account_id' is set 14150 if ('account_id' not in params) or (params['account_id'] is None): 14151 raise ValueError("Missing the required parameter `account_id` when calling `update_recipients`") 14152 # verify the required parameter 'envelope_id' is set 14153 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14154 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipients`") 14155 14156 14157 collection_formats = {} 14158 14159 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients'.replace('{format}', 'json') 14160 path_params = {} 14161 if 'account_id' in params: 14162 path_params['accountId'] = params['account_id'] 14163 if 'envelope_id' in params: 14164 path_params['envelopeId'] = params['envelope_id'] 14165 14166 query_params = {} 14167 if 'combine_same_order_recipients' in params: 14168 query_params['combine_same_order_recipients'] = params['combine_same_order_recipients'] 14169 if 'offline_signing' in params: 14170 query_params['offline_signing'] = params['offline_signing'] 14171 if 'resend_envelope' in params: 14172 query_params['resend_envelope'] = params['resend_envelope'] 14173 14174 header_params = {} 14175 14176 form_params = [] 14177 local_var_files = {} 14178 14179 body_params = None 14180 if 'recipients' in params: 14181 body_params = params['recipients'] 14182 # HTTP header `Accept` 14183 header_params['Accept'] = self.api_client.\ 14184 select_header_accept(['application/json']) 14185 14186 # Authentication setting 14187 auth_settings = [] 14188 14189 return self.api_client.call_api(resource_path, 'PUT', 14190 path_params, 14191 query_params, 14192 header_params, 14193 body=body_params, 14194 post_params=form_params, 14195 files=local_var_files, 14196 response_type='RecipientsUpdateSummary', 14197 auth_settings=auth_settings, 14198 callback=params.get('callback'), 14199 _return_http_data_only=params.get('_return_http_data_only'), 14200 _preload_content=params.get('_preload_content', True), 14201 _request_timeout=params.get('_request_timeout'), 14202 collection_formats=collection_formats) 14203 14204 def update_recipients_document_visibility(self, account_id, envelope_id, **kwargs): 14205 """ 14206 Updates document visibility for the recipients 14207 This method updates document visibility for one or more recipients based on the `recipientId` and `visible` values that you include in the request body. **Note:** A document cannot be hidden from a recipient if the recipient has tabs assigned to them on the document. Carbon Copy, Certified Delivery (Needs to Sign), Editor, and Agent recipients can always see all documents. 14208 This method makes a synchronous HTTP request by default. To make an 14209 asynchronous HTTP request, please define a `callback` function 14210 to be invoked when receiving the response. 14211 >>> def callback_function(response): 14212 >>> pprint(response) 14213 >>> 14214 >>> thread = api.update_recipients_document_visibility(account_id, envelope_id, callback=callback_function) 14215 14216 :param callback function: The callback function 14217 for asynchronous request. (optional) 14218 :param str account_id: The external account number (int) or account ID Guid. (required) 14219 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14220 :param DocumentVisibilityList document_visibility_list: 14221 :return: DocumentVisibilityList 14222 If the method is called asynchronously, 14223 returns the request thread. 14224 """ 14225 kwargs['_return_http_data_only'] = True 14226 if kwargs.get('callback'): 14227 return self.update_recipients_document_visibility_with_http_info(account_id, envelope_id, **kwargs) 14228 else: 14229 (data) = self.update_recipients_document_visibility_with_http_info(account_id, envelope_id, **kwargs) 14230 return data 14231 14232 def update_recipients_document_visibility_with_http_info(self, account_id, envelope_id, **kwargs): 14233 """ 14234 Updates document visibility for the recipients 14235 This method updates document visibility for one or more recipients based on the `recipientId` and `visible` values that you include in the request body. **Note:** A document cannot be hidden from a recipient if the recipient has tabs assigned to them on the document. Carbon Copy, Certified Delivery (Needs to Sign), Editor, and Agent recipients can always see all documents. 14236 This method makes a synchronous HTTP request by default. To make an 14237 asynchronous HTTP request, please define a `callback` function 14238 to be invoked when receiving the response. 14239 >>> def callback_function(response): 14240 >>> pprint(response) 14241 >>> 14242 >>> thread = api.update_recipients_document_visibility_with_http_info(account_id, envelope_id, callback=callback_function) 14243 14244 :param callback function: The callback function 14245 for asynchronous request. (optional) 14246 :param str account_id: The external account number (int) or account ID Guid. (required) 14247 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14248 :param DocumentVisibilityList document_visibility_list: 14249 :return: DocumentVisibilityList 14250 If the method is called asynchronously, 14251 returns the request thread. 14252 """ 14253 14254 all_params = ['account_id', 'envelope_id', 'document_visibility_list'] 14255 all_params.append('callback') 14256 all_params.append('_return_http_data_only') 14257 all_params.append('_preload_content') 14258 all_params.append('_request_timeout') 14259 14260 params = locals() 14261 for key, val in iteritems(params['kwargs']): 14262 if key not in all_params: 14263 raise TypeError( 14264 "Got an unexpected keyword argument '%s'" 14265 " to method update_recipients_document_visibility" % key 14266 ) 14267 params[key] = val 14268 del params['kwargs'] 14269 # verify the required parameter 'account_id' is set 14270 if ('account_id' not in params) or (params['account_id'] is None): 14271 raise ValueError("Missing the required parameter `account_id` when calling `update_recipients_document_visibility`") 14272 # verify the required parameter 'envelope_id' is set 14273 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14274 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipients_document_visibility`") 14275 14276 14277 collection_formats = {} 14278 14279 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/document_visibility'.replace('{format}', 'json') 14280 path_params = {} 14281 if 'account_id' in params: 14282 path_params['accountId'] = params['account_id'] 14283 if 'envelope_id' in params: 14284 path_params['envelopeId'] = params['envelope_id'] 14285 14286 query_params = {} 14287 14288 header_params = {} 14289 14290 form_params = [] 14291 local_var_files = {} 14292 14293 body_params = None 14294 if 'document_visibility_list' in params: 14295 body_params = params['document_visibility_list'] 14296 # HTTP header `Accept` 14297 header_params['Accept'] = self.api_client.\ 14298 select_header_accept(['application/json']) 14299 14300 # Authentication setting 14301 auth_settings = [] 14302 14303 return self.api_client.call_api(resource_path, 'PUT', 14304 path_params, 14305 query_params, 14306 header_params, 14307 body=body_params, 14308 post_params=form_params, 14309 files=local_var_files, 14310 response_type='DocumentVisibilityList', 14311 auth_settings=auth_settings, 14312 callback=params.get('callback'), 14313 _return_http_data_only=params.get('_return_http_data_only'), 14314 _preload_content=params.get('_preload_content', True), 14315 _request_timeout=params.get('_request_timeout'), 14316 collection_formats=collection_formats) 14317 14318 def update_tabs(self, account_id, envelope_id, recipient_id, **kwargs): 14319 """ 14320 Updates the tabs for a recipient. 14321 Updates one or more tabs for a recipient in a draft envelope. 14322 This method makes a synchronous HTTP request by default. To make an 14323 asynchronous HTTP request, please define a `callback` function 14324 to be invoked when receiving the response. 14325 >>> def callback_function(response): 14326 >>> pprint(response) 14327 >>> 14328 >>> thread = api.update_tabs(account_id, envelope_id, recipient_id, callback=callback_function) 14329 14330 :param callback function: The callback function 14331 for asynchronous request. (optional) 14332 :param str account_id: The external account number (int) or account ID Guid. (required) 14333 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14334 :param str recipient_id: The ID of the recipient being accessed. (required) 14335 :param Tabs tabs: 14336 :return: Tabs 14337 If the method is called asynchronously, 14338 returns the request thread. 14339 """ 14340 kwargs['_return_http_data_only'] = True 14341 if kwargs.get('callback'): 14342 return self.update_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 14343 else: 14344 (data) = self.update_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 14345 return data 14346 14347 def update_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 14348 """ 14349 Updates the tabs for a recipient. 14350 Updates one or more tabs for a recipient in a draft envelope. 14351 This method makes a synchronous HTTP request by default. To make an 14352 asynchronous HTTP request, please define a `callback` function 14353 to be invoked when receiving the response. 14354 >>> def callback_function(response): 14355 >>> pprint(response) 14356 >>> 14357 >>> thread = api.update_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 14358 14359 :param callback function: The callback function 14360 for asynchronous request. (optional) 14361 :param str account_id: The external account number (int) or account ID Guid. (required) 14362 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14363 :param str recipient_id: The ID of the recipient being accessed. (required) 14364 :param Tabs tabs: 14365 :return: Tabs 14366 If the method is called asynchronously, 14367 returns the request thread. 14368 """ 14369 14370 all_params = ['account_id', 'envelope_id', 'recipient_id', 'tabs'] 14371 all_params.append('callback') 14372 all_params.append('_return_http_data_only') 14373 all_params.append('_preload_content') 14374 all_params.append('_request_timeout') 14375 14376 params = locals() 14377 for key, val in iteritems(params['kwargs']): 14378 if key not in all_params: 14379 raise TypeError( 14380 "Got an unexpected keyword argument '%s'" 14381 " to method update_tabs" % key 14382 ) 14383 params[key] = val 14384 del params['kwargs'] 14385 # verify the required parameter 'account_id' is set 14386 if ('account_id' not in params) or (params['account_id'] is None): 14387 raise ValueError("Missing the required parameter `account_id` when calling `update_tabs`") 14388 # verify the required parameter 'envelope_id' is set 14389 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14390 raise ValueError("Missing the required parameter `envelope_id` when calling `update_tabs`") 14391 # verify the required parameter 'recipient_id' is set 14392 if ('recipient_id' not in params) or (params['recipient_id'] is None): 14393 raise ValueError("Missing the required parameter `recipient_id` when calling `update_tabs`") 14394 14395 14396 collection_formats = {} 14397 14398 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/tabs'.replace('{format}', 'json') 14399 path_params = {} 14400 if 'account_id' in params: 14401 path_params['accountId'] = params['account_id'] 14402 if 'envelope_id' in params: 14403 path_params['envelopeId'] = params['envelope_id'] 14404 if 'recipient_id' in params: 14405 path_params['recipientId'] = params['recipient_id'] 14406 14407 query_params = {} 14408 14409 header_params = {} 14410 14411 form_params = [] 14412 local_var_files = {} 14413 14414 body_params = None 14415 if 'tabs' in params: 14416 body_params = params['tabs'] 14417 # HTTP header `Accept` 14418 header_params['Accept'] = self.api_client.\ 14419 select_header_accept(['application/json']) 14420 14421 # Authentication setting 14422 auth_settings = [] 14423 14424 return self.api_client.call_api(resource_path, 'PUT', 14425 path_params, 14426 query_params, 14427 header_params, 14428 body=body_params, 14429 post_params=form_params, 14430 files=local_var_files, 14431 response_type='Tabs', 14432 auth_settings=auth_settings, 14433 callback=params.get('callback'), 14434 _return_http_data_only=params.get('_return_http_data_only'), 14435 _preload_content=params.get('_preload_content', True), 14436 _request_timeout=params.get('_request_timeout'), 14437 collection_formats=collection_formats) 14438 14439 def update_tabs_blob(self, account_id, envelope_id, **kwargs): 14440 """ 14441 Update encrypted tabs for envelope. 14442 14443 This method makes a synchronous HTTP request by default. To make an 14444 asynchronous HTTP request, please define a `callback` function 14445 to be invoked when receiving the response. 14446 >>> def callback_function(response): 14447 >>> pprint(response) 14448 >>> 14449 >>> thread = api.update_tabs_blob(account_id, envelope_id, callback=callback_function) 14450 14451 :param callback function: The callback function 14452 for asynchronous request. (optional) 14453 :param str account_id: The external account number (int) or account ID Guid. (required) 14454 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14455 :return: None 14456 If the method is called asynchronously, 14457 returns the request thread. 14458 """ 14459 kwargs['_return_http_data_only'] = True 14460 if kwargs.get('callback'): 14461 return self.update_tabs_blob_with_http_info(account_id, envelope_id, **kwargs) 14462 else: 14463 (data) = self.update_tabs_blob_with_http_info(account_id, envelope_id, **kwargs) 14464 return data 14465 14466 def update_tabs_blob_with_http_info(self, account_id, envelope_id, **kwargs): 14467 """ 14468 Update encrypted tabs for envelope. 14469 14470 This method makes a synchronous HTTP request by default. To make an 14471 asynchronous HTTP request, please define a `callback` function 14472 to be invoked when receiving the response. 14473 >>> def callback_function(response): 14474 >>> pprint(response) 14475 >>> 14476 >>> thread = api.update_tabs_blob_with_http_info(account_id, envelope_id, callback=callback_function) 14477 14478 :param callback function: The callback function 14479 for asynchronous request. (optional) 14480 :param str account_id: The external account number (int) or account ID Guid. (required) 14481 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14482 :return: None 14483 If the method is called asynchronously, 14484 returns the request thread. 14485 """ 14486 14487 all_params = ['account_id', 'envelope_id'] 14488 all_params.append('callback') 14489 all_params.append('_return_http_data_only') 14490 all_params.append('_preload_content') 14491 all_params.append('_request_timeout') 14492 14493 params = locals() 14494 for key, val in iteritems(params['kwargs']): 14495 if key not in all_params: 14496 raise TypeError( 14497 "Got an unexpected keyword argument '%s'" 14498 " to method update_tabs_blob" % key 14499 ) 14500 params[key] = val 14501 del params['kwargs'] 14502 # verify the required parameter 'account_id' is set 14503 if ('account_id' not in params) or (params['account_id'] is None): 14504 raise ValueError("Missing the required parameter `account_id` when calling `update_tabs_blob`") 14505 # verify the required parameter 'envelope_id' is set 14506 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14507 raise ValueError("Missing the required parameter `envelope_id` when calling `update_tabs_blob`") 14508 14509 14510 collection_formats = {} 14511 14512 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/tabs_blob'.replace('{format}', 'json') 14513 path_params = {} 14514 if 'account_id' in params: 14515 path_params['accountId'] = params['account_id'] 14516 if 'envelope_id' in params: 14517 path_params['envelopeId'] = params['envelope_id'] 14518 14519 query_params = {} 14520 14521 header_params = {} 14522 14523 form_params = [] 14524 local_var_files = {} 14525 14526 body_params = None 14527 # HTTP header `Accept` 14528 header_params['Accept'] = self.api_client.\ 14529 select_header_accept(['application/json']) 14530 14531 # Authentication setting 14532 auth_settings = [] 14533 14534 return self.api_client.call_api(resource_path, 'PUT', 14535 path_params, 14536 query_params, 14537 header_params, 14538 body=body_params, 14539 post_params=form_params, 14540 files=local_var_files, 14541 response_type=None, 14542 auth_settings=auth_settings, 14543 callback=params.get('callback'), 14544 _return_http_data_only=params.get('_return_http_data_only'), 14545 _preload_content=params.get('_preload_content', True), 14546 _request_timeout=params.get('_request_timeout'), 14547 collection_formats=collection_formats) 14548 14549 def update_template_delayed_routing_definition(self, account_id, template_id, workflow_step_id, **kwargs): 14550 """ 14551 Updates the delayed routing rules for a template's workflow step definition. 14552 This method makes a synchronous HTTP request by default. To make an 14553 asynchronous HTTP request, please define a `callback` function 14554 to be invoked when receiving the response. 14555 >>> def callback_function(response): 14556 >>> pprint(response) 14557 >>> 14558 >>> thread = api.update_template_delayed_routing_definition(account_id, template_id, workflow_step_id, callback=callback_function) 14559 14560 :param callback function: The callback function 14561 for asynchronous request. (optional) 14562 :param str account_id: The external account number (int) or account ID Guid. (required) 14563 :param str template_id: The ID of the template being accessed. (required) 14564 :param str workflow_step_id: (required) 14565 :param DelayedRouting delayed_routing: 14566 :return: DelayedRouting 14567 If the method is called asynchronously, 14568 returns the request thread. 14569 """ 14570 kwargs['_return_http_data_only'] = True 14571 if kwargs.get('callback'): 14572 return self.update_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 14573 else: 14574 (data) = self.update_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 14575 return data 14576 14577 def update_template_delayed_routing_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 14578 """ 14579 Updates the delayed routing rules for a template's workflow step definition. 14580 This method makes a synchronous HTTP request by default. To make an 14581 asynchronous HTTP request, please define a `callback` function 14582 to be invoked when receiving the response. 14583 >>> def callback_function(response): 14584 >>> pprint(response) 14585 >>> 14586 >>> thread = api.update_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 14587 14588 :param callback function: The callback function 14589 for asynchronous request. (optional) 14590 :param str account_id: The external account number (int) or account ID Guid. (required) 14591 :param str template_id: The ID of the template being accessed. (required) 14592 :param str workflow_step_id: (required) 14593 :param DelayedRouting delayed_routing: 14594 :return: DelayedRouting 14595 If the method is called asynchronously, 14596 returns the request thread. 14597 """ 14598 14599 all_params = ['account_id', 'template_id', 'workflow_step_id', 'delayed_routing'] 14600 all_params.append('callback') 14601 all_params.append('_return_http_data_only') 14602 all_params.append('_preload_content') 14603 all_params.append('_request_timeout') 14604 14605 params = locals() 14606 for key, val in iteritems(params['kwargs']): 14607 if key not in all_params: 14608 raise TypeError( 14609 "Got an unexpected keyword argument '%s'" 14610 " to method update_template_delayed_routing_definition" % key 14611 ) 14612 params[key] = val 14613 del params['kwargs'] 14614 # verify the required parameter 'account_id' is set 14615 if ('account_id' not in params) or (params['account_id'] is None): 14616 raise ValueError("Missing the required parameter `account_id` when calling `update_template_delayed_routing_definition`") 14617 # verify the required parameter 'template_id' is set 14618 if ('template_id' not in params) or (params['template_id'] is None): 14619 raise ValueError("Missing the required parameter `template_id` when calling `update_template_delayed_routing_definition`") 14620 # verify the required parameter 'workflow_step_id' is set 14621 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 14622 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_template_delayed_routing_definition`") 14623 14624 14625 collection_formats = {} 14626 14627 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 14628 path_params = {} 14629 if 'account_id' in params: 14630 path_params['accountId'] = params['account_id'] 14631 if 'template_id' in params: 14632 path_params['templateId'] = params['template_id'] 14633 if 'workflow_step_id' in params: 14634 path_params['workflowStepId'] = params['workflow_step_id'] 14635 14636 query_params = {} 14637 14638 header_params = {} 14639 14640 form_params = [] 14641 local_var_files = {} 14642 14643 body_params = None 14644 if 'delayed_routing' in params: 14645 body_params = params['delayed_routing'] 14646 # HTTP header `Accept` 14647 header_params['Accept'] = self.api_client.\ 14648 select_header_accept(['application/json']) 14649 14650 # Authentication setting 14651 auth_settings = [] 14652 14653 return self.api_client.call_api(resource_path, 'PUT', 14654 path_params, 14655 query_params, 14656 header_params, 14657 body=body_params, 14658 post_params=form_params, 14659 files=local_var_files, 14660 response_type='DelayedRouting', 14661 auth_settings=auth_settings, 14662 callback=params.get('callback'), 14663 _return_http_data_only=params.get('_return_http_data_only'), 14664 _preload_content=params.get('_preload_content', True), 14665 _request_timeout=params.get('_request_timeout'), 14666 collection_formats=collection_formats) 14667 14668 def update_template_recipient_document_visibility(self, account_id, recipient_id, template_id, **kwargs): 14669 """ 14670 Updates document visibility for the recipients 14671 This method updates the document visibility for a template recipient. **Note:** A document cannot be hidden from a recipient if the recipient has tabs assigned to them on the document. Carbon Copy, Certified Delivery (Needs to Sign), Editor, and Agent recipients can always see all documents. 14672 This method makes a synchronous HTTP request by default. To make an 14673 asynchronous HTTP request, please define a `callback` function 14674 to be invoked when receiving the response. 14675 >>> def callback_function(response): 14676 >>> pprint(response) 14677 >>> 14678 >>> thread = api.update_template_recipient_document_visibility(account_id, recipient_id, template_id, callback=callback_function) 14679 14680 :param callback function: The callback function 14681 for asynchronous request. (optional) 14682 :param str account_id: The external account number (int) or account ID Guid. (required) 14683 :param str recipient_id: The ID of the recipient being accessed. (required) 14684 :param str template_id: The ID of the template being accessed. (required) 14685 :param TemplateDocumentVisibilityList template_document_visibility_list: 14686 :return: TemplateDocumentVisibilityList 14687 If the method is called asynchronously, 14688 returns the request thread. 14689 """ 14690 kwargs['_return_http_data_only'] = True 14691 if kwargs.get('callback'): 14692 return self.update_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, **kwargs) 14693 else: 14694 (data) = self.update_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, **kwargs) 14695 return data 14696 14697 def update_template_recipient_document_visibility_with_http_info(self, account_id, recipient_id, template_id, **kwargs): 14698 """ 14699 Updates document visibility for the recipients 14700 This method updates the document visibility for a template recipient. **Note:** A document cannot be hidden from a recipient if the recipient has tabs assigned to them on the document. Carbon Copy, Certified Delivery (Needs to Sign), Editor, and Agent recipients can always see all documents. 14701 This method makes a synchronous HTTP request by default. To make an 14702 asynchronous HTTP request, please define a `callback` function 14703 to be invoked when receiving the response. 14704 >>> def callback_function(response): 14705 >>> pprint(response) 14706 >>> 14707 >>> thread = api.update_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, callback=callback_function) 14708 14709 :param callback function: The callback function 14710 for asynchronous request. (optional) 14711 :param str account_id: The external account number (int) or account ID Guid. (required) 14712 :param str recipient_id: The ID of the recipient being accessed. (required) 14713 :param str template_id: The ID of the template being accessed. (required) 14714 :param TemplateDocumentVisibilityList template_document_visibility_list: 14715 :return: TemplateDocumentVisibilityList 14716 If the method is called asynchronously, 14717 returns the request thread. 14718 """ 14719 14720 all_params = ['account_id', 'recipient_id', 'template_id', 'template_document_visibility_list'] 14721 all_params.append('callback') 14722 all_params.append('_return_http_data_only') 14723 all_params.append('_preload_content') 14724 all_params.append('_request_timeout') 14725 14726 params = locals() 14727 for key, val in iteritems(params['kwargs']): 14728 if key not in all_params: 14729 raise TypeError( 14730 "Got an unexpected keyword argument '%s'" 14731 " to method update_template_recipient_document_visibility" % key 14732 ) 14733 params[key] = val 14734 del params['kwargs'] 14735 # verify the required parameter 'account_id' is set 14736 if ('account_id' not in params) or (params['account_id'] is None): 14737 raise ValueError("Missing the required parameter `account_id` when calling `update_template_recipient_document_visibility`") 14738 # verify the required parameter 'recipient_id' is set 14739 if ('recipient_id' not in params) or (params['recipient_id'] is None): 14740 raise ValueError("Missing the required parameter `recipient_id` when calling `update_template_recipient_document_visibility`") 14741 # verify the required parameter 'template_id' is set 14742 if ('template_id' not in params) or (params['template_id'] is None): 14743 raise ValueError("Missing the required parameter `template_id` when calling `update_template_recipient_document_visibility`") 14744 14745 14746 collection_formats = {} 14747 14748 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/recipients/{recipientId}/document_visibility'.replace('{format}', 'json') 14749 path_params = {} 14750 if 'account_id' in params: 14751 path_params['accountId'] = params['account_id'] 14752 if 'recipient_id' in params: 14753 path_params['recipientId'] = params['recipient_id'] 14754 if 'template_id' in params: 14755 path_params['templateId'] = params['template_id'] 14756 14757 query_params = {} 14758 14759 header_params = {} 14760 14761 form_params = [] 14762 local_var_files = {} 14763 14764 body_params = None 14765 if 'template_document_visibility_list' in params: 14766 body_params = params['template_document_visibility_list'] 14767 # HTTP header `Accept` 14768 header_params['Accept'] = self.api_client.\ 14769 select_header_accept(['application/json']) 14770 14771 # Authentication setting 14772 auth_settings = [] 14773 14774 return self.api_client.call_api(resource_path, 'PUT', 14775 path_params, 14776 query_params, 14777 header_params, 14778 body=body_params, 14779 post_params=form_params, 14780 files=local_var_files, 14781 response_type='TemplateDocumentVisibilityList', 14782 auth_settings=auth_settings, 14783 callback=params.get('callback'), 14784 _return_http_data_only=params.get('_return_http_data_only'), 14785 _preload_content=params.get('_preload_content', True), 14786 _request_timeout=params.get('_request_timeout'), 14787 collection_formats=collection_formats) 14788 14789 def update_template_recipients_document_visibility(self, account_id, template_id, **kwargs): 14790 """ 14791 Updates document visibility for the recipients 14792 This method updates document visibility for one or more template recipients based on the `recipientId` and `visible` values that you include in the request body. **Note:** A document cannot be hidden from a recipient if the recipient has tabs assigned to them on the document. Carbon Copy, Certified Delivery (Needs to Sign), Editor, and Agent recipients can always see all documents. 14793 This method makes a synchronous HTTP request by default. To make an 14794 asynchronous HTTP request, please define a `callback` function 14795 to be invoked when receiving the response. 14796 >>> def callback_function(response): 14797 >>> pprint(response) 14798 >>> 14799 >>> thread = api.update_template_recipients_document_visibility(account_id, template_id, callback=callback_function) 14800 14801 :param callback function: The callback function 14802 for asynchronous request. (optional) 14803 :param str account_id: The external account number (int) or account ID Guid. (required) 14804 :param str template_id: The ID of the template being accessed. (required) 14805 :param TemplateDocumentVisibilityList template_document_visibility_list: 14806 :return: TemplateDocumentVisibilityList 14807 If the method is called asynchronously, 14808 returns the request thread. 14809 """ 14810 kwargs['_return_http_data_only'] = True 14811 if kwargs.get('callback'): 14812 return self.update_template_recipients_document_visibility_with_http_info(account_id, template_id, **kwargs) 14813 else: 14814 (data) = self.update_template_recipients_document_visibility_with_http_info(account_id, template_id, **kwargs) 14815 return data 14816 14817 def update_template_recipients_document_visibility_with_http_info(self, account_id, template_id, **kwargs): 14818 """ 14819 Updates document visibility for the recipients 14820 This method updates document visibility for one or more template recipients based on the `recipientId` and `visible` values that you include in the request body. **Note:** A document cannot be hidden from a recipient if the recipient has tabs assigned to them on the document. Carbon Copy, Certified Delivery (Needs to Sign), Editor, and Agent recipients can always see all documents. 14821 This method makes a synchronous HTTP request by default. To make an 14822 asynchronous HTTP request, please define a `callback` function 14823 to be invoked when receiving the response. 14824 >>> def callback_function(response): 14825 >>> pprint(response) 14826 >>> 14827 >>> thread = api.update_template_recipients_document_visibility_with_http_info(account_id, template_id, callback=callback_function) 14828 14829 :param callback function: The callback function 14830 for asynchronous request. (optional) 14831 :param str account_id: The external account number (int) or account ID Guid. (required) 14832 :param str template_id: The ID of the template being accessed. (required) 14833 :param TemplateDocumentVisibilityList template_document_visibility_list: 14834 :return: TemplateDocumentVisibilityList 14835 If the method is called asynchronously, 14836 returns the request thread. 14837 """ 14838 14839 all_params = ['account_id', 'template_id', 'template_document_visibility_list'] 14840 all_params.append('callback') 14841 all_params.append('_return_http_data_only') 14842 all_params.append('_preload_content') 14843 all_params.append('_request_timeout') 14844 14845 params = locals() 14846 for key, val in iteritems(params['kwargs']): 14847 if key not in all_params: 14848 raise TypeError( 14849 "Got an unexpected keyword argument '%s'" 14850 " to method update_template_recipients_document_visibility" % key 14851 ) 14852 params[key] = val 14853 del params['kwargs'] 14854 # verify the required parameter 'account_id' is set 14855 if ('account_id' not in params) or (params['account_id'] is None): 14856 raise ValueError("Missing the required parameter `account_id` when calling `update_template_recipients_document_visibility`") 14857 # verify the required parameter 'template_id' is set 14858 if ('template_id' not in params) or (params['template_id'] is None): 14859 raise ValueError("Missing the required parameter `template_id` when calling `update_template_recipients_document_visibility`") 14860 14861 14862 collection_formats = {} 14863 14864 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/recipients/document_visibility'.replace('{format}', 'json') 14865 path_params = {} 14866 if 'account_id' in params: 14867 path_params['accountId'] = params['account_id'] 14868 if 'template_id' in params: 14869 path_params['templateId'] = params['template_id'] 14870 14871 query_params = {} 14872 14873 header_params = {} 14874 14875 form_params = [] 14876 local_var_files = {} 14877 14878 body_params = None 14879 if 'template_document_visibility_list' in params: 14880 body_params = params['template_document_visibility_list'] 14881 # HTTP header `Accept` 14882 header_params['Accept'] = self.api_client.\ 14883 select_header_accept(['application/json']) 14884 14885 # Authentication setting 14886 auth_settings = [] 14887 14888 return self.api_client.call_api(resource_path, 'PUT', 14889 path_params, 14890 query_params, 14891 header_params, 14892 body=body_params, 14893 post_params=form_params, 14894 files=local_var_files, 14895 response_type='TemplateDocumentVisibilityList', 14896 auth_settings=auth_settings, 14897 callback=params.get('callback'), 14898 _return_http_data_only=params.get('_return_http_data_only'), 14899 _preload_content=params.get('_preload_content', True), 14900 _request_timeout=params.get('_request_timeout'), 14901 collection_formats=collection_formats) 14902 14903 def update_template_scheduled_sending_definition(self, account_id, template_id, **kwargs): 14904 """ 14905 Updates the scheduled sending rules for a template's workflow definition. 14906 This method makes a synchronous HTTP request by default. To make an 14907 asynchronous HTTP request, please define a `callback` function 14908 to be invoked when receiving the response. 14909 >>> def callback_function(response): 14910 >>> pprint(response) 14911 >>> 14912 >>> thread = api.update_template_scheduled_sending_definition(account_id, template_id, callback=callback_function) 14913 14914 :param callback function: The callback function 14915 for asynchronous request. (optional) 14916 :param str account_id: The external account number (int) or account ID Guid. (required) 14917 :param str template_id: The ID of the template being accessed. (required) 14918 :param ScheduledSending scheduled_sending: 14919 :return: ScheduledSending 14920 If the method is called asynchronously, 14921 returns the request thread. 14922 """ 14923 kwargs['_return_http_data_only'] = True 14924 if kwargs.get('callback'): 14925 return self.update_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 14926 else: 14927 (data) = self.update_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 14928 return data 14929 14930 def update_template_scheduled_sending_definition_with_http_info(self, account_id, template_id, **kwargs): 14931 """ 14932 Updates the scheduled sending rules for a template's workflow definition. 14933 This method makes a synchronous HTTP request by default. To make an 14934 asynchronous HTTP request, please define a `callback` function 14935 to be invoked when receiving the response. 14936 >>> def callback_function(response): 14937 >>> pprint(response) 14938 >>> 14939 >>> thread = api.update_template_scheduled_sending_definition_with_http_info(account_id, template_id, callback=callback_function) 14940 14941 :param callback function: The callback function 14942 for asynchronous request. (optional) 14943 :param str account_id: The external account number (int) or account ID Guid. (required) 14944 :param str template_id: The ID of the template being accessed. (required) 14945 :param ScheduledSending scheduled_sending: 14946 :return: ScheduledSending 14947 If the method is called asynchronously, 14948 returns the request thread. 14949 """ 14950 14951 all_params = ['account_id', 'template_id', 'scheduled_sending'] 14952 all_params.append('callback') 14953 all_params.append('_return_http_data_only') 14954 all_params.append('_preload_content') 14955 all_params.append('_request_timeout') 14956 14957 params = locals() 14958 for key, val in iteritems(params['kwargs']): 14959 if key not in all_params: 14960 raise TypeError( 14961 "Got an unexpected keyword argument '%s'" 14962 " to method update_template_scheduled_sending_definition" % key 14963 ) 14964 params[key] = val 14965 del params['kwargs'] 14966 # verify the required parameter 'account_id' is set 14967 if ('account_id' not in params) or (params['account_id'] is None): 14968 raise ValueError("Missing the required parameter `account_id` when calling `update_template_scheduled_sending_definition`") 14969 # verify the required parameter 'template_id' is set 14970 if ('template_id' not in params) or (params['template_id'] is None): 14971 raise ValueError("Missing the required parameter `template_id` when calling `update_template_scheduled_sending_definition`") 14972 14973 14974 collection_formats = {} 14975 14976 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/scheduledSending'.replace('{format}', 'json') 14977 path_params = {} 14978 if 'account_id' in params: 14979 path_params['accountId'] = params['account_id'] 14980 if 'template_id' in params: 14981 path_params['templateId'] = params['template_id'] 14982 14983 query_params = {} 14984 14985 header_params = {} 14986 14987 form_params = [] 14988 local_var_files = {} 14989 14990 body_params = None 14991 if 'scheduled_sending' in params: 14992 body_params = params['scheduled_sending'] 14993 # HTTP header `Accept` 14994 header_params['Accept'] = self.api_client.\ 14995 select_header_accept(['application/json']) 14996 14997 # Authentication setting 14998 auth_settings = [] 14999 15000 return self.api_client.call_api(resource_path, 'PUT', 15001 path_params, 15002 query_params, 15003 header_params, 15004 body=body_params, 15005 post_params=form_params, 15006 files=local_var_files, 15007 response_type='ScheduledSending', 15008 auth_settings=auth_settings, 15009 callback=params.get('callback'), 15010 _return_http_data_only=params.get('_return_http_data_only'), 15011 _preload_content=params.get('_preload_content', True), 15012 _request_timeout=params.get('_request_timeout'), 15013 collection_formats=collection_formats) 15014 15015 def update_template_workflow_definition(self, account_id, template_id, **kwargs): 15016 """ 15017 Updates the workflow definition for a template. 15018 Updates the specified template's workflow definition if it has one. 15019 This method makes a synchronous HTTP request by default. To make an 15020 asynchronous HTTP request, please define a `callback` function 15021 to be invoked when receiving the response. 15022 >>> def callback_function(response): 15023 >>> pprint(response) 15024 >>> 15025 >>> thread = api.update_template_workflow_definition(account_id, template_id, callback=callback_function) 15026 15027 :param callback function: The callback function 15028 for asynchronous request. (optional) 15029 :param str account_id: The external account number (int) or account ID Guid. (required) 15030 :param str template_id: The ID of the template being accessed. (required) 15031 :param Workflow workflow: 15032 :return: Workflow 15033 If the method is called asynchronously, 15034 returns the request thread. 15035 """ 15036 kwargs['_return_http_data_only'] = True 15037 if kwargs.get('callback'): 15038 return self.update_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 15039 else: 15040 (data) = self.update_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 15041 return data 15042 15043 def update_template_workflow_definition_with_http_info(self, account_id, template_id, **kwargs): 15044 """ 15045 Updates the workflow definition for a template. 15046 Updates the specified template's workflow definition if it has one. 15047 This method makes a synchronous HTTP request by default. To make an 15048 asynchronous HTTP request, please define a `callback` function 15049 to be invoked when receiving the response. 15050 >>> def callback_function(response): 15051 >>> pprint(response) 15052 >>> 15053 >>> thread = api.update_template_workflow_definition_with_http_info(account_id, template_id, callback=callback_function) 15054 15055 :param callback function: The callback function 15056 for asynchronous request. (optional) 15057 :param str account_id: The external account number (int) or account ID Guid. (required) 15058 :param str template_id: The ID of the template being accessed. (required) 15059 :param Workflow workflow: 15060 :return: Workflow 15061 If the method is called asynchronously, 15062 returns the request thread. 15063 """ 15064 15065 all_params = ['account_id', 'template_id', 'workflow'] 15066 all_params.append('callback') 15067 all_params.append('_return_http_data_only') 15068 all_params.append('_preload_content') 15069 all_params.append('_request_timeout') 15070 15071 params = locals() 15072 for key, val in iteritems(params['kwargs']): 15073 if key not in all_params: 15074 raise TypeError( 15075 "Got an unexpected keyword argument '%s'" 15076 " to method update_template_workflow_definition" % key 15077 ) 15078 params[key] = val 15079 del params['kwargs'] 15080 # verify the required parameter 'account_id' is set 15081 if ('account_id' not in params) or (params['account_id'] is None): 15082 raise ValueError("Missing the required parameter `account_id` when calling `update_template_workflow_definition`") 15083 # verify the required parameter 'template_id' is set 15084 if ('template_id' not in params) or (params['template_id'] is None): 15085 raise ValueError("Missing the required parameter `template_id` when calling `update_template_workflow_definition`") 15086 15087 15088 collection_formats = {} 15089 15090 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow'.replace('{format}', 'json') 15091 path_params = {} 15092 if 'account_id' in params: 15093 path_params['accountId'] = params['account_id'] 15094 if 'template_id' in params: 15095 path_params['templateId'] = params['template_id'] 15096 15097 query_params = {} 15098 15099 header_params = {} 15100 15101 form_params = [] 15102 local_var_files = {} 15103 15104 body_params = None 15105 if 'workflow' in params: 15106 body_params = params['workflow'] 15107 # HTTP header `Accept` 15108 header_params['Accept'] = self.api_client.\ 15109 select_header_accept(['application/json']) 15110 15111 # Authentication setting 15112 auth_settings = [] 15113 15114 return self.api_client.call_api(resource_path, 'PUT', 15115 path_params, 15116 query_params, 15117 header_params, 15118 body=body_params, 15119 post_params=form_params, 15120 files=local_var_files, 15121 response_type='Workflow', 15122 auth_settings=auth_settings, 15123 callback=params.get('callback'), 15124 _return_http_data_only=params.get('_return_http_data_only'), 15125 _preload_content=params.get('_preload_content', True), 15126 _request_timeout=params.get('_request_timeout'), 15127 collection_formats=collection_formats) 15128 15129 def update_template_workflow_step_definition(self, account_id, template_id, workflow_step_id, **kwargs): 15130 """ 15131 Updates the template workflow step definition for an envelope. 15132 This method makes a synchronous HTTP request by default. To make an 15133 asynchronous HTTP request, please define a `callback` function 15134 to be invoked when receiving the response. 15135 >>> def callback_function(response): 15136 >>> pprint(response) 15137 >>> 15138 >>> thread = api.update_template_workflow_step_definition(account_id, template_id, workflow_step_id, callback=callback_function) 15139 15140 :param callback function: The callback function 15141 for asynchronous request. (optional) 15142 :param str account_id: The external account number (int) or account ID Guid. (required) 15143 :param str template_id: The ID of the template being accessed. (required) 15144 :param str workflow_step_id: (required) 15145 :param WorkflowStep workflow_step: 15146 :return: WorkflowStep 15147 If the method is called asynchronously, 15148 returns the request thread. 15149 """ 15150 kwargs['_return_http_data_only'] = True 15151 if kwargs.get('callback'): 15152 return self.update_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 15153 else: 15154 (data) = self.update_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 15155 return data 15156 15157 def update_template_workflow_step_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 15158 """ 15159 Updates the template workflow step definition for an envelope. 15160 This method makes a synchronous HTTP request by default. To make an 15161 asynchronous HTTP request, please define a `callback` function 15162 to be invoked when receiving the response. 15163 >>> def callback_function(response): 15164 >>> pprint(response) 15165 >>> 15166 >>> thread = api.update_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 15167 15168 :param callback function: The callback function 15169 for asynchronous request. (optional) 15170 :param str account_id: The external account number (int) or account ID Guid. (required) 15171 :param str template_id: The ID of the template being accessed. (required) 15172 :param str workflow_step_id: (required) 15173 :param WorkflowStep workflow_step: 15174 :return: WorkflowStep 15175 If the method is called asynchronously, 15176 returns the request thread. 15177 """ 15178 15179 all_params = ['account_id', 'template_id', 'workflow_step_id', 'workflow_step'] 15180 all_params.append('callback') 15181 all_params.append('_return_http_data_only') 15182 all_params.append('_preload_content') 15183 all_params.append('_request_timeout') 15184 15185 params = locals() 15186 for key, val in iteritems(params['kwargs']): 15187 if key not in all_params: 15188 raise TypeError( 15189 "Got an unexpected keyword argument '%s'" 15190 " to method update_template_workflow_step_definition" % key 15191 ) 15192 params[key] = val 15193 del params['kwargs'] 15194 # verify the required parameter 'account_id' is set 15195 if ('account_id' not in params) or (params['account_id'] is None): 15196 raise ValueError("Missing the required parameter `account_id` when calling `update_template_workflow_step_definition`") 15197 # verify the required parameter 'template_id' is set 15198 if ('template_id' not in params) or (params['template_id'] is None): 15199 raise ValueError("Missing the required parameter `template_id` when calling `update_template_workflow_step_definition`") 15200 # verify the required parameter 'workflow_step_id' is set 15201 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 15202 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_template_workflow_step_definition`") 15203 15204 15205 collection_formats = {} 15206 15207 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 15208 path_params = {} 15209 if 'account_id' in params: 15210 path_params['accountId'] = params['account_id'] 15211 if 'template_id' in params: 15212 path_params['templateId'] = params['template_id'] 15213 if 'workflow_step_id' in params: 15214 path_params['workflowStepId'] = params['workflow_step_id'] 15215 15216 query_params = {} 15217 15218 header_params = {} 15219 15220 form_params = [] 15221 local_var_files = {} 15222 15223 body_params = None 15224 if 'workflow_step' in params: 15225 body_params = params['workflow_step'] 15226 # HTTP header `Accept` 15227 header_params['Accept'] = self.api_client.\ 15228 select_header_accept(['application/json']) 15229 15230 # Authentication setting 15231 auth_settings = [] 15232 15233 return self.api_client.call_api(resource_path, 'PUT', 15234 path_params, 15235 query_params, 15236 header_params, 15237 body=body_params, 15238 post_params=form_params, 15239 files=local_var_files, 15240 response_type='WorkflowStep', 15241 auth_settings=auth_settings, 15242 callback=params.get('callback'), 15243 _return_http_data_only=params.get('_return_http_data_only'), 15244 _preload_content=params.get('_preload_content', True), 15245 _request_timeout=params.get('_request_timeout'), 15246 collection_formats=collection_formats)
NOTE: This class is auto generated by the swagger code generator program. Do not edit the class manually. Ref: https://github.com/swagger-api/swagger-codegen
def
apply_template(self, account_id, envelope_id, **kwargs)
44 def apply_template(self, account_id, envelope_id, **kwargs): 45 """ 46 Adds templates to an envelope. 47 Adds templates to the specified envelope. 48 This method makes a synchronous HTTP request by default. To make an 49 asynchronous HTTP request, please define a `callback` function 50 to be invoked when receiving the response. 51 >>> def callback_function(response): 52 >>> pprint(response) 53 >>> 54 >>> thread = api.apply_template(account_id, envelope_id, callback=callback_function) 55 56 :param callback function: The callback function 57 for asynchronous request. (optional) 58 :param str account_id: The external account number (int) or account ID Guid. (required) 59 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 60 :param str preserve_template_recipient: 61 :param DocumentTemplateList document_template_list: 62 :return: DocumentTemplateList 63 If the method is called asynchronously, 64 returns the request thread. 65 """ 66 kwargs['_return_http_data_only'] = True 67 if kwargs.get('callback'): 68 return self.apply_template_with_http_info(account_id, envelope_id, **kwargs) 69 else: 70 (data) = self.apply_template_with_http_info(account_id, envelope_id, **kwargs) 71 return data
Adds templates to an envelope.
Adds templates to the specified envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.apply_template(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str preserve_template_recipient:
- DocumentTemplateList document_template_list:
Returns
DocumentTemplateList If the method is called asynchronously, returns the request thread.
def
apply_template_with_http_info(self, account_id, envelope_id, **kwargs)
73 def apply_template_with_http_info(self, account_id, envelope_id, **kwargs): 74 """ 75 Adds templates to an envelope. 76 Adds templates to the specified envelope. 77 This method makes a synchronous HTTP request by default. To make an 78 asynchronous HTTP request, please define a `callback` function 79 to be invoked when receiving the response. 80 >>> def callback_function(response): 81 >>> pprint(response) 82 >>> 83 >>> thread = api.apply_template_with_http_info(account_id, envelope_id, callback=callback_function) 84 85 :param callback function: The callback function 86 for asynchronous request. (optional) 87 :param str account_id: The external account number (int) or account ID Guid. (required) 88 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 89 :param str preserve_template_recipient: 90 :param DocumentTemplateList document_template_list: 91 :return: DocumentTemplateList 92 If the method is called asynchronously, 93 returns the request thread. 94 """ 95 96 all_params = ['account_id', 'envelope_id', 'preserve_template_recipient', 'document_template_list'] 97 all_params.append('callback') 98 all_params.append('_return_http_data_only') 99 all_params.append('_preload_content') 100 all_params.append('_request_timeout') 101 102 params = locals() 103 for key, val in iteritems(params['kwargs']): 104 if key not in all_params: 105 raise TypeError( 106 "Got an unexpected keyword argument '%s'" 107 " to method apply_template" % key 108 ) 109 params[key] = val 110 del params['kwargs'] 111 # verify the required parameter 'account_id' is set 112 if ('account_id' not in params) or (params['account_id'] is None): 113 raise ValueError("Missing the required parameter `account_id` when calling `apply_template`") 114 # verify the required parameter 'envelope_id' is set 115 if ('envelope_id' not in params) or (params['envelope_id'] is None): 116 raise ValueError("Missing the required parameter `envelope_id` when calling `apply_template`") 117 118 119 collection_formats = {} 120 121 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/templates'.replace('{format}', 'json') 122 path_params = {} 123 if 'account_id' in params: 124 path_params['accountId'] = params['account_id'] 125 if 'envelope_id' in params: 126 path_params['envelopeId'] = params['envelope_id'] 127 128 query_params = {} 129 if 'preserve_template_recipient' in params: 130 query_params['preserve_template_recipient'] = params['preserve_template_recipient'] 131 132 header_params = {} 133 134 form_params = [] 135 local_var_files = {} 136 137 body_params = None 138 if 'document_template_list' in params: 139 body_params = params['document_template_list'] 140 # HTTP header `Accept` 141 header_params['Accept'] = self.api_client.\ 142 select_header_accept(['application/json']) 143 144 # Authentication setting 145 auth_settings = [] 146 147 return self.api_client.call_api(resource_path, 'POST', 148 path_params, 149 query_params, 150 header_params, 151 body=body_params, 152 post_params=form_params, 153 files=local_var_files, 154 response_type='DocumentTemplateList', 155 auth_settings=auth_settings, 156 callback=params.get('callback'), 157 _return_http_data_only=params.get('_return_http_data_only'), 158 _preload_content=params.get('_preload_content', True), 159 _request_timeout=params.get('_request_timeout'), 160 collection_formats=collection_formats)
Adds templates to an envelope.
Adds templates to the specified envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.apply_template_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str preserve_template_recipient:
- DocumentTemplateList document_template_list:
Returns
DocumentTemplateList If the method is called asynchronously, returns the request thread.
def
apply_template_to_document(self, account_id, document_id, envelope_id, **kwargs)
162 def apply_template_to_document(self, account_id, document_id, envelope_id, **kwargs): 163 """ 164 Adds templates to a document in an envelope. 165 Adds templates to a document in the specified envelope. 166 This method makes a synchronous HTTP request by default. To make an 167 asynchronous HTTP request, please define a `callback` function 168 to be invoked when receiving the response. 169 >>> def callback_function(response): 170 >>> pprint(response) 171 >>> 172 >>> thread = api.apply_template_to_document(account_id, document_id, envelope_id, callback=callback_function) 173 174 :param callback function: The callback function 175 for asynchronous request. (optional) 176 :param str account_id: The external account number (int) or account ID Guid. (required) 177 :param str document_id: The ID of the document being accessed. (required) 178 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 179 :param str preserve_template_recipient: 180 :param DocumentTemplateList document_template_list: 181 :return: DocumentTemplateList 182 If the method is called asynchronously, 183 returns the request thread. 184 """ 185 kwargs['_return_http_data_only'] = True 186 if kwargs.get('callback'): 187 return self.apply_template_to_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 188 else: 189 (data) = self.apply_template_to_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 190 return data
Adds templates to a document in an envelope.
Adds templates to a document in the specified envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.apply_template_to_document(account_id, document_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str preserve_template_recipient:
- DocumentTemplateList document_template_list:
Returns
DocumentTemplateList If the method is called asynchronously, returns the request thread.
def
apply_template_to_document_with_http_info(self, account_id, document_id, envelope_id, **kwargs)
192 def apply_template_to_document_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 193 """ 194 Adds templates to a document in an envelope. 195 Adds templates to a document in the specified envelope. 196 This method makes a synchronous HTTP request by default. To make an 197 asynchronous HTTP request, please define a `callback` function 198 to be invoked when receiving the response. 199 >>> def callback_function(response): 200 >>> pprint(response) 201 >>> 202 >>> thread = api.apply_template_to_document_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 203 204 :param callback function: The callback function 205 for asynchronous request. (optional) 206 :param str account_id: The external account number (int) or account ID Guid. (required) 207 :param str document_id: The ID of the document being accessed. (required) 208 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 209 :param str preserve_template_recipient: 210 :param DocumentTemplateList document_template_list: 211 :return: DocumentTemplateList 212 If the method is called asynchronously, 213 returns the request thread. 214 """ 215 216 all_params = ['account_id', 'document_id', 'envelope_id', 'preserve_template_recipient', 'document_template_list'] 217 all_params.append('callback') 218 all_params.append('_return_http_data_only') 219 all_params.append('_preload_content') 220 all_params.append('_request_timeout') 221 222 params = locals() 223 for key, val in iteritems(params['kwargs']): 224 if key not in all_params: 225 raise TypeError( 226 "Got an unexpected keyword argument '%s'" 227 " to method apply_template_to_document" % key 228 ) 229 params[key] = val 230 del params['kwargs'] 231 # verify the required parameter 'account_id' is set 232 if ('account_id' not in params) or (params['account_id'] is None): 233 raise ValueError("Missing the required parameter `account_id` when calling `apply_template_to_document`") 234 # verify the required parameter 'document_id' is set 235 if ('document_id' not in params) or (params['document_id'] is None): 236 raise ValueError("Missing the required parameter `document_id` when calling `apply_template_to_document`") 237 # verify the required parameter 'envelope_id' is set 238 if ('envelope_id' not in params) or (params['envelope_id'] is None): 239 raise ValueError("Missing the required parameter `envelope_id` when calling `apply_template_to_document`") 240 241 242 collection_formats = {} 243 244 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/templates'.replace('{format}', 'json') 245 path_params = {} 246 if 'account_id' in params: 247 path_params['accountId'] = params['account_id'] 248 if 'document_id' in params: 249 path_params['documentId'] = params['document_id'] 250 if 'envelope_id' in params: 251 path_params['envelopeId'] = params['envelope_id'] 252 253 query_params = {} 254 if 'preserve_template_recipient' in params: 255 query_params['preserve_template_recipient'] = params['preserve_template_recipient'] 256 257 header_params = {} 258 259 form_params = [] 260 local_var_files = {} 261 262 body_params = None 263 if 'document_template_list' in params: 264 body_params = params['document_template_list'] 265 # HTTP header `Accept` 266 header_params['Accept'] = self.api_client.\ 267 select_header_accept(['application/json']) 268 269 # Authentication setting 270 auth_settings = [] 271 272 return self.api_client.call_api(resource_path, 'POST', 273 path_params, 274 query_params, 275 header_params, 276 body=body_params, 277 post_params=form_params, 278 files=local_var_files, 279 response_type='DocumentTemplateList', 280 auth_settings=auth_settings, 281 callback=params.get('callback'), 282 _return_http_data_only=params.get('_return_http_data_only'), 283 _preload_content=params.get('_preload_content', True), 284 _request_timeout=params.get('_request_timeout'), 285 collection_formats=collection_formats)
Adds templates to a document in an envelope.
Adds templates to a document in the specified envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.apply_template_to_document_with_http_info(account_id, document_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str preserve_template_recipient:
- DocumentTemplateList document_template_list:
Returns
DocumentTemplateList If the method is called asynchronously, returns the request thread.
def
create_chunked_upload(self, account_id, **kwargs)
287 def create_chunked_upload(self, account_id, **kwargs): 288 """ 289 Initiate a new ChunkedUpload. 290 This method initiates a new chunked upload with the first part of the content. 291 This method makes a synchronous HTTP request by default. To make an 292 asynchronous HTTP request, please define a `callback` function 293 to be invoked when receiving the response. 294 >>> def callback_function(response): 295 >>> pprint(response) 296 >>> 297 >>> thread = api.create_chunked_upload(account_id, callback=callback_function) 298 299 :param callback function: The callback function 300 for asynchronous request. (optional) 301 :param str account_id: The external account number (int) or account ID Guid. (required) 302 :param ChunkedUploadRequest chunked_upload_request: 303 :return: ChunkedUploadResponse 304 If the method is called asynchronously, 305 returns the request thread. 306 """ 307 kwargs['_return_http_data_only'] = True 308 if kwargs.get('callback'): 309 return self.create_chunked_upload_with_http_info(account_id, **kwargs) 310 else: 311 (data) = self.create_chunked_upload_with_http_info(account_id, **kwargs) 312 return data
Initiate a new ChunkedUpload.
This method initiates a new chunked upload with the first part of the content.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_chunked_upload(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- ChunkedUploadRequest chunked_upload_request:
Returns
ChunkedUploadResponse If the method is called asynchronously, returns the request thread.
def
create_chunked_upload_with_http_info(self, account_id, **kwargs)
314 def create_chunked_upload_with_http_info(self, account_id, **kwargs): 315 """ 316 Initiate a new ChunkedUpload. 317 This method initiates a new chunked upload with the first part of the content. 318 This method makes a synchronous HTTP request by default. To make an 319 asynchronous HTTP request, please define a `callback` function 320 to be invoked when receiving the response. 321 >>> def callback_function(response): 322 >>> pprint(response) 323 >>> 324 >>> thread = api.create_chunked_upload_with_http_info(account_id, callback=callback_function) 325 326 :param callback function: The callback function 327 for asynchronous request. (optional) 328 :param str account_id: The external account number (int) or account ID Guid. (required) 329 :param ChunkedUploadRequest chunked_upload_request: 330 :return: ChunkedUploadResponse 331 If the method is called asynchronously, 332 returns the request thread. 333 """ 334 335 all_params = ['account_id', 'chunked_upload_request'] 336 all_params.append('callback') 337 all_params.append('_return_http_data_only') 338 all_params.append('_preload_content') 339 all_params.append('_request_timeout') 340 341 params = locals() 342 for key, val in iteritems(params['kwargs']): 343 if key not in all_params: 344 raise TypeError( 345 "Got an unexpected keyword argument '%s'" 346 " to method create_chunked_upload" % key 347 ) 348 params[key] = val 349 del params['kwargs'] 350 # verify the required parameter 'account_id' is set 351 if ('account_id' not in params) or (params['account_id'] is None): 352 raise ValueError("Missing the required parameter `account_id` when calling `create_chunked_upload`") 353 354 355 collection_formats = {} 356 357 resource_path = '/v2.1/accounts/{accountId}/chunked_uploads'.replace('{format}', 'json') 358 path_params = {} 359 if 'account_id' in params: 360 path_params['accountId'] = params['account_id'] 361 362 query_params = {} 363 364 header_params = {} 365 366 form_params = [] 367 local_var_files = {} 368 369 body_params = None 370 if 'chunked_upload_request' in params: 371 body_params = params['chunked_upload_request'] 372 # HTTP header `Accept` 373 header_params['Accept'] = self.api_client.\ 374 select_header_accept(['application/json']) 375 376 # Authentication setting 377 auth_settings = [] 378 379 return self.api_client.call_api(resource_path, 'POST', 380 path_params, 381 query_params, 382 header_params, 383 body=body_params, 384 post_params=form_params, 385 files=local_var_files, 386 response_type='ChunkedUploadResponse', 387 auth_settings=auth_settings, 388 callback=params.get('callback'), 389 _return_http_data_only=params.get('_return_http_data_only'), 390 _preload_content=params.get('_preload_content', True), 391 _request_timeout=params.get('_request_timeout'), 392 collection_formats=collection_formats)
Initiate a new ChunkedUpload.
This method initiates a new chunked upload with the first part of the content.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_chunked_upload_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- ChunkedUploadRequest chunked_upload_request:
Returns
ChunkedUploadResponse If the method is called asynchronously, returns the request thread.
def
create_console_view(self, account_id, **kwargs)
394 def create_console_view(self, account_id, **kwargs): 395 """ 396 Returns a URL to the authentication view UI. 397 Returns a URL that allows you to embed the authentication view of the DocuSign UI in your applications. 398 This method makes a synchronous HTTP request by default. To make an 399 asynchronous HTTP request, please define a `callback` function 400 to be invoked when receiving the response. 401 >>> def callback_function(response): 402 >>> pprint(response) 403 >>> 404 >>> thread = api.create_console_view(account_id, callback=callback_function) 405 406 :param callback function: The callback function 407 for asynchronous request. (optional) 408 :param str account_id: The external account number (int) or account ID Guid. (required) 409 :param ConsoleViewRequest console_view_request: 410 :return: ViewUrl 411 If the method is called asynchronously, 412 returns the request thread. 413 """ 414 kwargs['_return_http_data_only'] = True 415 if kwargs.get('callback'): 416 return self.create_console_view_with_http_info(account_id, **kwargs) 417 else: 418 (data) = self.create_console_view_with_http_info(account_id, **kwargs) 419 return data
Returns a URL to the authentication view UI.
Returns a URL that allows you to embed the authentication view of the DocuSign UI in your applications.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_console_view(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- ConsoleViewRequest console_view_request:
Returns
ViewUrl If the method is called asynchronously, returns the request thread.
def
create_console_view_with_http_info(self, account_id, **kwargs)
421 def create_console_view_with_http_info(self, account_id, **kwargs): 422 """ 423 Returns a URL to the authentication view UI. 424 Returns a URL that allows you to embed the authentication view of the DocuSign UI in your applications. 425 This method makes a synchronous HTTP request by default. To make an 426 asynchronous HTTP request, please define a `callback` function 427 to be invoked when receiving the response. 428 >>> def callback_function(response): 429 >>> pprint(response) 430 >>> 431 >>> thread = api.create_console_view_with_http_info(account_id, callback=callback_function) 432 433 :param callback function: The callback function 434 for asynchronous request. (optional) 435 :param str account_id: The external account number (int) or account ID Guid. (required) 436 :param ConsoleViewRequest console_view_request: 437 :return: ViewUrl 438 If the method is called asynchronously, 439 returns the request thread. 440 """ 441 442 all_params = ['account_id', 'console_view_request'] 443 all_params.append('callback') 444 all_params.append('_return_http_data_only') 445 all_params.append('_preload_content') 446 all_params.append('_request_timeout') 447 448 params = locals() 449 for key, val in iteritems(params['kwargs']): 450 if key not in all_params: 451 raise TypeError( 452 "Got an unexpected keyword argument '%s'" 453 " to method create_console_view" % key 454 ) 455 params[key] = val 456 del params['kwargs'] 457 # verify the required parameter 'account_id' is set 458 if ('account_id' not in params) or (params['account_id'] is None): 459 raise ValueError("Missing the required parameter `account_id` when calling `create_console_view`") 460 461 462 collection_formats = {} 463 464 resource_path = '/v2.1/accounts/{accountId}/views/console'.replace('{format}', 'json') 465 path_params = {} 466 if 'account_id' in params: 467 path_params['accountId'] = params['account_id'] 468 469 query_params = {} 470 471 header_params = {} 472 473 form_params = [] 474 local_var_files = {} 475 476 body_params = None 477 if 'console_view_request' in params: 478 body_params = params['console_view_request'] 479 # HTTP header `Accept` 480 header_params['Accept'] = self.api_client.\ 481 select_header_accept(['application/json']) 482 483 # Authentication setting 484 auth_settings = [] 485 486 return self.api_client.call_api(resource_path, 'POST', 487 path_params, 488 query_params, 489 header_params, 490 body=body_params, 491 post_params=form_params, 492 files=local_var_files, 493 response_type='ViewUrl', 494 auth_settings=auth_settings, 495 callback=params.get('callback'), 496 _return_http_data_only=params.get('_return_http_data_only'), 497 _preload_content=params.get('_preload_content', True), 498 _request_timeout=params.get('_request_timeout'), 499 collection_formats=collection_formats)
Returns a URL to the authentication view UI.
Returns a URL that allows you to embed the authentication view of the DocuSign UI in your applications.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_console_view_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- ConsoleViewRequest console_view_request:
Returns
ViewUrl If the method is called asynchronously, returns the request thread.
def
create_correct_view(self, account_id, envelope_id, **kwargs)
501 def create_correct_view(self, account_id, envelope_id, **kwargs): 502 """ 503 Returns a URL to the envelope correction UI. 504 Returns a URL that allows you to embed the envelope correction view of the DocuSign UI in your applications. Important: iFrames should not be used for embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends using a WebView. 505 This method makes a synchronous HTTP request by default. To make an 506 asynchronous HTTP request, please define a `callback` function 507 to be invoked when receiving the response. 508 >>> def callback_function(response): 509 >>> pprint(response) 510 >>> 511 >>> thread = api.create_correct_view(account_id, envelope_id, callback=callback_function) 512 513 :param callback function: The callback function 514 for asynchronous request. (optional) 515 :param str account_id: The external account number (int) or account ID Guid. (required) 516 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 517 :param EnvelopeViewRequest envelope_view_request: 518 :return: ViewUrl 519 If the method is called asynchronously, 520 returns the request thread. 521 """ 522 kwargs['_return_http_data_only'] = True 523 if kwargs.get('callback'): 524 return self.create_correct_view_with_http_info(account_id, envelope_id, **kwargs) 525 else: 526 (data) = self.create_correct_view_with_http_info(account_id, envelope_id, **kwargs) 527 return data
Returns a URL to the envelope correction UI.
Returns a URL that allows you to embed the envelope correction view of the DocuSign UI in your applications. Important: iFrames should not be used for embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends using a WebView.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_correct_view(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- EnvelopeViewRequest envelope_view_request:
Returns
ViewUrl If the method is called asynchronously, returns the request thread.
def
create_correct_view_with_http_info(self, account_id, envelope_id, **kwargs)
529 def create_correct_view_with_http_info(self, account_id, envelope_id, **kwargs): 530 """ 531 Returns a URL to the envelope correction UI. 532 Returns a URL that allows you to embed the envelope correction view of the DocuSign UI in your applications. Important: iFrames should not be used for embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends using a WebView. 533 This method makes a synchronous HTTP request by default. To make an 534 asynchronous HTTP request, please define a `callback` function 535 to be invoked when receiving the response. 536 >>> def callback_function(response): 537 >>> pprint(response) 538 >>> 539 >>> thread = api.create_correct_view_with_http_info(account_id, envelope_id, callback=callback_function) 540 541 :param callback function: The callback function 542 for asynchronous request. (optional) 543 :param str account_id: The external account number (int) or account ID Guid. (required) 544 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 545 :param EnvelopeViewRequest envelope_view_request: 546 :return: ViewUrl 547 If the method is called asynchronously, 548 returns the request thread. 549 """ 550 551 all_params = ['account_id', 'envelope_id', 'envelope_view_request'] 552 all_params.append('callback') 553 all_params.append('_return_http_data_only') 554 all_params.append('_preload_content') 555 all_params.append('_request_timeout') 556 557 params = locals() 558 for key, val in iteritems(params['kwargs']): 559 if key not in all_params: 560 raise TypeError( 561 "Got an unexpected keyword argument '%s'" 562 " to method create_correct_view" % key 563 ) 564 params[key] = val 565 del params['kwargs'] 566 # verify the required parameter 'account_id' is set 567 if ('account_id' not in params) or (params['account_id'] is None): 568 raise ValueError("Missing the required parameter `account_id` when calling `create_correct_view`") 569 # verify the required parameter 'envelope_id' is set 570 if ('envelope_id' not in params) or (params['envelope_id'] is None): 571 raise ValueError("Missing the required parameter `envelope_id` when calling `create_correct_view`") 572 573 574 collection_formats = {} 575 576 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/correct'.replace('{format}', 'json') 577 path_params = {} 578 if 'account_id' in params: 579 path_params['accountId'] = params['account_id'] 580 if 'envelope_id' in params: 581 path_params['envelopeId'] = params['envelope_id'] 582 583 query_params = {} 584 585 header_params = {} 586 587 form_params = [] 588 local_var_files = {} 589 590 body_params = None 591 if 'envelope_view_request' in params: 592 body_params = params['envelope_view_request'] 593 # HTTP header `Accept` 594 header_params['Accept'] = self.api_client.\ 595 select_header_accept(['application/json']) 596 597 # Authentication setting 598 auth_settings = [] 599 600 return self.api_client.call_api(resource_path, 'POST', 601 path_params, 602 query_params, 603 header_params, 604 body=body_params, 605 post_params=form_params, 606 files=local_var_files, 607 response_type='ViewUrl', 608 auth_settings=auth_settings, 609 callback=params.get('callback'), 610 _return_http_data_only=params.get('_return_http_data_only'), 611 _preload_content=params.get('_preload_content', True), 612 _request_timeout=params.get('_request_timeout'), 613 collection_formats=collection_formats)
Returns a URL to the envelope correction UI.
Returns a URL that allows you to embed the envelope correction view of the DocuSign UI in your applications. Important: iFrames should not be used for embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends using a WebView.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_correct_view_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- EnvelopeViewRequest envelope_view_request:
Returns
ViewUrl If the method is called asynchronously, returns the request thread.
def
create_custom_fields(self, account_id, envelope_id, **kwargs)
615 def create_custom_fields(self, account_id, envelope_id, **kwargs): 616 """ 617 Updates envelope custom fields for an envelope. 618 Updates the envelope custom fields for draft and in-process envelopes. Each custom field used in an envelope must have a unique name. 619 This method makes a synchronous HTTP request by default. To make an 620 asynchronous HTTP request, please define a `callback` function 621 to be invoked when receiving the response. 622 >>> def callback_function(response): 623 >>> pprint(response) 624 >>> 625 >>> thread = api.create_custom_fields(account_id, envelope_id, callback=callback_function) 626 627 :param callback function: The callback function 628 for asynchronous request. (optional) 629 :param str account_id: The external account number (int) or account ID Guid. (required) 630 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 631 :param CustomFields custom_fields: 632 :return: CustomFields 633 If the method is called asynchronously, 634 returns the request thread. 635 """ 636 kwargs['_return_http_data_only'] = True 637 if kwargs.get('callback'): 638 return self.create_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 639 else: 640 (data) = self.create_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 641 return data
Updates envelope custom fields for an envelope.
Updates the envelope custom fields for draft and in-process envelopes. Each custom field used in an envelope must have a unique name.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_custom_fields(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- CustomFields custom_fields:
Returns
CustomFields If the method is called asynchronously, returns the request thread.
def
create_custom_fields_with_http_info(self, account_id, envelope_id, **kwargs)
643 def create_custom_fields_with_http_info(self, account_id, envelope_id, **kwargs): 644 """ 645 Updates envelope custom fields for an envelope. 646 Updates the envelope custom fields for draft and in-process envelopes. Each custom field used in an envelope must have a unique name. 647 This method makes a synchronous HTTP request by default. To make an 648 asynchronous HTTP request, please define a `callback` function 649 to be invoked when receiving the response. 650 >>> def callback_function(response): 651 >>> pprint(response) 652 >>> 653 >>> thread = api.create_custom_fields_with_http_info(account_id, envelope_id, callback=callback_function) 654 655 :param callback function: The callback function 656 for asynchronous request. (optional) 657 :param str account_id: The external account number (int) or account ID Guid. (required) 658 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 659 :param CustomFields custom_fields: 660 :return: CustomFields 661 If the method is called asynchronously, 662 returns the request thread. 663 """ 664 665 all_params = ['account_id', 'envelope_id', 'custom_fields'] 666 all_params.append('callback') 667 all_params.append('_return_http_data_only') 668 all_params.append('_preload_content') 669 all_params.append('_request_timeout') 670 671 params = locals() 672 for key, val in iteritems(params['kwargs']): 673 if key not in all_params: 674 raise TypeError( 675 "Got an unexpected keyword argument '%s'" 676 " to method create_custom_fields" % key 677 ) 678 params[key] = val 679 del params['kwargs'] 680 # verify the required parameter 'account_id' is set 681 if ('account_id' not in params) or (params['account_id'] is None): 682 raise ValueError("Missing the required parameter `account_id` when calling `create_custom_fields`") 683 # verify the required parameter 'envelope_id' is set 684 if ('envelope_id' not in params) or (params['envelope_id'] is None): 685 raise ValueError("Missing the required parameter `envelope_id` when calling `create_custom_fields`") 686 687 688 collection_formats = {} 689 690 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/custom_fields'.replace('{format}', 'json') 691 path_params = {} 692 if 'account_id' in params: 693 path_params['accountId'] = params['account_id'] 694 if 'envelope_id' in params: 695 path_params['envelopeId'] = params['envelope_id'] 696 697 query_params = {} 698 699 header_params = {} 700 701 form_params = [] 702 local_var_files = {} 703 704 body_params = None 705 if 'custom_fields' in params: 706 body_params = params['custom_fields'] 707 # HTTP header `Accept` 708 header_params['Accept'] = self.api_client.\ 709 select_header_accept(['application/json']) 710 711 # Authentication setting 712 auth_settings = [] 713 714 return self.api_client.call_api(resource_path, 'POST', 715 path_params, 716 query_params, 717 header_params, 718 body=body_params, 719 post_params=form_params, 720 files=local_var_files, 721 response_type='CustomFields', 722 auth_settings=auth_settings, 723 callback=params.get('callback'), 724 _return_http_data_only=params.get('_return_http_data_only'), 725 _preload_content=params.get('_preload_content', True), 726 _request_timeout=params.get('_request_timeout'), 727 collection_formats=collection_formats)
Updates envelope custom fields for an envelope.
Updates the envelope custom fields for draft and in-process envelopes. Each custom field used in an envelope must have a unique name.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_custom_fields_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- CustomFields custom_fields:
Returns
CustomFields If the method is called asynchronously, returns the request thread.
def
create_document_fields(self, account_id, document_id, envelope_id, **kwargs)
729 def create_document_fields(self, account_id, document_id, envelope_id, **kwargs): 730 """ 731 Creates custom document fields in an existing envelope document. 732 Creates custom document fields in an existing envelope document. 733 This method makes a synchronous HTTP request by default. To make an 734 asynchronous HTTP request, please define a `callback` function 735 to be invoked when receiving the response. 736 >>> def callback_function(response): 737 >>> pprint(response) 738 >>> 739 >>> thread = api.create_document_fields(account_id, document_id, envelope_id, callback=callback_function) 740 741 :param callback function: The callback function 742 for asynchronous request. (optional) 743 :param str account_id: The external account number (int) or account ID Guid. (required) 744 :param str document_id: The ID of the document being accessed. (required) 745 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 746 :param DocumentFieldsInformation document_fields_information: 747 :return: DocumentFieldsInformation 748 If the method is called asynchronously, 749 returns the request thread. 750 """ 751 kwargs['_return_http_data_only'] = True 752 if kwargs.get('callback'): 753 return self.create_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 754 else: 755 (data) = self.create_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 756 return data
Creates custom document fields in an existing envelope document.
Creates custom document fields in an existing envelope document.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_document_fields(account_id, document_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- DocumentFieldsInformation document_fields_information:
Returns
DocumentFieldsInformation If the method is called asynchronously, returns the request thread.
def
create_document_fields_with_http_info(self, account_id, document_id, envelope_id, **kwargs)
758 def create_document_fields_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 759 """ 760 Creates custom document fields in an existing envelope document. 761 Creates custom document fields in an existing envelope document. 762 This method makes a synchronous HTTP request by default. To make an 763 asynchronous HTTP request, please define a `callback` function 764 to be invoked when receiving the response. 765 >>> def callback_function(response): 766 >>> pprint(response) 767 >>> 768 >>> thread = api.create_document_fields_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 769 770 :param callback function: The callback function 771 for asynchronous request. (optional) 772 :param str account_id: The external account number (int) or account ID Guid. (required) 773 :param str document_id: The ID of the document being accessed. (required) 774 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 775 :param DocumentFieldsInformation document_fields_information: 776 :return: DocumentFieldsInformation 777 If the method is called asynchronously, 778 returns the request thread. 779 """ 780 781 all_params = ['account_id', 'document_id', 'envelope_id', 'document_fields_information'] 782 all_params.append('callback') 783 all_params.append('_return_http_data_only') 784 all_params.append('_preload_content') 785 all_params.append('_request_timeout') 786 787 params = locals() 788 for key, val in iteritems(params['kwargs']): 789 if key not in all_params: 790 raise TypeError( 791 "Got an unexpected keyword argument '%s'" 792 " to method create_document_fields" % key 793 ) 794 params[key] = val 795 del params['kwargs'] 796 # verify the required parameter 'account_id' is set 797 if ('account_id' not in params) or (params['account_id'] is None): 798 raise ValueError("Missing the required parameter `account_id` when calling `create_document_fields`") 799 # verify the required parameter 'document_id' is set 800 if ('document_id' not in params) or (params['document_id'] is None): 801 raise ValueError("Missing the required parameter `document_id` when calling `create_document_fields`") 802 # verify the required parameter 'envelope_id' is set 803 if ('envelope_id' not in params) or (params['envelope_id'] is None): 804 raise ValueError("Missing the required parameter `envelope_id` when calling `create_document_fields`") 805 806 807 collection_formats = {} 808 809 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/fields'.replace('{format}', 'json') 810 path_params = {} 811 if 'account_id' in params: 812 path_params['accountId'] = params['account_id'] 813 if 'document_id' in params: 814 path_params['documentId'] = params['document_id'] 815 if 'envelope_id' in params: 816 path_params['envelopeId'] = params['envelope_id'] 817 818 query_params = {} 819 820 header_params = {} 821 822 form_params = [] 823 local_var_files = {} 824 825 body_params = None 826 if 'document_fields_information' in params: 827 body_params = params['document_fields_information'] 828 # HTTP header `Accept` 829 header_params['Accept'] = self.api_client.\ 830 select_header_accept(['application/json']) 831 832 # Authentication setting 833 auth_settings = [] 834 835 return self.api_client.call_api(resource_path, 'POST', 836 path_params, 837 query_params, 838 header_params, 839 body=body_params, 840 post_params=form_params, 841 files=local_var_files, 842 response_type='DocumentFieldsInformation', 843 auth_settings=auth_settings, 844 callback=params.get('callback'), 845 _return_http_data_only=params.get('_return_http_data_only'), 846 _preload_content=params.get('_preload_content', True), 847 _request_timeout=params.get('_request_timeout'), 848 collection_formats=collection_formats)
Creates custom document fields in an existing envelope document.
Creates custom document fields in an existing envelope document.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_document_fields_with_http_info(account_id, document_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- DocumentFieldsInformation document_fields_information:
Returns
DocumentFieldsInformation If the method is called asynchronously, returns the request thread.
def
create_document_responsive_html_preview(self, account_id, document_id, envelope_id, **kwargs)
850 def create_document_responsive_html_preview(self, account_id, document_id, envelope_id, **kwargs): 851 """ 852 Get Responsive HTML Preview for a document in an envelope. 853 Creates a preview of the [responsive](/docs/esign-rest-api/esign101/concepts/responsive/) HTML version of a specific document. This method enables you to preview a PDF document conversion to responsive HTML across device types prior to sending. The request body is a `documentHtmlDefinition` object, which holds the responsive signing parameters that define how to generate the HTML version of the signing document. 854 This method makes a synchronous HTTP request by default. To make an 855 asynchronous HTTP request, please define a `callback` function 856 to be invoked when receiving the response. 857 >>> def callback_function(response): 858 >>> pprint(response) 859 >>> 860 >>> thread = api.create_document_responsive_html_preview(account_id, document_id, envelope_id, callback=callback_function) 861 862 :param callback function: The callback function 863 for asynchronous request. (optional) 864 :param str account_id: The external account number (int) or account ID Guid. (required) 865 :param str document_id: The ID of the document being accessed. (required) 866 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 867 :param DocumentHtmlDefinition document_html_definition: 868 :return: DocumentHtmlDefinitions 869 If the method is called asynchronously, 870 returns the request thread. 871 """ 872 kwargs['_return_http_data_only'] = True 873 if kwargs.get('callback'): 874 return self.create_document_responsive_html_preview_with_http_info(account_id, document_id, envelope_id, **kwargs) 875 else: 876 (data) = self.create_document_responsive_html_preview_with_http_info(account_id, document_id, envelope_id, **kwargs) 877 return data
Get Responsive HTML Preview for a document in an envelope.
Creates a preview of the responsive HTML version of a specific document. This method enables you to preview a PDF document conversion to responsive HTML across device types prior to sending. The request body is a documentHtmlDefinition object, which holds the responsive signing parameters that define how to generate the HTML version of the signing document.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_document_responsive_html_preview(account_id, document_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- DocumentHtmlDefinition document_html_definition:
Returns
DocumentHtmlDefinitions If the method is called asynchronously, returns the request thread.
def
create_document_responsive_html_preview_with_http_info(self, account_id, document_id, envelope_id, **kwargs)
879 def create_document_responsive_html_preview_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 880 """ 881 Get Responsive HTML Preview for a document in an envelope. 882 Creates a preview of the [responsive](/docs/esign-rest-api/esign101/concepts/responsive/) HTML version of a specific document. This method enables you to preview a PDF document conversion to responsive HTML across device types prior to sending. The request body is a `documentHtmlDefinition` object, which holds the responsive signing parameters that define how to generate the HTML version of the signing document. 883 This method makes a synchronous HTTP request by default. To make an 884 asynchronous HTTP request, please define a `callback` function 885 to be invoked when receiving the response. 886 >>> def callback_function(response): 887 >>> pprint(response) 888 >>> 889 >>> thread = api.create_document_responsive_html_preview_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 890 891 :param callback function: The callback function 892 for asynchronous request. (optional) 893 :param str account_id: The external account number (int) or account ID Guid. (required) 894 :param str document_id: The ID of the document being accessed. (required) 895 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 896 :param DocumentHtmlDefinition document_html_definition: 897 :return: DocumentHtmlDefinitions 898 If the method is called asynchronously, 899 returns the request thread. 900 """ 901 902 all_params = ['account_id', 'document_id', 'envelope_id', 'document_html_definition'] 903 all_params.append('callback') 904 all_params.append('_return_http_data_only') 905 all_params.append('_preload_content') 906 all_params.append('_request_timeout') 907 908 params = locals() 909 for key, val in iteritems(params['kwargs']): 910 if key not in all_params: 911 raise TypeError( 912 "Got an unexpected keyword argument '%s'" 913 " to method create_document_responsive_html_preview" % key 914 ) 915 params[key] = val 916 del params['kwargs'] 917 # verify the required parameter 'account_id' is set 918 if ('account_id' not in params) or (params['account_id'] is None): 919 raise ValueError("Missing the required parameter `account_id` when calling `create_document_responsive_html_preview`") 920 # verify the required parameter 'document_id' is set 921 if ('document_id' not in params) or (params['document_id'] is None): 922 raise ValueError("Missing the required parameter `document_id` when calling `create_document_responsive_html_preview`") 923 # verify the required parameter 'envelope_id' is set 924 if ('envelope_id' not in params) or (params['envelope_id'] is None): 925 raise ValueError("Missing the required parameter `envelope_id` when calling `create_document_responsive_html_preview`") 926 927 928 collection_formats = {} 929 930 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/responsive_html_preview'.replace('{format}', 'json') 931 path_params = {} 932 if 'account_id' in params: 933 path_params['accountId'] = params['account_id'] 934 if 'document_id' in params: 935 path_params['documentId'] = params['document_id'] 936 if 'envelope_id' in params: 937 path_params['envelopeId'] = params['envelope_id'] 938 939 query_params = {} 940 941 header_params = {} 942 943 form_params = [] 944 local_var_files = {} 945 946 body_params = None 947 if 'document_html_definition' in params: 948 body_params = params['document_html_definition'] 949 # HTTP header `Accept` 950 header_params['Accept'] = self.api_client.\ 951 select_header_accept(['application/json']) 952 953 # Authentication setting 954 auth_settings = [] 955 956 return self.api_client.call_api(resource_path, 'POST', 957 path_params, 958 query_params, 959 header_params, 960 body=body_params, 961 post_params=form_params, 962 files=local_var_files, 963 response_type='DocumentHtmlDefinitions', 964 auth_settings=auth_settings, 965 callback=params.get('callback'), 966 _return_http_data_only=params.get('_return_http_data_only'), 967 _preload_content=params.get('_preload_content', True), 968 _request_timeout=params.get('_request_timeout'), 969 collection_formats=collection_formats)
Get Responsive HTML Preview for a document in an envelope.
Creates a preview of the responsive HTML version of a specific document. This method enables you to preview a PDF document conversion to responsive HTML across device types prior to sending. The request body is a documentHtmlDefinition object, which holds the responsive signing parameters that define how to generate the HTML version of the signing document.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_document_responsive_html_preview_with_http_info(account_id, document_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- DocumentHtmlDefinition document_html_definition:
Returns
DocumentHtmlDefinitions If the method is called asynchronously, returns the request thread.
def
create_document_tabs(self, account_id, document_id, envelope_id, **kwargs)
971 def create_document_tabs(self, account_id, document_id, envelope_id, **kwargs): 972 """ 973 Adds the tabs to an envelope document 974 Adds tabs to the document specified by `documentId` in the envelope specified by `envelopeId`. In the request body, you only need to specify the tabs that your are adding. For example, to add a text [prefill tab](/docs/esign-rest-api/reference/envelopes/envelopedocumenttabs/create/#definition__tabs_prefilltabs), your request body might look like this: ``` { \"prefillTabs\": { \"textTabs\": [ { \"value\": \"a prefill text tab\", \"pageNumber\": \"1\", \"documentId\": \"1\", \"xPosition\": 316, \"yPosition\": 97 } ] } } ``` 975 This method makes a synchronous HTTP request by default. To make an 976 asynchronous HTTP request, please define a `callback` function 977 to be invoked when receiving the response. 978 >>> def callback_function(response): 979 >>> pprint(response) 980 >>> 981 >>> thread = api.create_document_tabs(account_id, document_id, envelope_id, callback=callback_function) 982 983 :param callback function: The callback function 984 for asynchronous request. (optional) 985 :param str account_id: The external account number (int) or account ID Guid. (required) 986 :param str document_id: The ID of the document being accessed. (required) 987 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 988 :param Tabs tabs: 989 :return: Tabs 990 If the method is called asynchronously, 991 returns the request thread. 992 """ 993 kwargs['_return_http_data_only'] = True 994 if kwargs.get('callback'): 995 return self.create_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 996 else: 997 (data) = self.create_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 998 return data
Adds the tabs to an envelope document
Adds tabs to the document specified by documentId in the envelope specified by envelopeId. In the request body, you only need to specify the tabs that your are adding. For example, to add a text prefill tab, your request body might look like this: { "prefillTabs": { "textTabs": [ { "value": "a prefill text tab", "pageNumber": "1", "documentId": "1", "xPosition": 316, "yPosition": 97 } ] } }
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_document_tabs(account_id, document_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- Tabs tabs:
Returns
Tabs If the method is called asynchronously, returns the request thread.
def
create_document_tabs_with_http_info(self, account_id, document_id, envelope_id, **kwargs)
1000 def create_document_tabs_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 1001 """ 1002 Adds the tabs to an envelope document 1003 Adds tabs to the document specified by `documentId` in the envelope specified by `envelopeId`. In the request body, you only need to specify the tabs that your are adding. For example, to add a text [prefill tab](/docs/esign-rest-api/reference/envelopes/envelopedocumenttabs/create/#definition__tabs_prefilltabs), your request body might look like this: ``` { \"prefillTabs\": { \"textTabs\": [ { \"value\": \"a prefill text tab\", \"pageNumber\": \"1\", \"documentId\": \"1\", \"xPosition\": 316, \"yPosition\": 97 } ] } } ``` 1004 This method makes a synchronous HTTP request by default. To make an 1005 asynchronous HTTP request, please define a `callback` function 1006 to be invoked when receiving the response. 1007 >>> def callback_function(response): 1008 >>> pprint(response) 1009 >>> 1010 >>> thread = api.create_document_tabs_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 1011 1012 :param callback function: The callback function 1013 for asynchronous request. (optional) 1014 :param str account_id: The external account number (int) or account ID Guid. (required) 1015 :param str document_id: The ID of the document being accessed. (required) 1016 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1017 :param Tabs tabs: 1018 :return: Tabs 1019 If the method is called asynchronously, 1020 returns the request thread. 1021 """ 1022 1023 all_params = ['account_id', 'document_id', 'envelope_id', 'tabs'] 1024 all_params.append('callback') 1025 all_params.append('_return_http_data_only') 1026 all_params.append('_preload_content') 1027 all_params.append('_request_timeout') 1028 1029 params = locals() 1030 for key, val in iteritems(params['kwargs']): 1031 if key not in all_params: 1032 raise TypeError( 1033 "Got an unexpected keyword argument '%s'" 1034 " to method create_document_tabs" % key 1035 ) 1036 params[key] = val 1037 del params['kwargs'] 1038 # verify the required parameter 'account_id' is set 1039 if ('account_id' not in params) or (params['account_id'] is None): 1040 raise ValueError("Missing the required parameter `account_id` when calling `create_document_tabs`") 1041 # verify the required parameter 'document_id' is set 1042 if ('document_id' not in params) or (params['document_id'] is None): 1043 raise ValueError("Missing the required parameter `document_id` when calling `create_document_tabs`") 1044 # verify the required parameter 'envelope_id' is set 1045 if ('envelope_id' not in params) or (params['envelope_id'] is None): 1046 raise ValueError("Missing the required parameter `envelope_id` when calling `create_document_tabs`") 1047 1048 1049 collection_formats = {} 1050 1051 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/tabs'.replace('{format}', 'json') 1052 path_params = {} 1053 if 'account_id' in params: 1054 path_params['accountId'] = params['account_id'] 1055 if 'document_id' in params: 1056 path_params['documentId'] = params['document_id'] 1057 if 'envelope_id' in params: 1058 path_params['envelopeId'] = params['envelope_id'] 1059 1060 query_params = {} 1061 1062 header_params = {} 1063 1064 form_params = [] 1065 local_var_files = {} 1066 1067 body_params = None 1068 if 'tabs' in params: 1069 body_params = params['tabs'] 1070 # HTTP header `Accept` 1071 header_params['Accept'] = self.api_client.\ 1072 select_header_accept(['application/json']) 1073 1074 # Authentication setting 1075 auth_settings = [] 1076 1077 return self.api_client.call_api(resource_path, 'POST', 1078 path_params, 1079 query_params, 1080 header_params, 1081 body=body_params, 1082 post_params=form_params, 1083 files=local_var_files, 1084 response_type='Tabs', 1085 auth_settings=auth_settings, 1086 callback=params.get('callback'), 1087 _return_http_data_only=params.get('_return_http_data_only'), 1088 _preload_content=params.get('_preload_content', True), 1089 _request_timeout=params.get('_request_timeout'), 1090 collection_formats=collection_formats)
Adds the tabs to an envelope document
Adds tabs to the document specified by documentId in the envelope specified by envelopeId. In the request body, you only need to specify the tabs that your are adding. For example, to add a text prefill tab, your request body might look like this: { "prefillTabs": { "textTabs": [ { "value": "a prefill text tab", "pageNumber": "1", "documentId": "1", "xPosition": 316, "yPosition": 97 } ] } }
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_document_tabs_with_http_info(account_id, document_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- Tabs tabs:
Returns
Tabs If the method is called asynchronously, returns the request thread.
def
create_edit_view(self, account_id, envelope_id, **kwargs)
1092 def create_edit_view(self, account_id, envelope_id, **kwargs): 1093 """ 1094 Returns a URL to the edit view UI. 1095 Returns a URL that allows you to embed the edit view of the DocuSign UI in your applications. This is a one-time use login token that allows the user to be placed into the DocuSign editing view. Upon sending completion, the user is returned to the return URL provided by the API application. Important: iFrames should not be used for embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends using a WebView. 1096 This method makes a synchronous HTTP request by default. To make an 1097 asynchronous HTTP request, please define a `callback` function 1098 to be invoked when receiving the response. 1099 >>> def callback_function(response): 1100 >>> pprint(response) 1101 >>> 1102 >>> thread = api.create_edit_view(account_id, envelope_id, callback=callback_function) 1103 1104 :param callback function: The callback function 1105 for asynchronous request. (optional) 1106 :param str account_id: The external account number (int) or account ID Guid. (required) 1107 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1108 :param EnvelopeViewRequest envelope_view_request: 1109 :return: ViewUrl 1110 If the method is called asynchronously, 1111 returns the request thread. 1112 """ 1113 kwargs['_return_http_data_only'] = True 1114 if kwargs.get('callback'): 1115 return self.create_edit_view_with_http_info(account_id, envelope_id, **kwargs) 1116 else: 1117 (data) = self.create_edit_view_with_http_info(account_id, envelope_id, **kwargs) 1118 return data
Returns a URL to the edit view UI.
Returns a URL that allows you to embed the edit view of the DocuSign UI in your applications. This is a one-time use login token that allows the user to be placed into the DocuSign editing view. Upon sending completion, the user is returned to the return URL provided by the API application. Important: iFrames should not be used for embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends using a WebView.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_edit_view(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- EnvelopeViewRequest envelope_view_request:
Returns
ViewUrl If the method is called asynchronously, returns the request thread.
def
create_edit_view_with_http_info(self, account_id, envelope_id, **kwargs)
1120 def create_edit_view_with_http_info(self, account_id, envelope_id, **kwargs): 1121 """ 1122 Returns a URL to the edit view UI. 1123 Returns a URL that allows you to embed the edit view of the DocuSign UI in your applications. This is a one-time use login token that allows the user to be placed into the DocuSign editing view. Upon sending completion, the user is returned to the return URL provided by the API application. Important: iFrames should not be used for embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends using a WebView. 1124 This method makes a synchronous HTTP request by default. To make an 1125 asynchronous HTTP request, please define a `callback` function 1126 to be invoked when receiving the response. 1127 >>> def callback_function(response): 1128 >>> pprint(response) 1129 >>> 1130 >>> thread = api.create_edit_view_with_http_info(account_id, envelope_id, callback=callback_function) 1131 1132 :param callback function: The callback function 1133 for asynchronous request. (optional) 1134 :param str account_id: The external account number (int) or account ID Guid. (required) 1135 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1136 :param EnvelopeViewRequest envelope_view_request: 1137 :return: ViewUrl 1138 If the method is called asynchronously, 1139 returns the request thread. 1140 """ 1141 1142 all_params = ['account_id', 'envelope_id', 'envelope_view_request'] 1143 all_params.append('callback') 1144 all_params.append('_return_http_data_only') 1145 all_params.append('_preload_content') 1146 all_params.append('_request_timeout') 1147 1148 params = locals() 1149 for key, val in iteritems(params['kwargs']): 1150 if key not in all_params: 1151 raise TypeError( 1152 "Got an unexpected keyword argument '%s'" 1153 " to method create_edit_view" % key 1154 ) 1155 params[key] = val 1156 del params['kwargs'] 1157 # verify the required parameter 'account_id' is set 1158 if ('account_id' not in params) or (params['account_id'] is None): 1159 raise ValueError("Missing the required parameter `account_id` when calling `create_edit_view`") 1160 # verify the required parameter 'envelope_id' is set 1161 if ('envelope_id' not in params) or (params['envelope_id'] is None): 1162 raise ValueError("Missing the required parameter `envelope_id` when calling `create_edit_view`") 1163 1164 1165 collection_formats = {} 1166 1167 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/edit'.replace('{format}', 'json') 1168 path_params = {} 1169 if 'account_id' in params: 1170 path_params['accountId'] = params['account_id'] 1171 if 'envelope_id' in params: 1172 path_params['envelopeId'] = params['envelope_id'] 1173 1174 query_params = {} 1175 1176 header_params = {} 1177 1178 form_params = [] 1179 local_var_files = {} 1180 1181 body_params = None 1182 if 'envelope_view_request' in params: 1183 body_params = params['envelope_view_request'] 1184 # HTTP header `Accept` 1185 header_params['Accept'] = self.api_client.\ 1186 select_header_accept(['application/json']) 1187 1188 # Authentication setting 1189 auth_settings = [] 1190 1191 return self.api_client.call_api(resource_path, 'POST', 1192 path_params, 1193 query_params, 1194 header_params, 1195 body=body_params, 1196 post_params=form_params, 1197 files=local_var_files, 1198 response_type='ViewUrl', 1199 auth_settings=auth_settings, 1200 callback=params.get('callback'), 1201 _return_http_data_only=params.get('_return_http_data_only'), 1202 _preload_content=params.get('_preload_content', True), 1203 _request_timeout=params.get('_request_timeout'), 1204 collection_formats=collection_formats)
Returns a URL to the edit view UI.
Returns a URL that allows you to embed the edit view of the DocuSign UI in your applications. This is a one-time use login token that allows the user to be placed into the DocuSign editing view. Upon sending completion, the user is returned to the return URL provided by the API application. Important: iFrames should not be used for embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends using a WebView.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_edit_view_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- EnvelopeViewRequest envelope_view_request:
Returns
ViewUrl If the method is called asynchronously, returns the request thread.
def
create_email_settings(self, account_id, envelope_id, **kwargs)
1206 def create_email_settings(self, account_id, envelope_id, **kwargs): 1207 """ 1208 Adds email setting overrides to an envelope. 1209 Adds email override settings, changing the email address to reply to an email address, name, or the BCC for email archive information, for the envelope. Note that adding email settings will only affect email communications that occur after the addition was made. ### Important: The BCC Email address feature is designed to provide a copy of all email communications for external archiving purposes. DocuSign recommends that envelopes sent using the BCC for Email Archive feature, including the BCC Email Override option, include additional signer authentication options. To send a copy of the envelope to a recipient who does not need to sign, use a Carbon Copies or Certified Deliveries Recipient Type. 1210 This method makes a synchronous HTTP request by default. To make an 1211 asynchronous HTTP request, please define a `callback` function 1212 to be invoked when receiving the response. 1213 >>> def callback_function(response): 1214 >>> pprint(response) 1215 >>> 1216 >>> thread = api.create_email_settings(account_id, envelope_id, callback=callback_function) 1217 1218 :param callback function: The callback function 1219 for asynchronous request. (optional) 1220 :param str account_id: The external account number (int) or account ID Guid. (required) 1221 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1222 :param EmailSettings email_settings: 1223 :return: EmailSettings 1224 If the method is called asynchronously, 1225 returns the request thread. 1226 """ 1227 kwargs['_return_http_data_only'] = True 1228 if kwargs.get('callback'): 1229 return self.create_email_settings_with_http_info(account_id, envelope_id, **kwargs) 1230 else: 1231 (data) = self.create_email_settings_with_http_info(account_id, envelope_id, **kwargs) 1232 return data
Adds email setting overrides to an envelope.
Adds email override settings, changing the email address to reply to an email address, name, or the BCC for email archive information, for the envelope. Note that adding email settings will only affect email communications that occur after the addition was made. ### Important: The BCC Email address feature is designed to provide a copy of all email communications for external archiving purposes. DocuSign recommends that envelopes sent using the BCC for Email Archive feature, including the BCC Email Override option, include additional signer authentication options. To send a copy of the envelope to a recipient who does not need to sign, use a Carbon Copies or Certified Deliveries Recipient Type.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_email_settings(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- EmailSettings email_settings:
Returns
EmailSettings If the method is called asynchronously, returns the request thread.
def
create_email_settings_with_http_info(self, account_id, envelope_id, **kwargs)
1234 def create_email_settings_with_http_info(self, account_id, envelope_id, **kwargs): 1235 """ 1236 Adds email setting overrides to an envelope. 1237 Adds email override settings, changing the email address to reply to an email address, name, or the BCC for email archive information, for the envelope. Note that adding email settings will only affect email communications that occur after the addition was made. ### Important: The BCC Email address feature is designed to provide a copy of all email communications for external archiving purposes. DocuSign recommends that envelopes sent using the BCC for Email Archive feature, including the BCC Email Override option, include additional signer authentication options. To send a copy of the envelope to a recipient who does not need to sign, use a Carbon Copies or Certified Deliveries Recipient Type. 1238 This method makes a synchronous HTTP request by default. To make an 1239 asynchronous HTTP request, please define a `callback` function 1240 to be invoked when receiving the response. 1241 >>> def callback_function(response): 1242 >>> pprint(response) 1243 >>> 1244 >>> thread = api.create_email_settings_with_http_info(account_id, envelope_id, callback=callback_function) 1245 1246 :param callback function: The callback function 1247 for asynchronous request. (optional) 1248 :param str account_id: The external account number (int) or account ID Guid. (required) 1249 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1250 :param EmailSettings email_settings: 1251 :return: EmailSettings 1252 If the method is called asynchronously, 1253 returns the request thread. 1254 """ 1255 1256 all_params = ['account_id', 'envelope_id', 'email_settings'] 1257 all_params.append('callback') 1258 all_params.append('_return_http_data_only') 1259 all_params.append('_preload_content') 1260 all_params.append('_request_timeout') 1261 1262 params = locals() 1263 for key, val in iteritems(params['kwargs']): 1264 if key not in all_params: 1265 raise TypeError( 1266 "Got an unexpected keyword argument '%s'" 1267 " to method create_email_settings" % key 1268 ) 1269 params[key] = val 1270 del params['kwargs'] 1271 # verify the required parameter 'account_id' is set 1272 if ('account_id' not in params) or (params['account_id'] is None): 1273 raise ValueError("Missing the required parameter `account_id` when calling `create_email_settings`") 1274 # verify the required parameter 'envelope_id' is set 1275 if ('envelope_id' not in params) or (params['envelope_id'] is None): 1276 raise ValueError("Missing the required parameter `envelope_id` when calling `create_email_settings`") 1277 1278 1279 collection_formats = {} 1280 1281 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/email_settings'.replace('{format}', 'json') 1282 path_params = {} 1283 if 'account_id' in params: 1284 path_params['accountId'] = params['account_id'] 1285 if 'envelope_id' in params: 1286 path_params['envelopeId'] = params['envelope_id'] 1287 1288 query_params = {} 1289 1290 header_params = {} 1291 1292 form_params = [] 1293 local_var_files = {} 1294 1295 body_params = None 1296 if 'email_settings' in params: 1297 body_params = params['email_settings'] 1298 # HTTP header `Accept` 1299 header_params['Accept'] = self.api_client.\ 1300 select_header_accept(['application/json']) 1301 1302 # Authentication setting 1303 auth_settings = [] 1304 1305 return self.api_client.call_api(resource_path, 'POST', 1306 path_params, 1307 query_params, 1308 header_params, 1309 body=body_params, 1310 post_params=form_params, 1311 files=local_var_files, 1312 response_type='EmailSettings', 1313 auth_settings=auth_settings, 1314 callback=params.get('callback'), 1315 _return_http_data_only=params.get('_return_http_data_only'), 1316 _preload_content=params.get('_preload_content', True), 1317 _request_timeout=params.get('_request_timeout'), 1318 collection_formats=collection_formats)
Adds email setting overrides to an envelope.
Adds email override settings, changing the email address to reply to an email address, name, or the BCC for email archive information, for the envelope. Note that adding email settings will only affect email communications that occur after the addition was made. ### Important: The BCC Email address feature is designed to provide a copy of all email communications for external archiving purposes. DocuSign recommends that envelopes sent using the BCC for Email Archive feature, including the BCC Email Override option, include additional signer authentication options. To send a copy of the envelope to a recipient who does not need to sign, use a Carbon Copies or Certified Deliveries Recipient Type.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_email_settings_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- EmailSettings email_settings:
Returns
EmailSettings If the method is called asynchronously, returns the request thread.
def
create_envelope(self, account_id, **kwargs)
1320 def create_envelope(self, account_id, **kwargs): 1321 """ 1322 Creates an envelope. 1323 Creates an envelope. Using this function you can: * Create an envelope and send it. * Create an envelope from an existing template and send it. In either case, you can choose to save the envelope as a draft envelope instead of sending it by setting the request's `status` property to `created` instead of `sent`. ## Sending Envelopes Documents can be included with the Envelopes::create call itself or a template can include documents. Documents can be added by using a multi-part/form request or by using the `documentBase64` field of the [`document` object](#/definitions/document) ### Recipient Types An [`envelopeDefinition` object](#/definitions/envelopeDefinition) is used as the method's body. Envelope recipients can be defined in the envelope or in templates. The `envelopeDefinition` object's `recipients` field is an [`EnvelopeRecipients` resource object](#/definitions/EnvelopeRecipients). It includes arrays of the seven types of recipients defined by DocuSign: Recipient type | Object definition -------------- | ----------------- agent (can add name and email information for later recipients/signers) | [`agent`](#/definitions/agent) carbon copy (receives a copy of the documents) | [`carbonCopy`](#/definitions/carbonCopy) certified delivery (receives a copy of the documents and must acknowledge receipt) | [`certifiedDelivery`](#/definitions/certifiedDelivery) editor (can change recipients and document fields for later recipients/signers) | [`editor`](#/definitions/editor) in-person signer (\"hosts\" someone who signs in-person) | [`inPersonSigner`](#/definitions/inPersonSigner) intermediary (can add name and email information for some later recipients/signers.) | [`intermediary`](#/definitions/intermediary) signer (signs and/or updates document fields) | [`signer`](#/definitions/signer) Additional information about the different types of recipients is available from the [`EnvelopeRecipients` resource page](../../EnvelopeRecipients) and from the [Developer Center](https://www.docusign.com/developer-center/explore/features/recipients) ### Tabs Tabs (also referred to as `tags` and as `fields` in the web sending user interface), can be defined in the `envelopeDefinition`, in templates, by transforming PDF Form Fields, or by using Composite Templates (see below). Defining tabs: the `inPersonSigner`, and `signer` recipient objects include a `tabs` field. It is an [`EnvelopeTabs` resource object](#/definitions/EnvelopeTabs). It includes arrays of the 24 different tab types available. See the [`EnvelopeTabs` resource](../../EnvelopeTabs) for more information. ## Using Templates Envelopes use specific people or groups as recipients. Templates can specify a role, eg `account_manager.` When a template is used in an envelope, the roles must be replaced with specific people or groups. When you create an envelope using a `templateId`, the different recipient type objects within the [`EnvelopeRecipients` object](#/definitions/EnvelopeRecipients) are used to assign recipients to the template's roles via the `roleName` property. The recipient objects can also override settings that were specified in the template, and set values for tab fields that were defined in the template. ### Message Lock When a template is added or applied to an envelope and the template has a locked email subject and message, that subject and message are used for the envelope and cannot be changed even if another locked template is subsequently added or applied to the envelope. The field `messageLock` is used to lock the email subject and message. If an email subject or message is entered before adding or applying a template with `messageLock` **true**, the email subject and message is overwritten with the locked email subject and message from the template. ## Envelope Status The status of sent envelopes can be determined through the DocuSign webhook system or by polling. Webhooks are highly recommended: they provide your application with the quickest updates when an envelope's status changes. DocuSign limits polling to once every 15 minutes or less frequently. When a webhook is used, DocuSign calls your application, via the URL you provide, with a notification XML message. See the [Webhook recipe](https://www.docusign.com/developer-center/recipes/webhook-status) for examples and live demos of using webhooks. ## Webhook Options The two webhook options, *eventNotification* and *Connect* use the same notification mechanism and message formats. eventNotification is used to create a webhook for a specific envelope sent via the API. Connect webhooks can be used for any envelope sent from an account, from any user, from any client. ### eventNotification Webhooks The Envelopes::create method includes an optional [eventNotification object](#definition-eventNotification) that adds a webhook to the envelope. eventNotification webhooks are available for all DocuSign accounts with API access. ### Connect Webhooks Connect can be used to create a webhook for all envelopes sent by all users in an account, either through the API or via other DocuSign clients (web, mobile, etc). Connect configurations are independent of specific envelopes. A Connect configuration includes a filter that may be used to limit the webhook to specific users, envelope statuses, etc. Connect configurations may be created and managed using the [ConnectConfigurations resource](../../Connect/ConnectConfigurations). Configurations can also be created and managed from the Administration tool accessed by selecting \"Go to Admin\" from the menu next to your picture on the DocuSign web app. See the Integrations/Connect section of the Admin tool. For repeatability, and to minimize support questions, creating Connect configurations via the API is recommended, especially for ISVs. Connect is available for some DocuSign account types. Please contact DocuSign Sales for more information. ## Composite Templates The Composite Templates feature, like [compositing in film production](https://en.wikipedia.org/wiki/Compositing), enables you to *overlay* document, recipient, and tab definitions from multiple sources, including PDF Form Field definitions, templates defined on the server, and more. Each Composite Template consists of optional elements: server templates, inline templates, PDF Metadata templates, and documents. * The Composite Template ID is an optional element used to identify the composite template. It is used as a reference when adding document object information via a multi-part HTTP message. If used, the document content-disposition must include the `compositeTemplateId` to which the document should be added. If `compositeTemplateId` is not specified in the content-disposition, the document is applied based on the `documentId` only. If no document object is specified, the composite template inherits the first document. * Server Templates are server-side templates stored on the DocuSign platform. If supplied, they are overlaid into the envelope in the order of their Sequence value. * Inline Templates provide a container to add documents, recipients, tabs, and custom fields. If inline templates are supplied, they are overlaid into the envelope in the order of their Sequence value. * Document objects are optional structures that provide a container to pass in a document or form. If this object is not included, the composite template inherits the *first* document it finds from a server template or inline template, starting with the lowest sequence value. PDF Form objects are only transformed from the document object. DocuSign does not derive PDF form properties from server templates or inline templates. To instruct DocuSign to transform fields from the PDF form, set `transformPdfFields` to \"true\" for the document. See the Transform PDF Fields section for more information about process. * PDF Metadata Templates provide a container to embed design-time template information into a PDF document. DocuSign uses this information when processing the Envelope. This convention allows the document to carry the signing instructions with it, so that less information needs to be provided at run-time through an inline template or synchronized with an external structure like a server template. PDF Metadata templates are stored in the Metadata layer of a PDF in accordance with Acrobat's XMP specification. DocuSign will only find PDF Metadata templates inside documents passed in the Document object (see below). If supplied, the PDF metadata template will be overlaid into the envelope in the order of its Sequence value. ### Compositing the definitions Each Composite Template adds a new document and templates overlay into the envelope. For each Composite Template these rules are applied: * Templates are overlaid in the order of their Sequence value. * If Document is not passed into the Composite Template's `document` field, the *first* template's document (based on the template's Sequence value) is used. * Last in wins in all cases except for the document (i.e. envelope information, recipient information, secure field information). There is no special casing. For example, if you want higher security on a tab, then that needs to be specified in a later template (by sequence number) then where the tab is included. If you want higher security on a role recipient, then it needs to be in a later template then where that role recipient is specified. * Recipient matching is based on Recipient Role and Routing Order. If there are matches, the recipient information is merged together. A final pass is done on all Composite Templates, after all template overlays have been applied, to collapse recipients with the same email, username and routing order. This prevents having the same recipients at the same routing order. * If you specify in a template that a recipient is locked, once that recipient is overlaid the recipient attributes can no longer be changed. The only items that can be changed for the recipient in this case are the email, username, access code and IDCheckInformationInput. * Tab matching is based on Tab Labels, Tab Types and Documents. If a Tab Label matches but the Document is not supplied, the Tab is overlaid for all the Documents. For example, if you have a simple inline template with only one tab in it with a label and a value, the Signature, Initial, Company, Envelope ID, User Name tabs will only be matched and collapsed if they fall in the exact same X and Y locations. * roleName and tabLabel matching is case sensitive. * The defaultRecipient field enables you to specify which recipient the generated tabs from a PDF form are mapped to. You can also set PDF form generated tabs to a recipient other than the DefaultRecipient by specifying the mapping of the tab label that is created to one of the template recipients. * You can use tabLabel wild carding to map a series of tabs from the PDF form. To use this you must end a tab label with \"\\*\" and then the system matches tabs that start with the label. * If no DefaultRecipient is specified, tabs must be explicitly mapped to recipients in order to be generated from the form. Unmapped form objects will not be generated into their DocuSign equivalents. (In the case of Signature/Initials, the tabs will be disregarded entirely; in the case of pdf text fields, the field data will be flattened on the Envelope document, but there will not be a corresponding DocuSign data tab.) ### Including the Document Content for Composite Templates Document content can be supplied inline, using the `documentBase64` or can be included in a multi-part HTTP message. If a multi-part message is used and there are multiple Composite Templates, the document content-disposition can include the `compositeTemplateId` to which the document should be added. Using the `compositeTemplateId` sets which documents are associated with particular composite templates. An example of this usage is: ``` --5cd3320a-5aac-4453-b3a4-cbb52a4cba5d Content-Type: application/pdf Content-Disposition: file; filename=\"eula.pdf\"; documentId=1; compositeTemplateId=\"1\" Content-Transfer-Encoding: base64 ``` ### PDF Form Field Transformation Only the following PDF Form FieldTypes will be transformed to DocuSign tabs: CheckBox, DateTime, ListBox, Numeric, Password, Radio, Signature, and Text Field Properties that will be transformed: Read Only, Required, Max Length, Positions, and Initial Data. When transforming a *PDF Form Digital Signature Field,* the following rules are used: If the PDF Field Name Contains | Then the DocuSign Tab Will be ------- | -------- DocuSignSignHere or eSignSignHere | Signature DocuSignSignHereOptional or eSignSignHereOptional | Optional Signature DocuSignInitialHere or eSignInitialHere | Initials DocuSignInitialHereOptional or eSignInitialHereOptional | Optional Initials Any other PDF Form Digital Signature Field will be transformed to a DocuSign Signature tab When transforming *PDF Form Text Fields,* the following rules are used: If the PDF Field Name Contains | Then the DocuSign Tab Will be ------- | -------- DocuSignSignHere or eSignSignHere | Signature DocuSignSignHereOptional or eSignSignHereOptional | Optional Signature DocuSignInitialHere or eSignInitialHere | Initials DocuSignInitialHereOptional or eSignInitialHereOptional | Optional Initials DocuSignEnvelopeID or eSignEnvelopeID | EnvelopeID DocuSignCompany or eSignCompany | Company DocuSignDateSigned or eSignDateSigned | Date Signed DocuSignTitle or eSignTitle | Title DocuSignFullName or eSignFullName | Full Name DocuSignSignerAttachmentOptional or eSignSignerAttachmentOptional | Optional Signer Attachment Any other PDF Form Text Field will be transformed to a DocuSign data (text) tab. PDF Form Field Names that include \"DocuSignIgnoreTransform\" or \"eSignIgnoreTransform\" will not be transformed. PDF Form Date fields will be transformed to Date Signed fields if their name includes DocuSignDateSigned or eSignDateSigned. ## Template Email Subject Merge Fields This feature enables you to insert recipient name and email address merge fields into the email subject line when creating or sending from a template. The merge fields, based on the recipient's `roleName`, are added to the `emailSubject` when the template is created or when the template is used to create an envelope. After a template sender adds the name and email information for the recipient and sends the envelope, the recipient information is automatically merged into the appropriate fields in the email subject line. Both the sender and the recipients will see the information in the email subject line for any emails associated with the template. This provides an easy way for senders to organize their envelope emails without having to open an envelope to check the recipient. If merging the recipient information into the subject line causes the subject line to exceed 100 characters, then any characters over the 100 character limit are not included in the subject line. For cases where the recipient name or email is expected to be long, you should consider placing the merge field at the start of the email subject. * To add a recipient's name in the subject line add the following text in the `emailSubject` when creating the template or when sending an envelope from a template: [[<roleName>_UserName]] Example: `\"emailSubject\":\"[[Signer 1_UserName]], Please sign this NDA\",` * To add a recipient's email address in the subject line add the following text in the emailSubject when creating the template or when sending an envelope from a template: [[<roleName>_Email]] Example: `\"emailSubject\":\"[[Signer 1_Email]], Please sign this NDA\",` In both cases the <roleName> is the recipient's `roleName` in the template. For cases where another recipient (such as an Agent, Editor, or Intermediary recipient) is entering the name and email information for the recipient included in the email subject, then [[<roleName>_UserName]] or [[<roleName>_Email]] is shown in the email subject. ## Branding an envelope The following rules are used to determine the `brandId` used in an envelope: * If a `brandId` is specified in the envelope/template and that brandId is available to the account, that brand is used in the envelope. * If more than one template is used in an envelope and more than one `brandId` is specified, the first `brandId` specified is used throughout the envelope. * In cases where no brand is specified and the sender belongs to a Group; if there is only one brand associated with the Group, then that brand is used in the envelope. Otherwise, the account's default signing brand is used. * For envelopes that do not meet any of the previous criteria, the account's default signing brand is used for the envelope. ## BCC Email address feature The BCC Email address feature is designed to provide a copy of all email communications for external archiving purposes. DocuSign recommends that envelopes sent using the BCC for Email Archive feature, including the BCC Email Override option, include additional signer authentication options. To send a copy of the envelope to a recipient who does not need to sign, don't use the BCC Email field. Use a Carbon Copy or Certified Delivery Recipient type. ## Merge Recipient Roles for Draft Envelopes When an envelope with multiple templates is sent, the recipients from the templates are merged according to the template roles, and empty recipients are removed. When creating an envelope with multiple templates, but not sending it (keeping it in a created state), duplicate recipients are not merged, which could cause leave duplicate recipients in the envelope. To prevent this, the query parameter `merge_roles_on_draft` should be added when posting a draft envelope (status=created) with multiple templates. Doing this will merge template roles and remove empty recipients. ###### Note: DocuSign recommends that the `merge_roles_on_draft` query parameter be used anytime you are creating an envelope with multiple templates and keeping it in draft (created) status. 1324 This method makes a synchronous HTTP request by default. To make an 1325 asynchronous HTTP request, please define a `callback` function 1326 to be invoked when receiving the response. 1327 >>> def callback_function(response): 1328 >>> pprint(response) 1329 >>> 1330 >>> thread = api.create_envelope(account_id, callback=callback_function) 1331 1332 :param callback function: The callback function 1333 for asynchronous request. (optional) 1334 :param str account_id: The external account number (int) or account ID Guid. (required) 1335 :param str cdse_mode: 1336 :param str change_routing_order: 1337 :param str completed_documents_only: If set to true then we want to set the sourceEnvelopeId to indicate that this is a\"forward\" envelope action 1338 :param str merge_roles_on_draft: When set to **true**, merges template roles and remove empty recipients when you create an envelope with multiple templates. 1339 :param str tab_label_exact_matches: 1340 :param EnvelopeDefinition envelope_definition: 1341 :return: EnvelopeSummary 1342 If the method is called asynchronously, 1343 returns the request thread. 1344 """ 1345 kwargs['_return_http_data_only'] = True 1346 if kwargs.get('callback'): 1347 return self.create_envelope_with_http_info(account_id, **kwargs) 1348 else: 1349 (data) = self.create_envelope_with_http_info(account_id, **kwargs) 1350 return data
Creates an envelope.
Creates an envelope. Using this function you can: * Create an envelope and send it. * Create an envelope from an existing template and send it. In either case, you can choose to save the envelope as a draft envelope instead of sending it by setting the request's status property to created instead of sent. ## Sending Envelopes Documents can be included with the Envelopes::create call itself or a template can include documents. Documents can be added by using a multi-part/form request or by using the documentBase64 field of the document object ### Recipient Types An envelopeDefinition object is used as the method's body. Envelope recipients can be defined in the envelope or in templates. The envelopeDefinition object's recipients field is an EnvelopeRecipients resource object. It includes arrays of the seven types of recipients defined by DocuSign: Recipient type | Object definition -------------- | ----------------- agent (can add name and email information for later recipients/signers) | agent carbon copy (receives a copy of the documents) | carbonCopy certified delivery (receives a copy of the documents and must acknowledge receipt) | certifiedDelivery editor (can change recipients and document fields for later recipients/signers) | editor in-person signer ("hosts" someone who signs in-person) | inPersonSigner intermediary (can add name and email information for some later recipients/signers.) | intermediary signer (signs and/or updates document fields) | signer Additional information about the different types of recipients is available from the EnvelopeRecipients resource page and from the Developer Center ### Tabs Tabs (also referred to as tags and as fields in the web sending user interface), can be defined in the envelopeDefinition, in templates, by transforming PDF Form Fields, or by using Composite Templates (see below). Defining tabs: the inPersonSigner, and signer recipient objects include a tabs field. It is an EnvelopeTabs resource object. It includes arrays of the 24 different tab types available. See the EnvelopeTabs resource for more information. ## Using Templates Envelopes use specific people or groups as recipients. Templates can specify a role, eg account_manager. When a template is used in an envelope, the roles must be replaced with specific people or groups. When you create an envelope using a templateId, the different recipient type objects within the EnvelopeRecipients object are used to assign recipients to the template's roles via the roleName property. The recipient objects can also override settings that were specified in the template, and set values for tab fields that were defined in the template. ### Message Lock When a template is added or applied to an envelope and the template has a locked email subject and message, that subject and message are used for the envelope and cannot be changed even if another locked template is subsequently added or applied to the envelope. The field messageLock is used to lock the email subject and message. If an email subject or message is entered before adding or applying a template with messageLock true, the email subject and message is overwritten with the locked email subject and message from the template. ## Envelope Status The status of sent envelopes can be determined through the DocuSign webhook system or by polling. Webhooks are highly recommended: they provide your application with the quickest updates when an envelope's status changes. DocuSign limits polling to once every 15 minutes or less frequently. When a webhook is used, DocuSign calls your application, via the URL you provide, with a notification XML message. See the Webhook recipe for examples and live demos of using webhooks. ## Webhook Options The two webhook options, eventNotification and Connect use the same notification mechanism and message formats. eventNotification is used to create a webhook for a specific envelope sent via the API. Connect webhooks can be used for any envelope sent from an account, from any user, from any client. ### eventNotification Webhooks The Envelopes::create method includes an optional eventNotification object that adds a webhook to the envelope. eventNotification webhooks are available for all DocuSign accounts with API access. ### Connect Webhooks Connect can be used to create a webhook for all envelopes sent by all users in an account, either through the API or via other DocuSign clients (web, mobile, etc). Connect configurations are independent of specific envelopes. A Connect configuration includes a filter that may be used to limit the webhook to specific users, envelope statuses, etc. Connect configurations may be created and managed using the ConnectConfigurations resource. Configurations can also be created and managed from the Administration tool accessed by selecting "Go to Admin" from the menu next to your picture on the DocuSign web app. See the Integrations/Connect section of the Admin tool. For repeatability, and to minimize support questions, creating Connect configurations via the API is recommended, especially for ISVs. Connect is available for some DocuSign account types. Please contact DocuSign Sales for more information. ## Composite Templates The Composite Templates feature, like compositing in film production, enables you to overlay document, recipient, and tab definitions from multiple sources, including PDF Form Field definitions, templates defined on the server, and more. Each Composite Template consists of optional elements: server templates, inline templates, PDF Metadata templates, and documents. * The Composite Template ID is an optional element used to identify the composite template. It is used as a reference when adding document object information via a multi-part HTTP message. If used, the document content-disposition must include the compositeTemplateId to which the document should be added. If compositeTemplateId is not specified in the content-disposition, the document is applied based on the documentId only. If no document object is specified, the composite template inherits the first document. * Server Templates are server-side templates stored on the DocuSign platform. If supplied, they are overlaid into the envelope in the order of their Sequence value. * Inline Templates provide a container to add documents, recipients, tabs, and custom fields. If inline templates are supplied, they are overlaid into the envelope in the order of their Sequence value. * Document objects are optional structures that provide a container to pass in a document or form. If this object is not included, the composite template inherits the first document it finds from a server template or inline template, starting with the lowest sequence value. PDF Form objects are only transformed from the document object. DocuSign does not derive PDF form properties from server templates or inline templates. To instruct DocuSign to transform fields from the PDF form, set transformPdfFields to "true" for the document. See the Transform PDF Fields section for more information about process. * PDF Metadata Templates provide a container to embed design-time template information into a PDF document. DocuSign uses this information when processing the Envelope. This convention allows the document to carry the signing instructions with it, so that less information needs to be provided at run-time through an inline template or synchronized with an external structure like a server template. PDF Metadata templates are stored in the Metadata layer of a PDF in accordance with Acrobat's XMP specification. DocuSign will only find PDF Metadata templates inside documents passed in the Document object (see below). If supplied, the PDF metadata template will be overlaid into the envelope in the order of its Sequence value. ### Compositing the definitions Each Composite Template adds a new document and templates overlay into the envelope. For each Composite Template these rules are applied: * Templates are overlaid in the order of their Sequence value. * If Document is not passed into the Composite Template's document field, the first template's document (based on the template's Sequence value) is used. * Last in wins in all cases except for the document (i.e. envelope information, recipient information, secure field information). There is no special casing. For example, if you want higher security on a tab, then that needs to be specified in a later template (by sequence number) then where the tab is included. If you want higher security on a role recipient, then it needs to be in a later template then where that role recipient is specified. * Recipient matching is based on Recipient Role and Routing Order. If there are matches, the recipient information is merged together. A final pass is done on all Composite Templates, after all template overlays have been applied, to collapse recipients with the same email, username and routing order. This prevents having the same recipients at the same routing order. * If you specify in a template that a recipient is locked, once that recipient is overlaid the recipient attributes can no longer be changed. The only items that can be changed for the recipient in this case are the email, username, access code and IDCheckInformationInput. * Tab matching is based on Tab Labels, Tab Types and Documents. If a Tab Label matches but the Document is not supplied, the Tab is overlaid for all the Documents. For example, if you have a simple inline template with only one tab in it with a label and a value, the Signature, Initial, Company, Envelope ID, User Name tabs will only be matched and collapsed if they fall in the exact same X and Y locations. * roleName and tabLabel matching is case sensitive. * The defaultRecipient field enables you to specify which recipient the generated tabs from a PDF form are mapped to. You can also set PDF form generated tabs to a recipient other than the DefaultRecipient by specifying the mapping of the tab label that is created to one of the template recipients. * You can use tabLabel wild carding to map a series of tabs from the PDF form. To use this you must end a tab label with "*" and then the system matches tabs that start with the label. * If no DefaultRecipient is specified, tabs must be explicitly mapped to recipients in order to be generated from the form. Unmapped form objects will not be generated into their DocuSign equivalents. (In the case of Signature/Initials, the tabs will be disregarded entirely; in the case of pdf text fields, the field data will be flattened on the Envelope document, but there will not be a corresponding DocuSign data tab.) ### Including the Document Content for Composite Templates Document content can be supplied inline, using the documentBase64 or can be included in a multi-part HTTP message. If a multi-part message is used and there are multiple Composite Templates, the document content-disposition can include the compositeTemplateId to which the document should be added. Using the compositeTemplateId sets which documents are associated with particular composite templates. An example of this usage is: --5cd3320a-5aac-4453-b3a4-cbb52a4cba5d Content-Type: application/pdf Content-Disposition: file; filename="eula.pdf"; documentId=1; compositeTemplateId="1" Content-Transfer-Encoding: base64 ### PDF Form Field Transformation Only the following PDF Form FieldTypes will be transformed to DocuSign tabs: CheckBox, DateTime, ListBox, Numeric, Password, Radio, Signature, and Text Field Properties that will be transformed: Read Only, Required, Max Length, Positions, and Initial Data. When transforming a PDF Form Digital Signature Field, the following rules are used: If the PDF Field Name Contains | Then the DocuSign Tab Will be ------- | -------- DocuSignSignHere or eSignSignHere | Signature DocuSignSignHereOptional or eSignSignHereOptional | Optional Signature DocuSignInitialHere or eSignInitialHere | Initials DocuSignInitialHereOptional or eSignInitialHereOptional | Optional Initials Any other PDF Form Digital Signature Field will be transformed to a DocuSign Signature tab When transforming PDF Form Text Fields, the following rules are used: If the PDF Field Name Contains | Then the DocuSign Tab Will be ------- | -------- DocuSignSignHere or eSignSignHere | Signature DocuSignSignHereOptional or eSignSignHereOptional | Optional Signature DocuSignInitialHere or eSignInitialHere | Initials DocuSignInitialHereOptional or eSignInitialHereOptional | Optional Initials DocuSignEnvelopeID or eSignEnvelopeID | EnvelopeID DocuSignCompany or eSignCompany | Company DocuSignDateSigned or eSignDateSigned | Date Signed DocuSignTitle or eSignTitle | Title DocuSignFullName or eSignFullName | Full Name DocuSignSignerAttachmentOptional or eSignSignerAttachmentOptional | Optional Signer Attachment Any other PDF Form Text Field will be transformed to a DocuSign data (text) tab. PDF Form Field Names that include "DocuSignIgnoreTransform" or "eSignIgnoreTransform" will not be transformed. PDF Form Date fields will be transformed to Date Signed fields if their name includes DocuSignDateSigned or eSignDateSigned. ## Template Email Subject Merge Fields This feature enables you to insert recipient name and email address merge fields into the email subject line when creating or sending from a template. The merge fields, based on the recipient's roleName, are added to the emailSubject when the template is created or when the template is used to create an envelope. After a template sender adds the name and email information for the recipient and sends the envelope, the recipient information is automatically merged into the appropriate fields in the email subject line. Both the sender and the recipients will see the information in the email subject line for any emails associated with the template. This provides an easy way for senders to organize their envelope emails without having to open an envelope to check the recipient. If merging the recipient information into the subject line causes the subject line to exceed 100 characters, then any characters over the 100 character limit are not included in the subject line. For cases where the recipient name or email is expected to be long, you should consider placing the merge field at the start of the email subject. * To add a recipient's name in the subject line add the following text in the emailSubject when creating the template or when sending an envelope from a template: [["emailSubject":"[[Signer 1_UserName]], Please sign this NDA", * To add a recipient's email address in the subject line add the following text in the emailSubject when creating the template or when sending an envelope from a template: [["emailSubject":"[[Signer 1_Email]], Please sign this NDA", In both cases the roleName in the template. For cases where another recipient (such as an Agent, Editor, or Intermediary recipient) is entering the name and email information for the recipient included in the email subject, then [[brandId used in an envelope: * If a brandId is specified in the envelope/template and that brandId is available to the account, that brand is used in the envelope. * If more than one template is used in an envelope and more than one brandId is specified, the first brandId specified is used throughout the envelope. * In cases where no brand is specified and the sender belongs to a Group; if there is only one brand associated with the Group, then that brand is used in the envelope. Otherwise, the account's default signing brand is used. * For envelopes that do not meet any of the previous criteria, the account's default signing brand is used for the envelope. ## BCC Email address feature The BCC Email address feature is designed to provide a copy of all email communications for external archiving purposes. DocuSign recommends that envelopes sent using the BCC for Email Archive feature, including the BCC Email Override option, include additional signer authentication options. To send a copy of the envelope to a recipient who does not need to sign, don't use the BCC Email field. Use a Carbon Copy or Certified Delivery Recipient type. ## Merge Recipient Roles for Draft Envelopes When an envelope with multiple templates is sent, the recipients from the templates are merged according to the template roles, and empty recipients are removed. When creating an envelope with multiple templates, but not sending it (keeping it in a created state), duplicate recipients are not merged, which could cause leave duplicate recipients in the envelope. To prevent this, the query parameter merge_roles_on_draft should be added when posting a draft envelope (status=created) with multiple templates. Doing this will merge template roles and remove empty recipients. ###### Note: DocuSign recommends that the merge_roles_on_draft query parameter be used anytime you are creating an envelope with multiple templates and keeping it in draft (created) status.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_envelope(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str cdse_mode:
- str change_routing_order:
- str completed_documents_only: If set to true then we want to set the sourceEnvelopeId to indicate that this is a"forward" envelope action
- str merge_roles_on_draft: When set to true, merges template roles and remove empty recipients when you create an envelope with multiple templates.
- str tab_label_exact_matches:
- EnvelopeDefinition envelope_definition:
Returns
EnvelopeSummary If the method is called asynchronously, returns the request thread.
def
create_envelope_with_http_info(self, account_id, **kwargs)
1352 def create_envelope_with_http_info(self, account_id, **kwargs): 1353 """ 1354 Creates an envelope. 1355 Creates an envelope. Using this function you can: * Create an envelope and send it. * Create an envelope from an existing template and send it. In either case, you can choose to save the envelope as a draft envelope instead of sending it by setting the request's `status` property to `created` instead of `sent`. ## Sending Envelopes Documents can be included with the Envelopes::create call itself or a template can include documents. Documents can be added by using a multi-part/form request or by using the `documentBase64` field of the [`document` object](#/definitions/document) ### Recipient Types An [`envelopeDefinition` object](#/definitions/envelopeDefinition) is used as the method's body. Envelope recipients can be defined in the envelope or in templates. The `envelopeDefinition` object's `recipients` field is an [`EnvelopeRecipients` resource object](#/definitions/EnvelopeRecipients). It includes arrays of the seven types of recipients defined by DocuSign: Recipient type | Object definition -------------- | ----------------- agent (can add name and email information for later recipients/signers) | [`agent`](#/definitions/agent) carbon copy (receives a copy of the documents) | [`carbonCopy`](#/definitions/carbonCopy) certified delivery (receives a copy of the documents and must acknowledge receipt) | [`certifiedDelivery`](#/definitions/certifiedDelivery) editor (can change recipients and document fields for later recipients/signers) | [`editor`](#/definitions/editor) in-person signer (\"hosts\" someone who signs in-person) | [`inPersonSigner`](#/definitions/inPersonSigner) intermediary (can add name and email information for some later recipients/signers.) | [`intermediary`](#/definitions/intermediary) signer (signs and/or updates document fields) | [`signer`](#/definitions/signer) Additional information about the different types of recipients is available from the [`EnvelopeRecipients` resource page](../../EnvelopeRecipients) and from the [Developer Center](https://www.docusign.com/developer-center/explore/features/recipients) ### Tabs Tabs (also referred to as `tags` and as `fields` in the web sending user interface), can be defined in the `envelopeDefinition`, in templates, by transforming PDF Form Fields, or by using Composite Templates (see below). Defining tabs: the `inPersonSigner`, and `signer` recipient objects include a `tabs` field. It is an [`EnvelopeTabs` resource object](#/definitions/EnvelopeTabs). It includes arrays of the 24 different tab types available. See the [`EnvelopeTabs` resource](../../EnvelopeTabs) for more information. ## Using Templates Envelopes use specific people or groups as recipients. Templates can specify a role, eg `account_manager.` When a template is used in an envelope, the roles must be replaced with specific people or groups. When you create an envelope using a `templateId`, the different recipient type objects within the [`EnvelopeRecipients` object](#/definitions/EnvelopeRecipients) are used to assign recipients to the template's roles via the `roleName` property. The recipient objects can also override settings that were specified in the template, and set values for tab fields that were defined in the template. ### Message Lock When a template is added or applied to an envelope and the template has a locked email subject and message, that subject and message are used for the envelope and cannot be changed even if another locked template is subsequently added or applied to the envelope. The field `messageLock` is used to lock the email subject and message. If an email subject or message is entered before adding or applying a template with `messageLock` **true**, the email subject and message is overwritten with the locked email subject and message from the template. ## Envelope Status The status of sent envelopes can be determined through the DocuSign webhook system or by polling. Webhooks are highly recommended: they provide your application with the quickest updates when an envelope's status changes. DocuSign limits polling to once every 15 minutes or less frequently. When a webhook is used, DocuSign calls your application, via the URL you provide, with a notification XML message. See the [Webhook recipe](https://www.docusign.com/developer-center/recipes/webhook-status) for examples and live demos of using webhooks. ## Webhook Options The two webhook options, *eventNotification* and *Connect* use the same notification mechanism and message formats. eventNotification is used to create a webhook for a specific envelope sent via the API. Connect webhooks can be used for any envelope sent from an account, from any user, from any client. ### eventNotification Webhooks The Envelopes::create method includes an optional [eventNotification object](#definition-eventNotification) that adds a webhook to the envelope. eventNotification webhooks are available for all DocuSign accounts with API access. ### Connect Webhooks Connect can be used to create a webhook for all envelopes sent by all users in an account, either through the API or via other DocuSign clients (web, mobile, etc). Connect configurations are independent of specific envelopes. A Connect configuration includes a filter that may be used to limit the webhook to specific users, envelope statuses, etc. Connect configurations may be created and managed using the [ConnectConfigurations resource](../../Connect/ConnectConfigurations). Configurations can also be created and managed from the Administration tool accessed by selecting \"Go to Admin\" from the menu next to your picture on the DocuSign web app. See the Integrations/Connect section of the Admin tool. For repeatability, and to minimize support questions, creating Connect configurations via the API is recommended, especially for ISVs. Connect is available for some DocuSign account types. Please contact DocuSign Sales for more information. ## Composite Templates The Composite Templates feature, like [compositing in film production](https://en.wikipedia.org/wiki/Compositing), enables you to *overlay* document, recipient, and tab definitions from multiple sources, including PDF Form Field definitions, templates defined on the server, and more. Each Composite Template consists of optional elements: server templates, inline templates, PDF Metadata templates, and documents. * The Composite Template ID is an optional element used to identify the composite template. It is used as a reference when adding document object information via a multi-part HTTP message. If used, the document content-disposition must include the `compositeTemplateId` to which the document should be added. If `compositeTemplateId` is not specified in the content-disposition, the document is applied based on the `documentId` only. If no document object is specified, the composite template inherits the first document. * Server Templates are server-side templates stored on the DocuSign platform. If supplied, they are overlaid into the envelope in the order of their Sequence value. * Inline Templates provide a container to add documents, recipients, tabs, and custom fields. If inline templates are supplied, they are overlaid into the envelope in the order of their Sequence value. * Document objects are optional structures that provide a container to pass in a document or form. If this object is not included, the composite template inherits the *first* document it finds from a server template or inline template, starting with the lowest sequence value. PDF Form objects are only transformed from the document object. DocuSign does not derive PDF form properties from server templates or inline templates. To instruct DocuSign to transform fields from the PDF form, set `transformPdfFields` to \"true\" for the document. See the Transform PDF Fields section for more information about process. * PDF Metadata Templates provide a container to embed design-time template information into a PDF document. DocuSign uses this information when processing the Envelope. This convention allows the document to carry the signing instructions with it, so that less information needs to be provided at run-time through an inline template or synchronized with an external structure like a server template. PDF Metadata templates are stored in the Metadata layer of a PDF in accordance with Acrobat's XMP specification. DocuSign will only find PDF Metadata templates inside documents passed in the Document object (see below). If supplied, the PDF metadata template will be overlaid into the envelope in the order of its Sequence value. ### Compositing the definitions Each Composite Template adds a new document and templates overlay into the envelope. For each Composite Template these rules are applied: * Templates are overlaid in the order of their Sequence value. * If Document is not passed into the Composite Template's `document` field, the *first* template's document (based on the template's Sequence value) is used. * Last in wins in all cases except for the document (i.e. envelope information, recipient information, secure field information). There is no special casing. For example, if you want higher security on a tab, then that needs to be specified in a later template (by sequence number) then where the tab is included. If you want higher security on a role recipient, then it needs to be in a later template then where that role recipient is specified. * Recipient matching is based on Recipient Role and Routing Order. If there are matches, the recipient information is merged together. A final pass is done on all Composite Templates, after all template overlays have been applied, to collapse recipients with the same email, username and routing order. This prevents having the same recipients at the same routing order. * If you specify in a template that a recipient is locked, once that recipient is overlaid the recipient attributes can no longer be changed. The only items that can be changed for the recipient in this case are the email, username, access code and IDCheckInformationInput. * Tab matching is based on Tab Labels, Tab Types and Documents. If a Tab Label matches but the Document is not supplied, the Tab is overlaid for all the Documents. For example, if you have a simple inline template with only one tab in it with a label and a value, the Signature, Initial, Company, Envelope ID, User Name tabs will only be matched and collapsed if they fall in the exact same X and Y locations. * roleName and tabLabel matching is case sensitive. * The defaultRecipient field enables you to specify which recipient the generated tabs from a PDF form are mapped to. You can also set PDF form generated tabs to a recipient other than the DefaultRecipient by specifying the mapping of the tab label that is created to one of the template recipients. * You can use tabLabel wild carding to map a series of tabs from the PDF form. To use this you must end a tab label with \"\\*\" and then the system matches tabs that start with the label. * If no DefaultRecipient is specified, tabs must be explicitly mapped to recipients in order to be generated from the form. Unmapped form objects will not be generated into their DocuSign equivalents. (In the case of Signature/Initials, the tabs will be disregarded entirely; in the case of pdf text fields, the field data will be flattened on the Envelope document, but there will not be a corresponding DocuSign data tab.) ### Including the Document Content for Composite Templates Document content can be supplied inline, using the `documentBase64` or can be included in a multi-part HTTP message. If a multi-part message is used and there are multiple Composite Templates, the document content-disposition can include the `compositeTemplateId` to which the document should be added. Using the `compositeTemplateId` sets which documents are associated with particular composite templates. An example of this usage is: ``` --5cd3320a-5aac-4453-b3a4-cbb52a4cba5d Content-Type: application/pdf Content-Disposition: file; filename=\"eula.pdf\"; documentId=1; compositeTemplateId=\"1\" Content-Transfer-Encoding: base64 ``` ### PDF Form Field Transformation Only the following PDF Form FieldTypes will be transformed to DocuSign tabs: CheckBox, DateTime, ListBox, Numeric, Password, Radio, Signature, and Text Field Properties that will be transformed: Read Only, Required, Max Length, Positions, and Initial Data. When transforming a *PDF Form Digital Signature Field,* the following rules are used: If the PDF Field Name Contains | Then the DocuSign Tab Will be ------- | -------- DocuSignSignHere or eSignSignHere | Signature DocuSignSignHereOptional or eSignSignHereOptional | Optional Signature DocuSignInitialHere or eSignInitialHere | Initials DocuSignInitialHereOptional or eSignInitialHereOptional | Optional Initials Any other PDF Form Digital Signature Field will be transformed to a DocuSign Signature tab When transforming *PDF Form Text Fields,* the following rules are used: If the PDF Field Name Contains | Then the DocuSign Tab Will be ------- | -------- DocuSignSignHere or eSignSignHere | Signature DocuSignSignHereOptional or eSignSignHereOptional | Optional Signature DocuSignInitialHere or eSignInitialHere | Initials DocuSignInitialHereOptional or eSignInitialHereOptional | Optional Initials DocuSignEnvelopeID or eSignEnvelopeID | EnvelopeID DocuSignCompany or eSignCompany | Company DocuSignDateSigned or eSignDateSigned | Date Signed DocuSignTitle or eSignTitle | Title DocuSignFullName or eSignFullName | Full Name DocuSignSignerAttachmentOptional or eSignSignerAttachmentOptional | Optional Signer Attachment Any other PDF Form Text Field will be transformed to a DocuSign data (text) tab. PDF Form Field Names that include \"DocuSignIgnoreTransform\" or \"eSignIgnoreTransform\" will not be transformed. PDF Form Date fields will be transformed to Date Signed fields if their name includes DocuSignDateSigned or eSignDateSigned. ## Template Email Subject Merge Fields This feature enables you to insert recipient name and email address merge fields into the email subject line when creating or sending from a template. The merge fields, based on the recipient's `roleName`, are added to the `emailSubject` when the template is created or when the template is used to create an envelope. After a template sender adds the name and email information for the recipient and sends the envelope, the recipient information is automatically merged into the appropriate fields in the email subject line. Both the sender and the recipients will see the information in the email subject line for any emails associated with the template. This provides an easy way for senders to organize their envelope emails without having to open an envelope to check the recipient. If merging the recipient information into the subject line causes the subject line to exceed 100 characters, then any characters over the 100 character limit are not included in the subject line. For cases where the recipient name or email is expected to be long, you should consider placing the merge field at the start of the email subject. * To add a recipient's name in the subject line add the following text in the `emailSubject` when creating the template or when sending an envelope from a template: [[<roleName>_UserName]] Example: `\"emailSubject\":\"[[Signer 1_UserName]], Please sign this NDA\",` * To add a recipient's email address in the subject line add the following text in the emailSubject when creating the template or when sending an envelope from a template: [[<roleName>_Email]] Example: `\"emailSubject\":\"[[Signer 1_Email]], Please sign this NDA\",` In both cases the <roleName> is the recipient's `roleName` in the template. For cases where another recipient (such as an Agent, Editor, or Intermediary recipient) is entering the name and email information for the recipient included in the email subject, then [[<roleName>_UserName]] or [[<roleName>_Email]] is shown in the email subject. ## Branding an envelope The following rules are used to determine the `brandId` used in an envelope: * If a `brandId` is specified in the envelope/template and that brandId is available to the account, that brand is used in the envelope. * If more than one template is used in an envelope and more than one `brandId` is specified, the first `brandId` specified is used throughout the envelope. * In cases where no brand is specified and the sender belongs to a Group; if there is only one brand associated with the Group, then that brand is used in the envelope. Otherwise, the account's default signing brand is used. * For envelopes that do not meet any of the previous criteria, the account's default signing brand is used for the envelope. ## BCC Email address feature The BCC Email address feature is designed to provide a copy of all email communications for external archiving purposes. DocuSign recommends that envelopes sent using the BCC for Email Archive feature, including the BCC Email Override option, include additional signer authentication options. To send a copy of the envelope to a recipient who does not need to sign, don't use the BCC Email field. Use a Carbon Copy or Certified Delivery Recipient type. ## Merge Recipient Roles for Draft Envelopes When an envelope with multiple templates is sent, the recipients from the templates are merged according to the template roles, and empty recipients are removed. When creating an envelope with multiple templates, but not sending it (keeping it in a created state), duplicate recipients are not merged, which could cause leave duplicate recipients in the envelope. To prevent this, the query parameter `merge_roles_on_draft` should be added when posting a draft envelope (status=created) with multiple templates. Doing this will merge template roles and remove empty recipients. ###### Note: DocuSign recommends that the `merge_roles_on_draft` query parameter be used anytime you are creating an envelope with multiple templates and keeping it in draft (created) status. 1356 This method makes a synchronous HTTP request by default. To make an 1357 asynchronous HTTP request, please define a `callback` function 1358 to be invoked when receiving the response. 1359 >>> def callback_function(response): 1360 >>> pprint(response) 1361 >>> 1362 >>> thread = api.create_envelope_with_http_info(account_id, callback=callback_function) 1363 1364 :param callback function: The callback function 1365 for asynchronous request. (optional) 1366 :param str account_id: The external account number (int) or account ID Guid. (required) 1367 :param str cdse_mode: 1368 :param str change_routing_order: 1369 :param str completed_documents_only: If set to true then we want to set the sourceEnvelopeId to indicate that this is a\"forward\" envelope action 1370 :param str merge_roles_on_draft: When set to **true**, merges template roles and remove empty recipients when you create an envelope with multiple templates. 1371 :param str tab_label_exact_matches: 1372 :param EnvelopeDefinition envelope_definition: 1373 :return: EnvelopeSummary 1374 If the method is called asynchronously, 1375 returns the request thread. 1376 """ 1377 1378 all_params = ['account_id', 'cdse_mode', 'change_routing_order', 'completed_documents_only', 'merge_roles_on_draft', 'tab_label_exact_matches', 'envelope_definition'] 1379 all_params.append('callback') 1380 all_params.append('_return_http_data_only') 1381 all_params.append('_preload_content') 1382 all_params.append('_request_timeout') 1383 1384 params = locals() 1385 for key, val in iteritems(params['kwargs']): 1386 if key not in all_params: 1387 raise TypeError( 1388 "Got an unexpected keyword argument '%s'" 1389 " to method create_envelope" % key 1390 ) 1391 params[key] = val 1392 del params['kwargs'] 1393 # verify the required parameter 'account_id' is set 1394 if ('account_id' not in params) or (params['account_id'] is None): 1395 raise ValueError("Missing the required parameter `account_id` when calling `create_envelope`") 1396 1397 1398 collection_formats = {} 1399 1400 resource_path = '/v2.1/accounts/{accountId}/envelopes'.replace('{format}', 'json') 1401 path_params = {} 1402 if 'account_id' in params: 1403 path_params['accountId'] = params['account_id'] 1404 1405 query_params = {} 1406 if 'cdse_mode' in params: 1407 query_params['cdse_mode'] = params['cdse_mode'] 1408 if 'change_routing_order' in params: 1409 query_params['change_routing_order'] = params['change_routing_order'] 1410 if 'completed_documents_only' in params: 1411 query_params['completed_documents_only'] = params['completed_documents_only'] 1412 if 'merge_roles_on_draft' in params: 1413 query_params['merge_roles_on_draft'] = params['merge_roles_on_draft'] 1414 if 'tab_label_exact_matches' in params: 1415 query_params['tab_label_exact_matches'] = params['tab_label_exact_matches'] 1416 1417 header_params = {} 1418 1419 form_params = [] 1420 local_var_files = {} 1421 1422 body_params = None 1423 if 'envelope_definition' in params: 1424 body_params = params['envelope_definition'] 1425 # HTTP header `Accept` 1426 header_params['Accept'] = self.api_client.\ 1427 select_header_accept(['application/json']) 1428 1429 # Authentication setting 1430 auth_settings = [] 1431 1432 return self.api_client.call_api(resource_path, 'POST', 1433 path_params, 1434 query_params, 1435 header_params, 1436 body=body_params, 1437 post_params=form_params, 1438 files=local_var_files, 1439 response_type='EnvelopeSummary', 1440 auth_settings=auth_settings, 1441 callback=params.get('callback'), 1442 _return_http_data_only=params.get('_return_http_data_only'), 1443 _preload_content=params.get('_preload_content', True), 1444 _request_timeout=params.get('_request_timeout'), 1445 collection_formats=collection_formats)
Creates an envelope.
Creates an envelope. Using this function you can: * Create an envelope and send it. * Create an envelope from an existing template and send it. In either case, you can choose to save the envelope as a draft envelope instead of sending it by setting the request's status property to created instead of sent. ## Sending Envelopes Documents can be included with the Envelopes::create call itself or a template can include documents. Documents can be added by using a multi-part/form request or by using the documentBase64 field of the document object ### Recipient Types An envelopeDefinition object is used as the method's body. Envelope recipients can be defined in the envelope or in templates. The envelopeDefinition object's recipients field is an EnvelopeRecipients resource object. It includes arrays of the seven types of recipients defined by DocuSign: Recipient type | Object definition -------------- | ----------------- agent (can add name and email information for later recipients/signers) | agent carbon copy (receives a copy of the documents) | carbonCopy certified delivery (receives a copy of the documents and must acknowledge receipt) | certifiedDelivery editor (can change recipients and document fields for later recipients/signers) | editor in-person signer ("hosts" someone who signs in-person) | inPersonSigner intermediary (can add name and email information for some later recipients/signers.) | intermediary signer (signs and/or updates document fields) | signer Additional information about the different types of recipients is available from the EnvelopeRecipients resource page and from the Developer Center ### Tabs Tabs (also referred to as tags and as fields in the web sending user interface), can be defined in the envelopeDefinition, in templates, by transforming PDF Form Fields, or by using Composite Templates (see below). Defining tabs: the inPersonSigner, and signer recipient objects include a tabs field. It is an EnvelopeTabs resource object. It includes arrays of the 24 different tab types available. See the EnvelopeTabs resource for more information. ## Using Templates Envelopes use specific people or groups as recipients. Templates can specify a role, eg account_manager. When a template is used in an envelope, the roles must be replaced with specific people or groups. When you create an envelope using a templateId, the different recipient type objects within the EnvelopeRecipients object are used to assign recipients to the template's roles via the roleName property. The recipient objects can also override settings that were specified in the template, and set values for tab fields that were defined in the template. ### Message Lock When a template is added or applied to an envelope and the template has a locked email subject and message, that subject and message are used for the envelope and cannot be changed even if another locked template is subsequently added or applied to the envelope. The field messageLock is used to lock the email subject and message. If an email subject or message is entered before adding or applying a template with messageLock true, the email subject and message is overwritten with the locked email subject and message from the template. ## Envelope Status The status of sent envelopes can be determined through the DocuSign webhook system or by polling. Webhooks are highly recommended: they provide your application with the quickest updates when an envelope's status changes. DocuSign limits polling to once every 15 minutes or less frequently. When a webhook is used, DocuSign calls your application, via the URL you provide, with a notification XML message. See the Webhook recipe for examples and live demos of using webhooks. ## Webhook Options The two webhook options, eventNotification and Connect use the same notification mechanism and message formats. eventNotification is used to create a webhook for a specific envelope sent via the API. Connect webhooks can be used for any envelope sent from an account, from any user, from any client. ### eventNotification Webhooks The Envelopes::create method includes an optional eventNotification object that adds a webhook to the envelope. eventNotification webhooks are available for all DocuSign accounts with API access. ### Connect Webhooks Connect can be used to create a webhook for all envelopes sent by all users in an account, either through the API or via other DocuSign clients (web, mobile, etc). Connect configurations are independent of specific envelopes. A Connect configuration includes a filter that may be used to limit the webhook to specific users, envelope statuses, etc. Connect configurations may be created and managed using the ConnectConfigurations resource. Configurations can also be created and managed from the Administration tool accessed by selecting "Go to Admin" from the menu next to your picture on the DocuSign web app. See the Integrations/Connect section of the Admin tool. For repeatability, and to minimize support questions, creating Connect configurations via the API is recommended, especially for ISVs. Connect is available for some DocuSign account types. Please contact DocuSign Sales for more information. ## Composite Templates The Composite Templates feature, like compositing in film production, enables you to overlay document, recipient, and tab definitions from multiple sources, including PDF Form Field definitions, templates defined on the server, and more. Each Composite Template consists of optional elements: server templates, inline templates, PDF Metadata templates, and documents. * The Composite Template ID is an optional element used to identify the composite template. It is used as a reference when adding document object information via a multi-part HTTP message. If used, the document content-disposition must include the compositeTemplateId to which the document should be added. If compositeTemplateId is not specified in the content-disposition, the document is applied based on the documentId only. If no document object is specified, the composite template inherits the first document. * Server Templates are server-side templates stored on the DocuSign platform. If supplied, they are overlaid into the envelope in the order of their Sequence value. * Inline Templates provide a container to add documents, recipients, tabs, and custom fields. If inline templates are supplied, they are overlaid into the envelope in the order of their Sequence value. * Document objects are optional structures that provide a container to pass in a document or form. If this object is not included, the composite template inherits the first document it finds from a server template or inline template, starting with the lowest sequence value. PDF Form objects are only transformed from the document object. DocuSign does not derive PDF form properties from server templates or inline templates. To instruct DocuSign to transform fields from the PDF form, set transformPdfFields to "true" for the document. See the Transform PDF Fields section for more information about process. * PDF Metadata Templates provide a container to embed design-time template information into a PDF document. DocuSign uses this information when processing the Envelope. This convention allows the document to carry the signing instructions with it, so that less information needs to be provided at run-time through an inline template or synchronized with an external structure like a server template. PDF Metadata templates are stored in the Metadata layer of a PDF in accordance with Acrobat's XMP specification. DocuSign will only find PDF Metadata templates inside documents passed in the Document object (see below). If supplied, the PDF metadata template will be overlaid into the envelope in the order of its Sequence value. ### Compositing the definitions Each Composite Template adds a new document and templates overlay into the envelope. For each Composite Template these rules are applied: * Templates are overlaid in the order of their Sequence value. * If Document is not passed into the Composite Template's document field, the first template's document (based on the template's Sequence value) is used. * Last in wins in all cases except for the document (i.e. envelope information, recipient information, secure field information). There is no special casing. For example, if you want higher security on a tab, then that needs to be specified in a later template (by sequence number) then where the tab is included. If you want higher security on a role recipient, then it needs to be in a later template then where that role recipient is specified. * Recipient matching is based on Recipient Role and Routing Order. If there are matches, the recipient information is merged together. A final pass is done on all Composite Templates, after all template overlays have been applied, to collapse recipients with the same email, username and routing order. This prevents having the same recipients at the same routing order. * If you specify in a template that a recipient is locked, once that recipient is overlaid the recipient attributes can no longer be changed. The only items that can be changed for the recipient in this case are the email, username, access code and IDCheckInformationInput. * Tab matching is based on Tab Labels, Tab Types and Documents. If a Tab Label matches but the Document is not supplied, the Tab is overlaid for all the Documents. For example, if you have a simple inline template with only one tab in it with a label and a value, the Signature, Initial, Company, Envelope ID, User Name tabs will only be matched and collapsed if they fall in the exact same X and Y locations. * roleName and tabLabel matching is case sensitive. * The defaultRecipient field enables you to specify which recipient the generated tabs from a PDF form are mapped to. You can also set PDF form generated tabs to a recipient other than the DefaultRecipient by specifying the mapping of the tab label that is created to one of the template recipients. * You can use tabLabel wild carding to map a series of tabs from the PDF form. To use this you must end a tab label with "*" and then the system matches tabs that start with the label. * If no DefaultRecipient is specified, tabs must be explicitly mapped to recipients in order to be generated from the form. Unmapped form objects will not be generated into their DocuSign equivalents. (In the case of Signature/Initials, the tabs will be disregarded entirely; in the case of pdf text fields, the field data will be flattened on the Envelope document, but there will not be a corresponding DocuSign data tab.) ### Including the Document Content for Composite Templates Document content can be supplied inline, using the documentBase64 or can be included in a multi-part HTTP message. If a multi-part message is used and there are multiple Composite Templates, the document content-disposition can include the compositeTemplateId to which the document should be added. Using the compositeTemplateId sets which documents are associated with particular composite templates. An example of this usage is: --5cd3320a-5aac-4453-b3a4-cbb52a4cba5d Content-Type: application/pdf Content-Disposition: file; filename="eula.pdf"; documentId=1; compositeTemplateId="1" Content-Transfer-Encoding: base64 ### PDF Form Field Transformation Only the following PDF Form FieldTypes will be transformed to DocuSign tabs: CheckBox, DateTime, ListBox, Numeric, Password, Radio, Signature, and Text Field Properties that will be transformed: Read Only, Required, Max Length, Positions, and Initial Data. When transforming a PDF Form Digital Signature Field, the following rules are used: If the PDF Field Name Contains | Then the DocuSign Tab Will be ------- | -------- DocuSignSignHere or eSignSignHere | Signature DocuSignSignHereOptional or eSignSignHereOptional | Optional Signature DocuSignInitialHere or eSignInitialHere | Initials DocuSignInitialHereOptional or eSignInitialHereOptional | Optional Initials Any other PDF Form Digital Signature Field will be transformed to a DocuSign Signature tab When transforming PDF Form Text Fields, the following rules are used: If the PDF Field Name Contains | Then the DocuSign Tab Will be ------- | -------- DocuSignSignHere or eSignSignHere | Signature DocuSignSignHereOptional or eSignSignHereOptional | Optional Signature DocuSignInitialHere or eSignInitialHere | Initials DocuSignInitialHereOptional or eSignInitialHereOptional | Optional Initials DocuSignEnvelopeID or eSignEnvelopeID | EnvelopeID DocuSignCompany or eSignCompany | Company DocuSignDateSigned or eSignDateSigned | Date Signed DocuSignTitle or eSignTitle | Title DocuSignFullName or eSignFullName | Full Name DocuSignSignerAttachmentOptional or eSignSignerAttachmentOptional | Optional Signer Attachment Any other PDF Form Text Field will be transformed to a DocuSign data (text) tab. PDF Form Field Names that include "DocuSignIgnoreTransform" or "eSignIgnoreTransform" will not be transformed. PDF Form Date fields will be transformed to Date Signed fields if their name includes DocuSignDateSigned or eSignDateSigned. ## Template Email Subject Merge Fields This feature enables you to insert recipient name and email address merge fields into the email subject line when creating or sending from a template. The merge fields, based on the recipient's roleName, are added to the emailSubject when the template is created or when the template is used to create an envelope. After a template sender adds the name and email information for the recipient and sends the envelope, the recipient information is automatically merged into the appropriate fields in the email subject line. Both the sender and the recipients will see the information in the email subject line for any emails associated with the template. This provides an easy way for senders to organize their envelope emails without having to open an envelope to check the recipient. If merging the recipient information into the subject line causes the subject line to exceed 100 characters, then any characters over the 100 character limit are not included in the subject line. For cases where the recipient name or email is expected to be long, you should consider placing the merge field at the start of the email subject. * To add a recipient's name in the subject line add the following text in the emailSubject when creating the template or when sending an envelope from a template: [["emailSubject":"[[Signer 1_UserName]], Please sign this NDA", * To add a recipient's email address in the subject line add the following text in the emailSubject when creating the template or when sending an envelope from a template: [["emailSubject":"[[Signer 1_Email]], Please sign this NDA", In both cases the roleName in the template. For cases where another recipient (such as an Agent, Editor, or Intermediary recipient) is entering the name and email information for the recipient included in the email subject, then [[brandId used in an envelope: * If a brandId is specified in the envelope/template and that brandId is available to the account, that brand is used in the envelope. * If more than one template is used in an envelope and more than one brandId is specified, the first brandId specified is used throughout the envelope. * In cases where no brand is specified and the sender belongs to a Group; if there is only one brand associated with the Group, then that brand is used in the envelope. Otherwise, the account's default signing brand is used. * For envelopes that do not meet any of the previous criteria, the account's default signing brand is used for the envelope. ## BCC Email address feature The BCC Email address feature is designed to provide a copy of all email communications for external archiving purposes. DocuSign recommends that envelopes sent using the BCC for Email Archive feature, including the BCC Email Override option, include additional signer authentication options. To send a copy of the envelope to a recipient who does not need to sign, don't use the BCC Email field. Use a Carbon Copy or Certified Delivery Recipient type. ## Merge Recipient Roles for Draft Envelopes When an envelope with multiple templates is sent, the recipients from the templates are merged according to the template roles, and empty recipients are removed. When creating an envelope with multiple templates, but not sending it (keeping it in a created state), duplicate recipients are not merged, which could cause leave duplicate recipients in the envelope. To prevent this, the query parameter merge_roles_on_draft should be added when posting a draft envelope (status=created) with multiple templates. Doing this will merge template roles and remove empty recipients. ###### Note: DocuSign recommends that the merge_roles_on_draft query parameter be used anytime you are creating an envelope with multiple templates and keeping it in draft (created) status.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_envelope_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str cdse_mode:
- str change_routing_order:
- str completed_documents_only: If set to true then we want to set the sourceEnvelopeId to indicate that this is a"forward" envelope action
- str merge_roles_on_draft: When set to true, merges template roles and remove empty recipients when you create an envelope with multiple templates.
- str tab_label_exact_matches:
- EnvelopeDefinition envelope_definition:
Returns
EnvelopeSummary If the method is called asynchronously, returns the request thread.
def
create_envelope_comments(self, account_id, envelope_id, **kwargs)
1447 def create_envelope_comments(self, account_id, envelope_id, **kwargs): 1448 """ 1449 Posts a list of comments for authorized user 1450 1451 This method makes a synchronous HTTP request by default. To make an 1452 asynchronous HTTP request, please define a `callback` function 1453 to be invoked when receiving the response. 1454 >>> def callback_function(response): 1455 >>> pprint(response) 1456 >>> 1457 >>> thread = api.create_envelope_comments(account_id, envelope_id, callback=callback_function) 1458 1459 :param callback function: The callback function 1460 for asynchronous request. (optional) 1461 :param str account_id: The external account number (int) or account ID Guid. (required) 1462 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1463 :param CommentsPublish comments_publish: 1464 :return: CommentHistoryResult 1465 If the method is called asynchronously, 1466 returns the request thread. 1467 """ 1468 kwargs['_return_http_data_only'] = True 1469 if kwargs.get('callback'): 1470 return self.create_envelope_comments_with_http_info(account_id, envelope_id, **kwargs) 1471 else: 1472 (data) = self.create_envelope_comments_with_http_info(account_id, envelope_id, **kwargs) 1473 return data
Posts a list of comments for authorized user
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_envelope_comments(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- CommentsPublish comments_publish:
Returns
CommentHistoryResult If the method is called asynchronously, returns the request thread.
def
create_envelope_comments_with_http_info(self, account_id, envelope_id, **kwargs)
1475 def create_envelope_comments_with_http_info(self, account_id, envelope_id, **kwargs): 1476 """ 1477 Posts a list of comments for authorized user 1478 1479 This method makes a synchronous HTTP request by default. To make an 1480 asynchronous HTTP request, please define a `callback` function 1481 to be invoked when receiving the response. 1482 >>> def callback_function(response): 1483 >>> pprint(response) 1484 >>> 1485 >>> thread = api.create_envelope_comments_with_http_info(account_id, envelope_id, callback=callback_function) 1486 1487 :param callback function: The callback function 1488 for asynchronous request. (optional) 1489 :param str account_id: The external account number (int) or account ID Guid. (required) 1490 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1491 :param CommentsPublish comments_publish: 1492 :return: CommentHistoryResult 1493 If the method is called asynchronously, 1494 returns the request thread. 1495 """ 1496 1497 all_params = ['account_id', 'envelope_id', 'comments_publish'] 1498 all_params.append('callback') 1499 all_params.append('_return_http_data_only') 1500 all_params.append('_preload_content') 1501 all_params.append('_request_timeout') 1502 1503 params = locals() 1504 for key, val in iteritems(params['kwargs']): 1505 if key not in all_params: 1506 raise TypeError( 1507 "Got an unexpected keyword argument '%s'" 1508 " to method create_envelope_comments" % key 1509 ) 1510 params[key] = val 1511 del params['kwargs'] 1512 # verify the required parameter 'account_id' is set 1513 if ('account_id' not in params) or (params['account_id'] is None): 1514 raise ValueError("Missing the required parameter `account_id` when calling `create_envelope_comments`") 1515 # verify the required parameter 'envelope_id' is set 1516 if ('envelope_id' not in params) or (params['envelope_id'] is None): 1517 raise ValueError("Missing the required parameter `envelope_id` when calling `create_envelope_comments`") 1518 1519 1520 collection_formats = {} 1521 1522 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/comments'.replace('{format}', 'json') 1523 path_params = {} 1524 if 'account_id' in params: 1525 path_params['accountId'] = params['account_id'] 1526 if 'envelope_id' in params: 1527 path_params['envelopeId'] = params['envelope_id'] 1528 1529 query_params = {} 1530 1531 header_params = {} 1532 1533 form_params = [] 1534 local_var_files = {} 1535 1536 body_params = None 1537 if 'comments_publish' in params: 1538 body_params = params['comments_publish'] 1539 # HTTP header `Accept` 1540 header_params['Accept'] = self.api_client.\ 1541 select_header_accept(['application/json']) 1542 1543 # Authentication setting 1544 auth_settings = [] 1545 1546 return self.api_client.call_api(resource_path, 'POST', 1547 path_params, 1548 query_params, 1549 header_params, 1550 body=body_params, 1551 post_params=form_params, 1552 files=local_var_files, 1553 response_type='CommentHistoryResult', 1554 auth_settings=auth_settings, 1555 callback=params.get('callback'), 1556 _return_http_data_only=params.get('_return_http_data_only'), 1557 _preload_content=params.get('_preload_content', True), 1558 _request_timeout=params.get('_request_timeout'), 1559 collection_formats=collection_formats)
Posts a list of comments for authorized user
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_envelope_comments_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- CommentsPublish comments_publish:
Returns
CommentHistoryResult If the method is called asynchronously, returns the request thread.
def
create_envelope_recipient_preview(self, account_id, envelope_id, **kwargs)
1561 def create_envelope_recipient_preview(self, account_id, envelope_id, **kwargs): 1562 """ 1563 Provides a URL to start a recipient view of the Envelope UI 1564 This method returns a URL for an envelope recipient preview in the DocuSign UI that you can embed in your application. You use this method to enable the sender to preview the recipients' experience. For more information, see [Preview and Send](https://support.docusign.com/en/guides/ndse-user-guide-send-your-documents). 1565 This method makes a synchronous HTTP request by default. To make an 1566 asynchronous HTTP request, please define a `callback` function 1567 to be invoked when receiving the response. 1568 >>> def callback_function(response): 1569 >>> pprint(response) 1570 >>> 1571 >>> thread = api.create_envelope_recipient_preview(account_id, envelope_id, callback=callback_function) 1572 1573 :param callback function: The callback function 1574 for asynchronous request. (optional) 1575 :param str account_id: The external account number (int) or account ID Guid. (required) 1576 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1577 :param RecipientPreviewRequest recipient_preview_request: 1578 :return: ViewUrl 1579 If the method is called asynchronously, 1580 returns the request thread. 1581 """ 1582 kwargs['_return_http_data_only'] = True 1583 if kwargs.get('callback'): 1584 return self.create_envelope_recipient_preview_with_http_info(account_id, envelope_id, **kwargs) 1585 else: 1586 (data) = self.create_envelope_recipient_preview_with_http_info(account_id, envelope_id, **kwargs) 1587 return data
Provides a URL to start a recipient view of the Envelope UI
This method returns a URL for an envelope recipient preview in the DocuSign UI that you can embed in your application. You use this method to enable the sender to preview the recipients' experience. For more information, see Preview and Send.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_envelope_recipient_preview(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- RecipientPreviewRequest recipient_preview_request:
Returns
ViewUrl If the method is called asynchronously, returns the request thread.
def
create_envelope_recipient_preview_with_http_info(self, account_id, envelope_id, **kwargs)
1589 def create_envelope_recipient_preview_with_http_info(self, account_id, envelope_id, **kwargs): 1590 """ 1591 Provides a URL to start a recipient view of the Envelope UI 1592 This method returns a URL for an envelope recipient preview in the DocuSign UI that you can embed in your application. You use this method to enable the sender to preview the recipients' experience. For more information, see [Preview and Send](https://support.docusign.com/en/guides/ndse-user-guide-send-your-documents). 1593 This method makes a synchronous HTTP request by default. To make an 1594 asynchronous HTTP request, please define a `callback` function 1595 to be invoked when receiving the response. 1596 >>> def callback_function(response): 1597 >>> pprint(response) 1598 >>> 1599 >>> thread = api.create_envelope_recipient_preview_with_http_info(account_id, envelope_id, callback=callback_function) 1600 1601 :param callback function: The callback function 1602 for asynchronous request. (optional) 1603 :param str account_id: The external account number (int) or account ID Guid. (required) 1604 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1605 :param RecipientPreviewRequest recipient_preview_request: 1606 :return: ViewUrl 1607 If the method is called asynchronously, 1608 returns the request thread. 1609 """ 1610 1611 all_params = ['account_id', 'envelope_id', 'recipient_preview_request'] 1612 all_params.append('callback') 1613 all_params.append('_return_http_data_only') 1614 all_params.append('_preload_content') 1615 all_params.append('_request_timeout') 1616 1617 params = locals() 1618 for key, val in iteritems(params['kwargs']): 1619 if key not in all_params: 1620 raise TypeError( 1621 "Got an unexpected keyword argument '%s'" 1622 " to method create_envelope_recipient_preview" % key 1623 ) 1624 params[key] = val 1625 del params['kwargs'] 1626 # verify the required parameter 'account_id' is set 1627 if ('account_id' not in params) or (params['account_id'] is None): 1628 raise ValueError("Missing the required parameter `account_id` when calling `create_envelope_recipient_preview`") 1629 # verify the required parameter 'envelope_id' is set 1630 if ('envelope_id' not in params) or (params['envelope_id'] is None): 1631 raise ValueError("Missing the required parameter `envelope_id` when calling `create_envelope_recipient_preview`") 1632 1633 1634 collection_formats = {} 1635 1636 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/recipient_preview'.replace('{format}', 'json') 1637 path_params = {} 1638 if 'account_id' in params: 1639 path_params['accountId'] = params['account_id'] 1640 if 'envelope_id' in params: 1641 path_params['envelopeId'] = params['envelope_id'] 1642 1643 query_params = {} 1644 1645 header_params = {} 1646 1647 form_params = [] 1648 local_var_files = {} 1649 1650 body_params = None 1651 if 'recipient_preview_request' in params: 1652 body_params = params['recipient_preview_request'] 1653 # HTTP header `Accept` 1654 header_params['Accept'] = self.api_client.\ 1655 select_header_accept(['application/json']) 1656 1657 # Authentication setting 1658 auth_settings = [] 1659 1660 return self.api_client.call_api(resource_path, 'POST', 1661 path_params, 1662 query_params, 1663 header_params, 1664 body=body_params, 1665 post_params=form_params, 1666 files=local_var_files, 1667 response_type='ViewUrl', 1668 auth_settings=auth_settings, 1669 callback=params.get('callback'), 1670 _return_http_data_only=params.get('_return_http_data_only'), 1671 _preload_content=params.get('_preload_content', True), 1672 _request_timeout=params.get('_request_timeout'), 1673 collection_formats=collection_formats)
Provides a URL to start a recipient view of the Envelope UI
This method returns a URL for an envelope recipient preview in the DocuSign UI that you can embed in your application. You use this method to enable the sender to preview the recipients' experience. For more information, see Preview and Send.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_envelope_recipient_preview_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- RecipientPreviewRequest recipient_preview_request:
Returns
ViewUrl If the method is called asynchronously, returns the request thread.
def
create_envelope_transfer_rules(self, account_id, **kwargs)
1789 def create_envelope_transfer_rules(self, account_id, **kwargs): 1790 """ 1791 Add envelope transfer rules to an account. 1792 This method creates an envelope transfer rule. When you create an envelope transfer rule, you specify the following properties: - `eventType` - `fromGroups` - `toUser` - `toFolder` - `carbonCopyOriginalOwner` - `enabled` **Note:** Only Administrators can create envelope transfer rules. In addition, to use envelope transfer rules, the **Transfer Custody** feature must be enabled for your account. 1793 This method makes a synchronous HTTP request by default. To make an 1794 asynchronous HTTP request, please define a `callback` function 1795 to be invoked when receiving the response. 1796 >>> def callback_function(response): 1797 >>> pprint(response) 1798 >>> 1799 >>> thread = api.create_envelope_transfer_rules(account_id, callback=callback_function) 1800 1801 :param callback function: The callback function 1802 for asynchronous request. (optional) 1803 :param str account_id: The external account number (int) or account ID Guid. (required) 1804 :param EnvelopeTransferRuleRequest envelope_transfer_rule_request: 1805 :return: EnvelopeTransferRuleInformation 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.create_envelope_transfer_rules_with_http_info(account_id, **kwargs) 1812 else: 1813 (data) = self.create_envelope_transfer_rules_with_http_info(account_id, **kwargs) 1814 return data
Add envelope transfer rules to an account.
This method creates an envelope transfer rule. When you create an envelope transfer rule, you specify the following properties: - eventType - fromGroups - toUser - toFolder - carbonCopyOriginalOwner - enabled Note: Only Administrators can create envelope transfer rules. In addition, to use envelope transfer rules, the Transfer Custody feature must be enabled for your account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_envelope_transfer_rules(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- EnvelopeTransferRuleRequest envelope_transfer_rule_request:
Returns
EnvelopeTransferRuleInformation If the method is called asynchronously, returns the request thread.
def
create_envelope_transfer_rules_with_http_info(self, account_id, **kwargs)
1816 def create_envelope_transfer_rules_with_http_info(self, account_id, **kwargs): 1817 """ 1818 Add envelope transfer rules to an account. 1819 This method creates an envelope transfer rule. When you create an envelope transfer rule, you specify the following properties: - `eventType` - `fromGroups` - `toUser` - `toFolder` - `carbonCopyOriginalOwner` - `enabled` **Note:** Only Administrators can create envelope transfer rules. In addition, to use envelope transfer rules, the **Transfer Custody** feature must be enabled for your account. 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.create_envelope_transfer_rules_with_http_info(account_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 EnvelopeTransferRuleRequest envelope_transfer_rule_request: 1832 :return: EnvelopeTransferRuleInformation 1833 If the method is called asynchronously, 1834 returns the request thread. 1835 """ 1836 1837 all_params = ['account_id', 'envelope_transfer_rule_request'] 1838 all_params.append('callback') 1839 all_params.append('_return_http_data_only') 1840 all_params.append('_preload_content') 1841 all_params.append('_request_timeout') 1842 1843 params = locals() 1844 for key, val in iteritems(params['kwargs']): 1845 if key not in all_params: 1846 raise TypeError( 1847 "Got an unexpected keyword argument '%s'" 1848 " to method create_envelope_transfer_rules" % key 1849 ) 1850 params[key] = val 1851 del params['kwargs'] 1852 # verify the required parameter 'account_id' is set 1853 if ('account_id' not in params) or (params['account_id'] is None): 1854 raise ValueError("Missing the required parameter `account_id` when calling `create_envelope_transfer_rules`") 1855 1856 1857 collection_formats = {} 1858 1859 resource_path = '/v2.1/accounts/{accountId}/envelopes/transfer_rules'.replace('{format}', 'json') 1860 path_params = {} 1861 if 'account_id' in params: 1862 path_params['accountId'] = params['account_id'] 1863 1864 query_params = {} 1865 1866 header_params = {} 1867 1868 form_params = [] 1869 local_var_files = {} 1870 1871 body_params = None 1872 if 'envelope_transfer_rule_request' in params: 1873 body_params = params['envelope_transfer_rule_request'] 1874 # HTTP header `Accept` 1875 header_params['Accept'] = self.api_client.\ 1876 select_header_accept(['application/json']) 1877 1878 # Authentication setting 1879 auth_settings = [] 1880 1881 return self.api_client.call_api(resource_path, 'POST', 1882 path_params, 1883 query_params, 1884 header_params, 1885 body=body_params, 1886 post_params=form_params, 1887 files=local_var_files, 1888 response_type='EnvelopeTransferRuleInformation', 1889 auth_settings=auth_settings, 1890 callback=params.get('callback'), 1891 _return_http_data_only=params.get('_return_http_data_only'), 1892 _preload_content=params.get('_preload_content', True), 1893 _request_timeout=params.get('_request_timeout'), 1894 collection_formats=collection_formats)
Add envelope transfer rules to an account.
This method creates an envelope transfer rule. When you create an envelope transfer rule, you specify the following properties: - eventType - fromGroups - toUser - toFolder - carbonCopyOriginalOwner - enabled Note: Only Administrators can create envelope transfer rules. In addition, to use envelope transfer rules, the Transfer Custody feature must be enabled for your account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_envelope_transfer_rules_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- EnvelopeTransferRuleRequest envelope_transfer_rule_request:
Returns
EnvelopeTransferRuleInformation If the method is called asynchronously, returns the request thread.
def
create_envelope_workflow_step_definition(self, account_id, envelope_id, **kwargs)
1896 def create_envelope_workflow_step_definition(self, account_id, envelope_id, **kwargs): 1897 """ 1898 Creates and adds a new workflow step definition for an envelope's workflow 1899 This method makes a synchronous HTTP request by default. To make an 1900 asynchronous HTTP request, please define a `callback` function 1901 to be invoked when receiving the response. 1902 >>> def callback_function(response): 1903 >>> pprint(response) 1904 >>> 1905 >>> thread = api.create_envelope_workflow_step_definition(account_id, envelope_id, callback=callback_function) 1906 1907 :param callback function: The callback function 1908 for asynchronous request. (optional) 1909 :param str account_id: The external account number (int) or account ID Guid. (required) 1910 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1911 :param WorkflowStep workflow_step: 1912 :return: WorkflowStep 1913 If the method is called asynchronously, 1914 returns the request thread. 1915 """ 1916 kwargs['_return_http_data_only'] = True 1917 if kwargs.get('callback'): 1918 return self.create_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, **kwargs) 1919 else: 1920 (data) = self.create_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, **kwargs) 1921 return data
Creates and adds a new workflow step definition for an envelope's workflow
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_envelope_workflow_step_definition(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- WorkflowStep workflow_step:
Returns
WorkflowStep If the method is called asynchronously, returns the request thread.
def
create_envelope_workflow_step_definition_with_http_info(self, account_id, envelope_id, **kwargs)
1923 def create_envelope_workflow_step_definition_with_http_info(self, account_id, envelope_id, **kwargs): 1924 """ 1925 Creates and adds a new workflow step definition for an envelope's workflow 1926 This method makes a synchronous HTTP request by default. To make an 1927 asynchronous HTTP request, please define a `callback` function 1928 to be invoked when receiving the response. 1929 >>> def callback_function(response): 1930 >>> pprint(response) 1931 >>> 1932 >>> thread = api.create_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, callback=callback_function) 1933 1934 :param callback function: The callback function 1935 for asynchronous request. (optional) 1936 :param str account_id: The external account number (int) or account ID Guid. (required) 1937 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 1938 :param WorkflowStep workflow_step: 1939 :return: WorkflowStep 1940 If the method is called asynchronously, 1941 returns the request thread. 1942 """ 1943 1944 all_params = ['account_id', 'envelope_id', 'workflow_step'] 1945 all_params.append('callback') 1946 all_params.append('_return_http_data_only') 1947 all_params.append('_preload_content') 1948 all_params.append('_request_timeout') 1949 1950 params = locals() 1951 for key, val in iteritems(params['kwargs']): 1952 if key not in all_params: 1953 raise TypeError( 1954 "Got an unexpected keyword argument '%s'" 1955 " to method create_envelope_workflow_step_definition" % key 1956 ) 1957 params[key] = val 1958 del params['kwargs'] 1959 # verify the required parameter 'account_id' is set 1960 if ('account_id' not in params) or (params['account_id'] is None): 1961 raise ValueError("Missing the required parameter `account_id` when calling `create_envelope_workflow_step_definition`") 1962 # verify the required parameter 'envelope_id' is set 1963 if ('envelope_id' not in params) or (params['envelope_id'] is None): 1964 raise ValueError("Missing the required parameter `envelope_id` when calling `create_envelope_workflow_step_definition`") 1965 1966 1967 collection_formats = {} 1968 1969 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps'.replace('{format}', 'json') 1970 path_params = {} 1971 if 'account_id' in params: 1972 path_params['accountId'] = params['account_id'] 1973 if 'envelope_id' in params: 1974 path_params['envelopeId'] = params['envelope_id'] 1975 1976 query_params = {} 1977 1978 header_params = {} 1979 1980 form_params = [] 1981 local_var_files = {} 1982 1983 body_params = None 1984 if 'workflow_step' in params: 1985 body_params = params['workflow_step'] 1986 # HTTP header `Accept` 1987 header_params['Accept'] = self.api_client.\ 1988 select_header_accept(['application/json']) 1989 1990 # Authentication setting 1991 auth_settings = [] 1992 1993 return self.api_client.call_api(resource_path, 'POST', 1994 path_params, 1995 query_params, 1996 header_params, 1997 body=body_params, 1998 post_params=form_params, 1999 files=local_var_files, 2000 response_type='WorkflowStep', 2001 auth_settings=auth_settings, 2002 callback=params.get('callback'), 2003 _return_http_data_only=params.get('_return_http_data_only'), 2004 _preload_content=params.get('_preload_content', True), 2005 _request_timeout=params.get('_request_timeout'), 2006 collection_formats=collection_formats)
Creates and adds a new workflow step definition for an envelope's workflow
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- WorkflowStep workflow_step:
Returns
WorkflowStep If the method is called asynchronously, returns the request thread.
def
create_historical_envelope_publish_transaction(self, account_id, **kwargs)
2008 def create_historical_envelope_publish_transaction(self, account_id, **kwargs): 2009 """ 2010 Submits a batch of historical envelopes for republish to an adhoc config. 2011 This method makes a synchronous HTTP request by default. To make an 2012 asynchronous HTTP request, please define a `callback` function 2013 to be invoked when receiving the response. 2014 >>> def callback_function(response): 2015 >>> pprint(response) 2016 >>> 2017 >>> thread = api.create_historical_envelope_publish_transaction(account_id, callback=callback_function) 2018 2019 :param callback function: The callback function 2020 for asynchronous request. (optional) 2021 :param str account_id: The external account number (int) or account ID Guid. (required) 2022 :param ConnectHistoricalEnvelopeRepublish connect_historical_envelope_republish: 2023 :return: EnvelopePublishTransaction 2024 If the method is called asynchronously, 2025 returns the request thread. 2026 """ 2027 kwargs['_return_http_data_only'] = True 2028 if kwargs.get('callback'): 2029 return self.create_historical_envelope_publish_transaction_with_http_info(account_id, **kwargs) 2030 else: 2031 (data) = self.create_historical_envelope_publish_transaction_with_http_info(account_id, **kwargs) 2032 return data
Submits a batch of historical envelopes for republish to an adhoc config.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_historical_envelope_publish_transaction(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- ConnectHistoricalEnvelopeRepublish connect_historical_envelope_republish:
Returns
EnvelopePublishTransaction If the method is called asynchronously, returns the request thread.
def
create_historical_envelope_publish_transaction_with_http_info(self, account_id, **kwargs)
2034 def create_historical_envelope_publish_transaction_with_http_info(self, account_id, **kwargs): 2035 """ 2036 Submits a batch of historical envelopes for republish to an adhoc config. 2037 This method makes a synchronous HTTP request by default. To make an 2038 asynchronous HTTP request, please define a `callback` function 2039 to be invoked when receiving the response. 2040 >>> def callback_function(response): 2041 >>> pprint(response) 2042 >>> 2043 >>> thread = api.create_historical_envelope_publish_transaction_with_http_info(account_id, callback=callback_function) 2044 2045 :param callback function: The callback function 2046 for asynchronous request. (optional) 2047 :param str account_id: The external account number (int) or account ID Guid. (required) 2048 :param ConnectHistoricalEnvelopeRepublish connect_historical_envelope_republish: 2049 :return: EnvelopePublishTransaction 2050 If the method is called asynchronously, 2051 returns the request thread. 2052 """ 2053 2054 all_params = ['account_id', 'connect_historical_envelope_republish'] 2055 all_params.append('callback') 2056 all_params.append('_return_http_data_only') 2057 all_params.append('_preload_content') 2058 all_params.append('_request_timeout') 2059 2060 params = locals() 2061 for key, val in iteritems(params['kwargs']): 2062 if key not in all_params: 2063 raise TypeError( 2064 "Got an unexpected keyword argument '%s'" 2065 " to method create_historical_envelope_publish_transaction" % key 2066 ) 2067 params[key] = val 2068 del params['kwargs'] 2069 # verify the required parameter 'account_id' is set 2070 if ('account_id' not in params) or (params['account_id'] is None): 2071 raise ValueError("Missing the required parameter `account_id` when calling `create_historical_envelope_publish_transaction`") 2072 2073 2074 collection_formats = {} 2075 2076 resource_path = '/v2.1/accounts/{accountId}/connect/envelopes/publish/historical'.replace('{format}', 'json') 2077 path_params = {} 2078 if 'account_id' in params: 2079 path_params['accountId'] = params['account_id'] 2080 2081 query_params = {} 2082 2083 header_params = {} 2084 2085 form_params = [] 2086 local_var_files = {} 2087 2088 body_params = None 2089 if 'connect_historical_envelope_republish' in params: 2090 body_params = params['connect_historical_envelope_republish'] 2091 # HTTP header `Accept` 2092 header_params['Accept'] = self.api_client.\ 2093 select_header_accept(['application/json']) 2094 2095 # Authentication setting 2096 auth_settings = [] 2097 2098 return self.api_client.call_api(resource_path, 'POST', 2099 path_params, 2100 query_params, 2101 header_params, 2102 body=body_params, 2103 post_params=form_params, 2104 files=local_var_files, 2105 response_type='EnvelopePublishTransaction', 2106 auth_settings=auth_settings, 2107 callback=params.get('callback'), 2108 _return_http_data_only=params.get('_return_http_data_only'), 2109 _preload_content=params.get('_preload_content', True), 2110 _request_timeout=params.get('_request_timeout'), 2111 collection_formats=collection_formats)
Submits a batch of historical envelopes for republish to an adhoc config.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_historical_envelope_publish_transaction_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- ConnectHistoricalEnvelopeRepublish connect_historical_envelope_republish:
Returns
EnvelopePublishTransaction If the method is called asynchronously, returns the request thread.
def
create_lock(self, account_id, envelope_id, **kwargs)
2113 def create_lock(self, account_id, envelope_id, **kwargs): 2114 """ 2115 Lock an envelope. 2116 Locks the specified envelope, and sets the time until the lock expires, to prevent other users or recipients from accessing and changing the envelope. ###### Note: Users must have envelope locking capability enabled to use this function (userSetting `canLockEnvelopes` must be set to true for the user). 2117 This method makes a synchronous HTTP request by default. To make an 2118 asynchronous HTTP request, please define a `callback` function 2119 to be invoked when receiving the response. 2120 >>> def callback_function(response): 2121 >>> pprint(response) 2122 >>> 2123 >>> thread = api.create_lock(account_id, envelope_id, callback=callback_function) 2124 2125 :param callback function: The callback function 2126 for asynchronous request. (optional) 2127 :param str account_id: The external account number (int) or account ID Guid. (required) 2128 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2129 :param LockRequest lock_request: 2130 :return: LockInformation 2131 If the method is called asynchronously, 2132 returns the request thread. 2133 """ 2134 kwargs['_return_http_data_only'] = True 2135 if kwargs.get('callback'): 2136 return self.create_lock_with_http_info(account_id, envelope_id, **kwargs) 2137 else: 2138 (data) = self.create_lock_with_http_info(account_id, envelope_id, **kwargs) 2139 return data
Lock an envelope.
Locks the specified envelope, and sets the time until the lock expires, to prevent other users or recipients from accessing and changing the envelope. ###### Note: Users must have envelope locking capability enabled to use this function (userSetting canLockEnvelopes must be set to true for the user).
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_lock(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- LockRequest lock_request:
Returns
LockInformation If the method is called asynchronously, returns the request thread.
def
create_lock_with_http_info(self, account_id, envelope_id, **kwargs)
2141 def create_lock_with_http_info(self, account_id, envelope_id, **kwargs): 2142 """ 2143 Lock an envelope. 2144 Locks the specified envelope, and sets the time until the lock expires, to prevent other users or recipients from accessing and changing the envelope. ###### Note: Users must have envelope locking capability enabled to use this function (userSetting `canLockEnvelopes` must be set to true for the user). 2145 This method makes a synchronous HTTP request by default. To make an 2146 asynchronous HTTP request, please define a `callback` function 2147 to be invoked when receiving the response. 2148 >>> def callback_function(response): 2149 >>> pprint(response) 2150 >>> 2151 >>> thread = api.create_lock_with_http_info(account_id, envelope_id, callback=callback_function) 2152 2153 :param callback function: The callback function 2154 for asynchronous request. (optional) 2155 :param str account_id: The external account number (int) or account ID Guid. (required) 2156 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2157 :param LockRequest lock_request: 2158 :return: LockInformation 2159 If the method is called asynchronously, 2160 returns the request thread. 2161 """ 2162 2163 all_params = ['account_id', 'envelope_id', 'lock_request'] 2164 all_params.append('callback') 2165 all_params.append('_return_http_data_only') 2166 all_params.append('_preload_content') 2167 all_params.append('_request_timeout') 2168 2169 params = locals() 2170 for key, val in iteritems(params['kwargs']): 2171 if key not in all_params: 2172 raise TypeError( 2173 "Got an unexpected keyword argument '%s'" 2174 " to method create_lock" % key 2175 ) 2176 params[key] = val 2177 del params['kwargs'] 2178 # verify the required parameter 'account_id' is set 2179 if ('account_id' not in params) or (params['account_id'] is None): 2180 raise ValueError("Missing the required parameter `account_id` when calling `create_lock`") 2181 # verify the required parameter 'envelope_id' is set 2182 if ('envelope_id' not in params) or (params['envelope_id'] is None): 2183 raise ValueError("Missing the required parameter `envelope_id` when calling `create_lock`") 2184 2185 2186 collection_formats = {} 2187 2188 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/lock'.replace('{format}', 'json') 2189 path_params = {} 2190 if 'account_id' in params: 2191 path_params['accountId'] = params['account_id'] 2192 if 'envelope_id' in params: 2193 path_params['envelopeId'] = params['envelope_id'] 2194 2195 query_params = {} 2196 2197 header_params = {} 2198 2199 form_params = [] 2200 local_var_files = {} 2201 2202 body_params = None 2203 if 'lock_request' in params: 2204 body_params = params['lock_request'] 2205 # HTTP header `Accept` 2206 header_params['Accept'] = self.api_client.\ 2207 select_header_accept(['application/json']) 2208 2209 # Authentication setting 2210 auth_settings = [] 2211 2212 return self.api_client.call_api(resource_path, 'POST', 2213 path_params, 2214 query_params, 2215 header_params, 2216 body=body_params, 2217 post_params=form_params, 2218 files=local_var_files, 2219 response_type='LockInformation', 2220 auth_settings=auth_settings, 2221 callback=params.get('callback'), 2222 _return_http_data_only=params.get('_return_http_data_only'), 2223 _preload_content=params.get('_preload_content', True), 2224 _request_timeout=params.get('_request_timeout'), 2225 collection_formats=collection_formats)
Lock an envelope.
Locks the specified envelope, and sets the time until the lock expires, to prevent other users or recipients from accessing and changing the envelope. ###### Note: Users must have envelope locking capability enabled to use this function (userSetting canLockEnvelopes must be set to true for the user).
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_lock_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- LockRequest lock_request:
Returns
LockInformation If the method is called asynchronously, returns the request thread.
def
create_recipient(self, account_id, envelope_id, **kwargs)
2227 def create_recipient(self, account_id, envelope_id, **kwargs): 2228 """ 2229 Adds one or more recipients to an envelope. 2230 Adds one or more recipients to an envelope. For an in process envelope, one that has been sent and has not been completed or voided, an email is sent to a new recipient when they are reached in the routing order. If the new recipient's routing order is before or the same as the envelope's next recipient, an email is only sent if the optional `resend_envelope` query string is set to **true**. 2231 This method makes a synchronous HTTP request by default. To make an 2232 asynchronous HTTP request, please define a `callback` function 2233 to be invoked when receiving the response. 2234 >>> def callback_function(response): 2235 >>> pprint(response) 2236 >>> 2237 >>> thread = api.create_recipient(account_id, envelope_id, callback=callback_function) 2238 2239 :param callback function: The callback function 2240 for asynchronous request. (optional) 2241 :param str account_id: The external account number (int) or account ID Guid. (required) 2242 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2243 :param str resend_envelope: When set to **true**, resends the envelope if the new recipient's routing order is before or the same as the envelope's next recipient. 2244 :param Recipients recipients: 2245 :return: Recipients 2246 If the method is called asynchronously, 2247 returns the request thread. 2248 """ 2249 kwargs['_return_http_data_only'] = True 2250 if kwargs.get('callback'): 2251 return self.create_recipient_with_http_info(account_id, envelope_id, **kwargs) 2252 else: 2253 (data) = self.create_recipient_with_http_info(account_id, envelope_id, **kwargs) 2254 return data
Adds one or more recipients to an envelope.
Adds one or more recipients to an envelope. For an in process envelope, one that has been sent and has not been completed or voided, an email is sent to a new recipient when they are reached in the routing order. If the new recipient's routing order is before or the same as the envelope's next recipient, an email is only sent if the optional resend_envelope query string is set to true.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_recipient(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str resend_envelope: When set to true, resends the envelope if the new recipient's routing order is before or the same as the envelope's next recipient.
- Recipients recipients:
Returns
Recipients If the method is called asynchronously, returns the request thread.
def
create_recipient_with_http_info(self, account_id, envelope_id, **kwargs)
2256 def create_recipient_with_http_info(self, account_id, envelope_id, **kwargs): 2257 """ 2258 Adds one or more recipients to an envelope. 2259 Adds one or more recipients to an envelope. For an in process envelope, one that has been sent and has not been completed or voided, an email is sent to a new recipient when they are reached in the routing order. If the new recipient's routing order is before or the same as the envelope's next recipient, an email is only sent if the optional `resend_envelope` query string is set to **true**. 2260 This method makes a synchronous HTTP request by default. To make an 2261 asynchronous HTTP request, please define a `callback` function 2262 to be invoked when receiving the response. 2263 >>> def callback_function(response): 2264 >>> pprint(response) 2265 >>> 2266 >>> thread = api.create_recipient_with_http_info(account_id, envelope_id, callback=callback_function) 2267 2268 :param callback function: The callback function 2269 for asynchronous request. (optional) 2270 :param str account_id: The external account number (int) or account ID Guid. (required) 2271 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2272 :param str resend_envelope: When set to **true**, resends the envelope if the new recipient's routing order is before or the same as the envelope's next recipient. 2273 :param Recipients recipients: 2274 :return: Recipients 2275 If the method is called asynchronously, 2276 returns the request thread. 2277 """ 2278 2279 all_params = ['account_id', 'envelope_id', 'resend_envelope', 'recipients'] 2280 all_params.append('callback') 2281 all_params.append('_return_http_data_only') 2282 all_params.append('_preload_content') 2283 all_params.append('_request_timeout') 2284 2285 params = locals() 2286 for key, val in iteritems(params['kwargs']): 2287 if key not in all_params: 2288 raise TypeError( 2289 "Got an unexpected keyword argument '%s'" 2290 " to method create_recipient" % key 2291 ) 2292 params[key] = val 2293 del params['kwargs'] 2294 # verify the required parameter 'account_id' is set 2295 if ('account_id' not in params) or (params['account_id'] is None): 2296 raise ValueError("Missing the required parameter `account_id` when calling `create_recipient`") 2297 # verify the required parameter 'envelope_id' is set 2298 if ('envelope_id' not in params) or (params['envelope_id'] is None): 2299 raise ValueError("Missing the required parameter `envelope_id` when calling `create_recipient`") 2300 2301 2302 collection_formats = {} 2303 2304 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients'.replace('{format}', 'json') 2305 path_params = {} 2306 if 'account_id' in params: 2307 path_params['accountId'] = params['account_id'] 2308 if 'envelope_id' in params: 2309 path_params['envelopeId'] = params['envelope_id'] 2310 2311 query_params = {} 2312 if 'resend_envelope' in params: 2313 query_params['resend_envelope'] = params['resend_envelope'] 2314 2315 header_params = {} 2316 2317 form_params = [] 2318 local_var_files = {} 2319 2320 body_params = None 2321 if 'recipients' in params: 2322 body_params = params['recipients'] 2323 # HTTP header `Accept` 2324 header_params['Accept'] = self.api_client.\ 2325 select_header_accept(['application/json']) 2326 2327 # Authentication setting 2328 auth_settings = [] 2329 2330 return self.api_client.call_api(resource_path, 'POST', 2331 path_params, 2332 query_params, 2333 header_params, 2334 body=body_params, 2335 post_params=form_params, 2336 files=local_var_files, 2337 response_type='Recipients', 2338 auth_settings=auth_settings, 2339 callback=params.get('callback'), 2340 _return_http_data_only=params.get('_return_http_data_only'), 2341 _preload_content=params.get('_preload_content', True), 2342 _request_timeout=params.get('_request_timeout'), 2343 collection_formats=collection_formats)
Adds one or more recipients to an envelope.
Adds one or more recipients to an envelope. For an in process envelope, one that has been sent and has not been completed or voided, an email is sent to a new recipient when they are reached in the routing order. If the new recipient's routing order is before or the same as the envelope's next recipient, an email is only sent if the optional resend_envelope query string is set to true.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_recipient_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str resend_envelope: When set to true, resends the envelope if the new recipient's routing order is before or the same as the envelope's next recipient.
- Recipients recipients:
Returns
Recipients If the method is called asynchronously, returns the request thread.
def
create_recipient_manual_review_view(self, account_id, envelope_id, recipient_id, **kwargs)
2345 def create_recipient_manual_review_view(self, account_id, envelope_id, recipient_id, **kwargs): 2346 """ 2347 Provides a link to access the Identity manual review related to a recipient. 2348 This method returns the URL of the page that allows a sender to [manually review](https://support.docusign.com/en/guides/ndse-user-guide-send-documents-with-id-verification) the ID of a recipient. 2349 This method makes a synchronous HTTP request by default. To make an 2350 asynchronous HTTP request, please define a `callback` function 2351 to be invoked when receiving the response. 2352 >>> def callback_function(response): 2353 >>> pprint(response) 2354 >>> 2355 >>> thread = api.create_recipient_manual_review_view(account_id, envelope_id, recipient_id, callback=callback_function) 2356 2357 :param callback function: The callback function 2358 for asynchronous request. (optional) 2359 :param str account_id: The external account number (int) or account ID Guid. (required) 2360 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2361 :param str recipient_id: The ID of the recipient being accessed. (required) 2362 :return: ViewUrl 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.create_recipient_manual_review_view_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 2369 else: 2370 (data) = self.create_recipient_manual_review_view_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 2371 return data
Provides a link to access the Identity manual review related to a recipient.
This method returns the URL of the page that allows a sender to manually review the ID of a recipient.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_recipient_manual_review_view(account_id, envelope_id, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
Returns
ViewUrl If the method is called asynchronously, returns the request thread.
def
create_recipient_manual_review_view_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs)
2373 def create_recipient_manual_review_view_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 2374 """ 2375 Provides a link to access the Identity manual review related to a recipient. 2376 This method returns the URL of the page that allows a sender to [manually review](https://support.docusign.com/en/guides/ndse-user-guide-send-documents-with-id-verification) the ID of a recipient. 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.create_recipient_manual_review_view_with_http_info(account_id, envelope_id, recipient_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 str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2389 :param str recipient_id: The ID of the recipient being accessed. (required) 2390 :return: ViewUrl 2391 If the method is called asynchronously, 2392 returns the request thread. 2393 """ 2394 2395 all_params = ['account_id', 'envelope_id', 'recipient_id'] 2396 all_params.append('callback') 2397 all_params.append('_return_http_data_only') 2398 all_params.append('_preload_content') 2399 all_params.append('_request_timeout') 2400 2401 params = locals() 2402 for key, val in iteritems(params['kwargs']): 2403 if key not in all_params: 2404 raise TypeError( 2405 "Got an unexpected keyword argument '%s'" 2406 " to method create_recipient_manual_review_view" % key 2407 ) 2408 params[key] = val 2409 del params['kwargs'] 2410 # verify the required parameter 'account_id' is set 2411 if ('account_id' not in params) or (params['account_id'] is None): 2412 raise ValueError("Missing the required parameter `account_id` when calling `create_recipient_manual_review_view`") 2413 # verify the required parameter 'envelope_id' is set 2414 if ('envelope_id' not in params) or (params['envelope_id'] is None): 2415 raise ValueError("Missing the required parameter `envelope_id` when calling `create_recipient_manual_review_view`") 2416 # verify the required parameter 'recipient_id' is set 2417 if ('recipient_id' not in params) or (params['recipient_id'] is None): 2418 raise ValueError("Missing the required parameter `recipient_id` when calling `create_recipient_manual_review_view`") 2419 2420 2421 collection_formats = {} 2422 2423 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/views/identity_manual_review'.replace('{format}', 'json') 2424 path_params = {} 2425 if 'account_id' in params: 2426 path_params['accountId'] = params['account_id'] 2427 if 'envelope_id' in params: 2428 path_params['envelopeId'] = params['envelope_id'] 2429 if 'recipient_id' in params: 2430 path_params['recipientId'] = params['recipient_id'] 2431 2432 query_params = {} 2433 2434 header_params = {} 2435 2436 form_params = [] 2437 local_var_files = {} 2438 2439 body_params = None 2440 # HTTP header `Accept` 2441 header_params['Accept'] = self.api_client.\ 2442 select_header_accept(['application/json']) 2443 2444 # Authentication setting 2445 auth_settings = [] 2446 2447 return self.api_client.call_api(resource_path, 'POST', 2448 path_params, 2449 query_params, 2450 header_params, 2451 body=body_params, 2452 post_params=form_params, 2453 files=local_var_files, 2454 response_type='ViewUrl', 2455 auth_settings=auth_settings, 2456 callback=params.get('callback'), 2457 _return_http_data_only=params.get('_return_http_data_only'), 2458 _preload_content=params.get('_preload_content', True), 2459 _request_timeout=params.get('_request_timeout'), 2460 collection_formats=collection_formats)
Provides a link to access the Identity manual review related to a recipient.
This method returns the URL of the page that allows a sender to manually review the ID of a recipient.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_recipient_manual_review_view_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
Returns
ViewUrl If the method is called asynchronously, returns the request thread.
def
create_recipient_proof_file_link(self, account_id, envelope_id, recipient_id, **kwargs)
2462 def create_recipient_proof_file_link(self, account_id, envelope_id, recipient_id, **kwargs): 2463 """ 2464 Returns a link to access to the identity events stored in the proof service related to this recipient. 2465 2466 This method makes a synchronous HTTP request by default. To make an 2467 asynchronous HTTP request, please define a `callback` function 2468 to be invoked when receiving the response. 2469 >>> def callback_function(response): 2470 >>> pprint(response) 2471 >>> 2472 >>> thread = api.create_recipient_proof_file_link(account_id, envelope_id, recipient_id, callback=callback_function) 2473 2474 :param callback function: The callback function 2475 for asynchronous request. (optional) 2476 :param str account_id: The external account number (int) or account ID Guid. (required) 2477 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2478 :param str recipient_id: The ID of the recipient being accessed. (required) 2479 :return: IdEvidenceViewLink 2480 If the method is called asynchronously, 2481 returns the request thread. 2482 """ 2483 kwargs['_return_http_data_only'] = True 2484 if kwargs.get('callback'): 2485 return self.create_recipient_proof_file_link_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 2486 else: 2487 (data) = self.create_recipient_proof_file_link_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 2488 return data
Returns a link to access to the identity events stored in the proof service related to this recipient.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_recipient_proof_file_link(account_id, envelope_id, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
Returns
IdEvidenceViewLink If the method is called asynchronously, returns the request thread.
def
create_recipient_proof_file_link_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs)
2490 def create_recipient_proof_file_link_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 2491 """ 2492 Returns a link to access to the identity events stored in the proof service related to this recipient. 2493 2494 This method makes a synchronous HTTP request by default. To make an 2495 asynchronous HTTP request, please define a `callback` function 2496 to be invoked when receiving the response. 2497 >>> def callback_function(response): 2498 >>> pprint(response) 2499 >>> 2500 >>> thread = api.create_recipient_proof_file_link_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 2501 2502 :param callback function: The callback function 2503 for asynchronous request. (optional) 2504 :param str account_id: The external account number (int) or account ID Guid. (required) 2505 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2506 :param str recipient_id: The ID of the recipient being accessed. (required) 2507 :return: IdEvidenceViewLink 2508 If the method is called asynchronously, 2509 returns the request thread. 2510 """ 2511 2512 all_params = ['account_id', 'envelope_id', 'recipient_id'] 2513 all_params.append('callback') 2514 all_params.append('_return_http_data_only') 2515 all_params.append('_preload_content') 2516 all_params.append('_request_timeout') 2517 2518 params = locals() 2519 for key, val in iteritems(params['kwargs']): 2520 if key not in all_params: 2521 raise TypeError( 2522 "Got an unexpected keyword argument '%s'" 2523 " to method create_recipient_proof_file_link" % key 2524 ) 2525 params[key] = val 2526 del params['kwargs'] 2527 # verify the required parameter 'account_id' is set 2528 if ('account_id' not in params) or (params['account_id'] is None): 2529 raise ValueError("Missing the required parameter `account_id` when calling `create_recipient_proof_file_link`") 2530 # verify the required parameter 'envelope_id' is set 2531 if ('envelope_id' not in params) or (params['envelope_id'] is None): 2532 raise ValueError("Missing the required parameter `envelope_id` when calling `create_recipient_proof_file_link`") 2533 # verify the required parameter 'recipient_id' is set 2534 if ('recipient_id' not in params) or (params['recipient_id'] is None): 2535 raise ValueError("Missing the required parameter `recipient_id` when calling `create_recipient_proof_file_link`") 2536 2537 2538 collection_formats = {} 2539 2540 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/identity_proof'.replace('{format}', 'json') 2541 path_params = {} 2542 if 'account_id' in params: 2543 path_params['accountId'] = params['account_id'] 2544 if 'envelope_id' in params: 2545 path_params['envelopeId'] = params['envelope_id'] 2546 if 'recipient_id' in params: 2547 path_params['recipientId'] = params['recipient_id'] 2548 2549 query_params = {} 2550 2551 header_params = {} 2552 2553 form_params = [] 2554 local_var_files = {} 2555 2556 body_params = None 2557 # HTTP header `Accept` 2558 header_params['Accept'] = self.api_client.\ 2559 select_header_accept(['application/json']) 2560 2561 # Authentication setting 2562 auth_settings = [] 2563 2564 return self.api_client.call_api(resource_path, 'POST', 2565 path_params, 2566 query_params, 2567 header_params, 2568 body=body_params, 2569 post_params=form_params, 2570 files=local_var_files, 2571 response_type='IdEvidenceViewLink', 2572 auth_settings=auth_settings, 2573 callback=params.get('callback'), 2574 _return_http_data_only=params.get('_return_http_data_only'), 2575 _preload_content=params.get('_preload_content', True), 2576 _request_timeout=params.get('_request_timeout'), 2577 collection_formats=collection_formats)
Returns a link to access to the identity events stored in the proof service related to this recipient.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_recipient_proof_file_link_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
Returns
IdEvidenceViewLink If the method is called asynchronously, returns the request thread.
def
create_recipient_proof_file_resource_token(self, account_id, envelope_id, recipient_id, **kwargs)
2579 def create_recipient_proof_file_resource_token(self, account_id, envelope_id, recipient_id, **kwargs): 2580 """ 2581 Returns a resource token to get access to the identity events stored in the proof service related to this recipient. 2582 Creates a resource token for a sender. This token allows a sender to return identification data for a recipient using the [ID Evidence API](/docs/idevidence-api/). 2583 This method makes a synchronous HTTP request by default. To make an 2584 asynchronous HTTP request, please define a `callback` function 2585 to be invoked when receiving the response. 2586 >>> def callback_function(response): 2587 >>> pprint(response) 2588 >>> 2589 >>> thread = api.create_recipient_proof_file_resource_token(account_id, envelope_id, recipient_id, callback=callback_function) 2590 2591 :param callback function: The callback function 2592 for asynchronous request. (optional) 2593 :param str account_id: The external account number (int) or account ID Guid. (required) 2594 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2595 :param str recipient_id: The ID of the recipient being accessed. (required) 2596 :param str token_scopes: 2597 :return: IdEvidenceResourceToken 2598 If the method is called asynchronously, 2599 returns the request thread. 2600 """ 2601 kwargs['_return_http_data_only'] = True 2602 if kwargs.get('callback'): 2603 return self.create_recipient_proof_file_resource_token_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 2604 else: 2605 (data) = self.create_recipient_proof_file_resource_token_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 2606 return data
Returns a resource token to get access to the identity events stored in the proof service related to this recipient.
Creates a resource token for a sender. This token allows a sender to return identification data for a recipient using the ID Evidence API.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_recipient_proof_file_resource_token(account_id, envelope_id, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
- str token_scopes:
Returns
IdEvidenceResourceToken If the method is called asynchronously, returns the request thread.
def
create_recipient_proof_file_resource_token_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs)
2608 def create_recipient_proof_file_resource_token_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 2609 """ 2610 Returns a resource token to get access to the identity events stored in the proof service related to this recipient. 2611 Creates a resource token for a sender. This token allows a sender to return identification data for a recipient using the [ID Evidence API](/docs/idevidence-api/). 2612 This method makes a synchronous HTTP request by default. To make an 2613 asynchronous HTTP request, please define a `callback` function 2614 to be invoked when receiving the response. 2615 >>> def callback_function(response): 2616 >>> pprint(response) 2617 >>> 2618 >>> thread = api.create_recipient_proof_file_resource_token_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 2619 2620 :param callback function: The callback function 2621 for asynchronous request. (optional) 2622 :param str account_id: The external account number (int) or account ID Guid. (required) 2623 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2624 :param str recipient_id: The ID of the recipient being accessed. (required) 2625 :param str token_scopes: 2626 :return: IdEvidenceResourceToken 2627 If the method is called asynchronously, 2628 returns the request thread. 2629 """ 2630 2631 all_params = ['account_id', 'envelope_id', 'recipient_id', 'token_scopes'] 2632 all_params.append('callback') 2633 all_params.append('_return_http_data_only') 2634 all_params.append('_preload_content') 2635 all_params.append('_request_timeout') 2636 2637 params = locals() 2638 for key, val in iteritems(params['kwargs']): 2639 if key not in all_params: 2640 raise TypeError( 2641 "Got an unexpected keyword argument '%s'" 2642 " to method create_recipient_proof_file_resource_token" % key 2643 ) 2644 params[key] = val 2645 del params['kwargs'] 2646 # verify the required parameter 'account_id' is set 2647 if ('account_id' not in params) or (params['account_id'] is None): 2648 raise ValueError("Missing the required parameter `account_id` when calling `create_recipient_proof_file_resource_token`") 2649 # verify the required parameter 'envelope_id' is set 2650 if ('envelope_id' not in params) or (params['envelope_id'] is None): 2651 raise ValueError("Missing the required parameter `envelope_id` when calling `create_recipient_proof_file_resource_token`") 2652 # verify the required parameter 'recipient_id' is set 2653 if ('recipient_id' not in params) or (params['recipient_id'] is None): 2654 raise ValueError("Missing the required parameter `recipient_id` when calling `create_recipient_proof_file_resource_token`") 2655 2656 2657 collection_formats = {} 2658 2659 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/identity_proof_token'.replace('{format}', 'json') 2660 path_params = {} 2661 if 'account_id' in params: 2662 path_params['accountId'] = params['account_id'] 2663 if 'envelope_id' in params: 2664 path_params['envelopeId'] = params['envelope_id'] 2665 if 'recipient_id' in params: 2666 path_params['recipientId'] = params['recipient_id'] 2667 2668 query_params = {} 2669 if 'token_scopes' in params: 2670 query_params['token_scopes'] = params['token_scopes'] 2671 2672 header_params = {} 2673 2674 form_params = [] 2675 local_var_files = {} 2676 2677 body_params = None 2678 # HTTP header `Accept` 2679 header_params['Accept'] = self.api_client.\ 2680 select_header_accept(['application/json']) 2681 2682 # Authentication setting 2683 auth_settings = [] 2684 2685 return self.api_client.call_api(resource_path, 'POST', 2686 path_params, 2687 query_params, 2688 header_params, 2689 body=body_params, 2690 post_params=form_params, 2691 files=local_var_files, 2692 response_type='IdEvidenceResourceToken', 2693 auth_settings=auth_settings, 2694 callback=params.get('callback'), 2695 _return_http_data_only=params.get('_return_http_data_only'), 2696 _preload_content=params.get('_preload_content', True), 2697 _request_timeout=params.get('_request_timeout'), 2698 collection_formats=collection_formats)
Returns a resource token to get access to the identity events stored in the proof service related to this recipient.
Creates a resource token for a sender. This token allows a sender to return identification data for a recipient using the ID Evidence API.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_recipient_proof_file_resource_token_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
- str token_scopes:
Returns
IdEvidenceResourceToken If the method is called asynchronously, returns the request thread.
def
create_recipient_view(self, account_id, envelope_id, **kwargs)
2700 def create_recipient_view(self, account_id, envelope_id, **kwargs): 2701 """ 2702 Returns a URL to the recipient view UI. 2703 Returns a URL that allows you to embed the recipient view of the DocuSign UI in your applications. This call cannot be used to view draft envelopes, since those envelopes have not been sent. Important: iFrames should not be used for embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends using a WebView. An entry is added into the Security Level section of the DocuSign Certificate of Completion that reflects the `securityDomain` and `authenticationMethod` properties used to verify the user identity. 2704 This method makes a synchronous HTTP request by default. To make an 2705 asynchronous HTTP request, please define a `callback` function 2706 to be invoked when receiving the response. 2707 >>> def callback_function(response): 2708 >>> pprint(response) 2709 >>> 2710 >>> thread = api.create_recipient_view(account_id, envelope_id, callback=callback_function) 2711 2712 :param callback function: The callback function 2713 for asynchronous request. (optional) 2714 :param str account_id: The external account number (int) or account ID Guid. (required) 2715 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2716 :param RecipientViewRequest recipient_view_request: 2717 :return: ViewUrl 2718 If the method is called asynchronously, 2719 returns the request thread. 2720 """ 2721 kwargs['_return_http_data_only'] = True 2722 if kwargs.get('callback'): 2723 return self.create_recipient_view_with_http_info(account_id, envelope_id, **kwargs) 2724 else: 2725 (data) = self.create_recipient_view_with_http_info(account_id, envelope_id, **kwargs) 2726 return data
Returns a URL to the recipient view UI.
Returns a URL that allows you to embed the recipient view of the DocuSign UI in your applications. This call cannot be used to view draft envelopes, since those envelopes have not been sent. Important: iFrames should not be used for embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends using a WebView. An entry is added into the Security Level section of the DocuSign Certificate of Completion that reflects the securityDomain and authenticationMethod properties used to verify the user identity.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_recipient_view(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- RecipientViewRequest recipient_view_request:
Returns
ViewUrl If the method is called asynchronously, returns the request thread.
def
create_recipient_view_with_http_info(self, account_id, envelope_id, **kwargs)
2728 def create_recipient_view_with_http_info(self, account_id, envelope_id, **kwargs): 2729 """ 2730 Returns a URL to the recipient view UI. 2731 Returns a URL that allows you to embed the recipient view of the DocuSign UI in your applications. This call cannot be used to view draft envelopes, since those envelopes have not been sent. Important: iFrames should not be used for embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends using a WebView. An entry is added into the Security Level section of the DocuSign Certificate of Completion that reflects the `securityDomain` and `authenticationMethod` properties used to verify the user identity. 2732 This method makes a synchronous HTTP request by default. To make an 2733 asynchronous HTTP request, please define a `callback` function 2734 to be invoked when receiving the response. 2735 >>> def callback_function(response): 2736 >>> pprint(response) 2737 >>> 2738 >>> thread = api.create_recipient_view_with_http_info(account_id, envelope_id, callback=callback_function) 2739 2740 :param callback function: The callback function 2741 for asynchronous request. (optional) 2742 :param str account_id: The external account number (int) or account ID Guid. (required) 2743 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2744 :param RecipientViewRequest recipient_view_request: 2745 :return: ViewUrl 2746 If the method is called asynchronously, 2747 returns the request thread. 2748 """ 2749 2750 all_params = ['account_id', 'envelope_id', 'recipient_view_request'] 2751 all_params.append('callback') 2752 all_params.append('_return_http_data_only') 2753 all_params.append('_preload_content') 2754 all_params.append('_request_timeout') 2755 2756 params = locals() 2757 for key, val in iteritems(params['kwargs']): 2758 if key not in all_params: 2759 raise TypeError( 2760 "Got an unexpected keyword argument '%s'" 2761 " to method create_recipient_view" % key 2762 ) 2763 params[key] = val 2764 del params['kwargs'] 2765 # verify the required parameter 'account_id' is set 2766 if ('account_id' not in params) or (params['account_id'] is None): 2767 raise ValueError("Missing the required parameter `account_id` when calling `create_recipient_view`") 2768 # verify the required parameter 'envelope_id' is set 2769 if ('envelope_id' not in params) or (params['envelope_id'] is None): 2770 raise ValueError("Missing the required parameter `envelope_id` when calling `create_recipient_view`") 2771 2772 2773 collection_formats = {} 2774 2775 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/recipient'.replace('{format}', 'json') 2776 path_params = {} 2777 if 'account_id' in params: 2778 path_params['accountId'] = params['account_id'] 2779 if 'envelope_id' in params: 2780 path_params['envelopeId'] = params['envelope_id'] 2781 2782 query_params = {} 2783 2784 header_params = {} 2785 2786 form_params = [] 2787 local_var_files = {} 2788 2789 body_params = None 2790 if 'recipient_view_request' in params: 2791 body_params = params['recipient_view_request'] 2792 # HTTP header `Accept` 2793 header_params['Accept'] = self.api_client.\ 2794 select_header_accept(['application/json']) 2795 2796 # Authentication setting 2797 auth_settings = [] 2798 2799 return self.api_client.call_api(resource_path, 'POST', 2800 path_params, 2801 query_params, 2802 header_params, 2803 body=body_params, 2804 post_params=form_params, 2805 files=local_var_files, 2806 response_type='ViewUrl', 2807 auth_settings=auth_settings, 2808 callback=params.get('callback'), 2809 _return_http_data_only=params.get('_return_http_data_only'), 2810 _preload_content=params.get('_preload_content', True), 2811 _request_timeout=params.get('_request_timeout'), 2812 collection_formats=collection_formats)
Returns a URL to the recipient view UI.
Returns a URL that allows you to embed the recipient view of the DocuSign UI in your applications. This call cannot be used to view draft envelopes, since those envelopes have not been sent. Important: iFrames should not be used for embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends using a WebView. An entry is added into the Security Level section of the DocuSign Certificate of Completion that reflects the securityDomain and authenticationMethod properties used to verify the user identity.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_recipient_view_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- RecipientViewRequest recipient_view_request:
Returns
ViewUrl If the method is called asynchronously, returns the request thread.
def
create_responsive_html_preview(self, account_id, envelope_id, **kwargs)
2814 def create_responsive_html_preview(self, account_id, envelope_id, **kwargs): 2815 """ 2816 Get Responsive HTML Preview for all documents in an envelope. 2817 Creates a preview of the [responsive](/docs/esign-rest-api/esign101/concepts/responsive/), HTML versions of all of the documents in an envelope. This method enables you to preview the PDF document conversions to responsive HTML across device types prior to sending. The request body is a `documentHtmlDefinition` object, which holds the responsive signing parameters that define how to generate the HTML version of the documents. 2818 This method makes a synchronous HTTP request by default. To make an 2819 asynchronous HTTP request, please define a `callback` function 2820 to be invoked when receiving the response. 2821 >>> def callback_function(response): 2822 >>> pprint(response) 2823 >>> 2824 >>> thread = api.create_responsive_html_preview(account_id, envelope_id, callback=callback_function) 2825 2826 :param callback function: The callback function 2827 for asynchronous request. (optional) 2828 :param str account_id: The external account number (int) or account ID Guid. (required) 2829 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2830 :param DocumentHtmlDefinition document_html_definition: 2831 :return: DocumentHtmlDefinitions 2832 If the method is called asynchronously, 2833 returns the request thread. 2834 """ 2835 kwargs['_return_http_data_only'] = True 2836 if kwargs.get('callback'): 2837 return self.create_responsive_html_preview_with_http_info(account_id, envelope_id, **kwargs) 2838 else: 2839 (data) = self.create_responsive_html_preview_with_http_info(account_id, envelope_id, **kwargs) 2840 return data
Get Responsive HTML Preview for all documents in an envelope.
Creates a preview of the responsive, HTML versions of all of the documents in an envelope. This method enables you to preview the PDF document conversions to responsive HTML across device types prior to sending. The request body is a documentHtmlDefinition object, which holds the responsive signing parameters that define how to generate the HTML version of the documents.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_responsive_html_preview(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- DocumentHtmlDefinition document_html_definition:
Returns
DocumentHtmlDefinitions If the method is called asynchronously, returns the request thread.
def
create_responsive_html_preview_with_http_info(self, account_id, envelope_id, **kwargs)
2842 def create_responsive_html_preview_with_http_info(self, account_id, envelope_id, **kwargs): 2843 """ 2844 Get Responsive HTML Preview for all documents in an envelope. 2845 Creates a preview of the [responsive](/docs/esign-rest-api/esign101/concepts/responsive/), HTML versions of all of the documents in an envelope. This method enables you to preview the PDF document conversions to responsive HTML across device types prior to sending. The request body is a `documentHtmlDefinition` object, which holds the responsive signing parameters that define how to generate the HTML version of the documents. 2846 This method makes a synchronous HTTP request by default. To make an 2847 asynchronous HTTP request, please define a `callback` function 2848 to be invoked when receiving the response. 2849 >>> def callback_function(response): 2850 >>> pprint(response) 2851 >>> 2852 >>> thread = api.create_responsive_html_preview_with_http_info(account_id, envelope_id, callback=callback_function) 2853 2854 :param callback function: The callback function 2855 for asynchronous request. (optional) 2856 :param str account_id: The external account number (int) or account ID Guid. (required) 2857 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2858 :param DocumentHtmlDefinition document_html_definition: 2859 :return: DocumentHtmlDefinitions 2860 If the method is called asynchronously, 2861 returns the request thread. 2862 """ 2863 2864 all_params = ['account_id', 'envelope_id', 'document_html_definition'] 2865 all_params.append('callback') 2866 all_params.append('_return_http_data_only') 2867 all_params.append('_preload_content') 2868 all_params.append('_request_timeout') 2869 2870 params = locals() 2871 for key, val in iteritems(params['kwargs']): 2872 if key not in all_params: 2873 raise TypeError( 2874 "Got an unexpected keyword argument '%s'" 2875 " to method create_responsive_html_preview" % key 2876 ) 2877 params[key] = val 2878 del params['kwargs'] 2879 # verify the required parameter 'account_id' is set 2880 if ('account_id' not in params) or (params['account_id'] is None): 2881 raise ValueError("Missing the required parameter `account_id` when calling `create_responsive_html_preview`") 2882 # verify the required parameter 'envelope_id' is set 2883 if ('envelope_id' not in params) or (params['envelope_id'] is None): 2884 raise ValueError("Missing the required parameter `envelope_id` when calling `create_responsive_html_preview`") 2885 2886 2887 collection_formats = {} 2888 2889 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/responsive_html_preview'.replace('{format}', 'json') 2890 path_params = {} 2891 if 'account_id' in params: 2892 path_params['accountId'] = params['account_id'] 2893 if 'envelope_id' in params: 2894 path_params['envelopeId'] = params['envelope_id'] 2895 2896 query_params = {} 2897 2898 header_params = {} 2899 2900 form_params = [] 2901 local_var_files = {} 2902 2903 body_params = None 2904 if 'document_html_definition' in params: 2905 body_params = params['document_html_definition'] 2906 # HTTP header `Accept` 2907 header_params['Accept'] = self.api_client.\ 2908 select_header_accept(['application/json']) 2909 2910 # Authentication setting 2911 auth_settings = [] 2912 2913 return self.api_client.call_api(resource_path, 'POST', 2914 path_params, 2915 query_params, 2916 header_params, 2917 body=body_params, 2918 post_params=form_params, 2919 files=local_var_files, 2920 response_type='DocumentHtmlDefinitions', 2921 auth_settings=auth_settings, 2922 callback=params.get('callback'), 2923 _return_http_data_only=params.get('_return_http_data_only'), 2924 _preload_content=params.get('_preload_content', True), 2925 _request_timeout=params.get('_request_timeout'), 2926 collection_formats=collection_formats)
Get Responsive HTML Preview for all documents in an envelope.
Creates a preview of the responsive, HTML versions of all of the documents in an envelope. This method enables you to preview the PDF document conversions to responsive HTML across device types prior to sending. The request body is a documentHtmlDefinition object, which holds the responsive signing parameters that define how to generate the HTML version of the documents.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_responsive_html_preview_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- DocumentHtmlDefinition document_html_definition:
Returns
DocumentHtmlDefinitions If the method is called asynchronously, returns the request thread.
def
create_sender_view(self, account_id, envelope_id, **kwargs)
2928 def create_sender_view(self, account_id, envelope_id, **kwargs): 2929 """ 2930 Returns a URL to the sender view UI. 2931 Returns a URL that allows you to embed the sender view of the DocuSign UI in your applications. This is a one-time use login token that allows the user to be placed into the DocuSign sending view. Upon sending completion, the user is returned to the return URL provided by the API application. Important: iFrames should not be used for embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends using a WebView. 2932 This method makes a synchronous HTTP request by default. To make an 2933 asynchronous HTTP request, please define a `callback` function 2934 to be invoked when receiving the response. 2935 >>> def callback_function(response): 2936 >>> pprint(response) 2937 >>> 2938 >>> thread = api.create_sender_view(account_id, envelope_id, callback=callback_function) 2939 2940 :param callback function: The callback function 2941 for asynchronous request. (optional) 2942 :param str account_id: The external account number (int) or account ID Guid. (required) 2943 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2944 :param EnvelopeViewRequest envelope_view_request: 2945 :return: ViewUrl 2946 If the method is called asynchronously, 2947 returns the request thread. 2948 """ 2949 kwargs['_return_http_data_only'] = True 2950 if kwargs.get('callback'): 2951 return self.create_sender_view_with_http_info(account_id, envelope_id, **kwargs) 2952 else: 2953 (data) = self.create_sender_view_with_http_info(account_id, envelope_id, **kwargs) 2954 return data
Returns a URL to the sender view UI.
Returns a URL that allows you to embed the sender view of the DocuSign UI in your applications. This is a one-time use login token that allows the user to be placed into the DocuSign sending view. Upon sending completion, the user is returned to the return URL provided by the API application. Important: iFrames should not be used for embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends using a WebView.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_sender_view(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- EnvelopeViewRequest envelope_view_request:
Returns
ViewUrl If the method is called asynchronously, returns the request thread.
def
create_sender_view_with_http_info(self, account_id, envelope_id, **kwargs)
2956 def create_sender_view_with_http_info(self, account_id, envelope_id, **kwargs): 2957 """ 2958 Returns a URL to the sender view UI. 2959 Returns a URL that allows you to embed the sender view of the DocuSign UI in your applications. This is a one-time use login token that allows the user to be placed into the DocuSign sending view. Upon sending completion, the user is returned to the return URL provided by the API application. Important: iFrames should not be used for embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends using a WebView. 2960 This method makes a synchronous HTTP request by default. To make an 2961 asynchronous HTTP request, please define a `callback` function 2962 to be invoked when receiving the response. 2963 >>> def callback_function(response): 2964 >>> pprint(response) 2965 >>> 2966 >>> thread = api.create_sender_view_with_http_info(account_id, envelope_id, callback=callback_function) 2967 2968 :param callback function: The callback function 2969 for asynchronous request. (optional) 2970 :param str account_id: The external account number (int) or account ID Guid. (required) 2971 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2972 :param EnvelopeViewRequest envelope_view_request: 2973 :return: ViewUrl 2974 If the method is called asynchronously, 2975 returns the request thread. 2976 """ 2977 2978 all_params = ['account_id', 'envelope_id', 'envelope_view_request'] 2979 all_params.append('callback') 2980 all_params.append('_return_http_data_only') 2981 all_params.append('_preload_content') 2982 all_params.append('_request_timeout') 2983 2984 params = locals() 2985 for key, val in iteritems(params['kwargs']): 2986 if key not in all_params: 2987 raise TypeError( 2988 "Got an unexpected keyword argument '%s'" 2989 " to method create_sender_view" % key 2990 ) 2991 params[key] = val 2992 del params['kwargs'] 2993 # verify the required parameter 'account_id' is set 2994 if ('account_id' not in params) or (params['account_id'] is None): 2995 raise ValueError("Missing the required parameter `account_id` when calling `create_sender_view`") 2996 # verify the required parameter 'envelope_id' is set 2997 if ('envelope_id' not in params) or (params['envelope_id'] is None): 2998 raise ValueError("Missing the required parameter `envelope_id` when calling `create_sender_view`") 2999 3000 3001 collection_formats = {} 3002 3003 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/sender'.replace('{format}', 'json') 3004 path_params = {} 3005 if 'account_id' in params: 3006 path_params['accountId'] = params['account_id'] 3007 if 'envelope_id' in params: 3008 path_params['envelopeId'] = params['envelope_id'] 3009 3010 query_params = {} 3011 3012 header_params = {} 3013 3014 form_params = [] 3015 local_var_files = {} 3016 3017 body_params = None 3018 if 'envelope_view_request' in params: 3019 body_params = params['envelope_view_request'] 3020 # HTTP header `Accept` 3021 header_params['Accept'] = self.api_client.\ 3022 select_header_accept(['application/json']) 3023 3024 # Authentication setting 3025 auth_settings = [] 3026 3027 return self.api_client.call_api(resource_path, 'POST', 3028 path_params, 3029 query_params, 3030 header_params, 3031 body=body_params, 3032 post_params=form_params, 3033 files=local_var_files, 3034 response_type='ViewUrl', 3035 auth_settings=auth_settings, 3036 callback=params.get('callback'), 3037 _return_http_data_only=params.get('_return_http_data_only'), 3038 _preload_content=params.get('_preload_content', True), 3039 _request_timeout=params.get('_request_timeout'), 3040 collection_formats=collection_formats)
Returns a URL to the sender view UI.
Returns a URL that allows you to embed the sender view of the DocuSign UI in your applications. This is a one-time use login token that allows the user to be placed into the DocuSign sending view. Upon sending completion, the user is returned to the return URL provided by the API application. Important: iFrames should not be used for embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends using a WebView.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_sender_view_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- EnvelopeViewRequest envelope_view_request:
Returns
ViewUrl If the method is called asynchronously, returns the request thread.
def
create_tabs(self, account_id, envelope_id, recipient_id, **kwargs)
3042 def create_tabs(self, account_id, envelope_id, recipient_id, **kwargs): 3043 """ 3044 Adds tabs for a recipient. 3045 Adds one or more tabs for a recipient. 3046 This method makes a synchronous HTTP request by default. To make an 3047 asynchronous HTTP request, please define a `callback` function 3048 to be invoked when receiving the response. 3049 >>> def callback_function(response): 3050 >>> pprint(response) 3051 >>> 3052 >>> thread = api.create_tabs(account_id, envelope_id, recipient_id, callback=callback_function) 3053 3054 :param callback function: The callback function 3055 for asynchronous request. (optional) 3056 :param str account_id: The external account number (int) or account ID Guid. (required) 3057 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3058 :param str recipient_id: The ID of the recipient being accessed. (required) 3059 :param Tabs tabs: 3060 :return: Tabs 3061 If the method is called asynchronously, 3062 returns the request thread. 3063 """ 3064 kwargs['_return_http_data_only'] = True 3065 if kwargs.get('callback'): 3066 return self.create_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 3067 else: 3068 (data) = self.create_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 3069 return data
Adds tabs for a recipient.
Adds one or more tabs for a recipient.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_tabs(account_id, envelope_id, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
- Tabs tabs:
Returns
Tabs If the method is called asynchronously, returns the request thread.
def
create_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs)
3071 def create_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 3072 """ 3073 Adds tabs for a recipient. 3074 Adds one or more tabs for a recipient. 3075 This method makes a synchronous HTTP request by default. To make an 3076 asynchronous HTTP request, please define a `callback` function 3077 to be invoked when receiving the response. 3078 >>> def callback_function(response): 3079 >>> pprint(response) 3080 >>> 3081 >>> thread = api.create_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 3082 3083 :param callback function: The callback function 3084 for asynchronous request. (optional) 3085 :param str account_id: The external account number (int) or account ID Guid. (required) 3086 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3087 :param str recipient_id: The ID of the recipient being accessed. (required) 3088 :param Tabs tabs: 3089 :return: Tabs 3090 If the method is called asynchronously, 3091 returns the request thread. 3092 """ 3093 3094 all_params = ['account_id', 'envelope_id', 'recipient_id', 'tabs'] 3095 all_params.append('callback') 3096 all_params.append('_return_http_data_only') 3097 all_params.append('_preload_content') 3098 all_params.append('_request_timeout') 3099 3100 params = locals() 3101 for key, val in iteritems(params['kwargs']): 3102 if key not in all_params: 3103 raise TypeError( 3104 "Got an unexpected keyword argument '%s'" 3105 " to method create_tabs" % key 3106 ) 3107 params[key] = val 3108 del params['kwargs'] 3109 # verify the required parameter 'account_id' is set 3110 if ('account_id' not in params) or (params['account_id'] is None): 3111 raise ValueError("Missing the required parameter `account_id` when calling `create_tabs`") 3112 # verify the required parameter 'envelope_id' is set 3113 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3114 raise ValueError("Missing the required parameter `envelope_id` when calling `create_tabs`") 3115 # verify the required parameter 'recipient_id' is set 3116 if ('recipient_id' not in params) or (params['recipient_id'] is None): 3117 raise ValueError("Missing the required parameter `recipient_id` when calling `create_tabs`") 3118 3119 3120 collection_formats = {} 3121 3122 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/tabs'.replace('{format}', 'json') 3123 path_params = {} 3124 if 'account_id' in params: 3125 path_params['accountId'] = params['account_id'] 3126 if 'envelope_id' in params: 3127 path_params['envelopeId'] = params['envelope_id'] 3128 if 'recipient_id' in params: 3129 path_params['recipientId'] = params['recipient_id'] 3130 3131 query_params = {} 3132 3133 header_params = {} 3134 3135 form_params = [] 3136 local_var_files = {} 3137 3138 body_params = None 3139 if 'tabs' in params: 3140 body_params = params['tabs'] 3141 # HTTP header `Accept` 3142 header_params['Accept'] = self.api_client.\ 3143 select_header_accept(['application/json']) 3144 3145 # Authentication setting 3146 auth_settings = [] 3147 3148 return self.api_client.call_api(resource_path, 'POST', 3149 path_params, 3150 query_params, 3151 header_params, 3152 body=body_params, 3153 post_params=form_params, 3154 files=local_var_files, 3155 response_type='Tabs', 3156 auth_settings=auth_settings, 3157 callback=params.get('callback'), 3158 _return_http_data_only=params.get('_return_http_data_only'), 3159 _preload_content=params.get('_preload_content', True), 3160 _request_timeout=params.get('_request_timeout'), 3161 collection_formats=collection_formats)
Adds tabs for a recipient.
Adds one or more tabs for a recipient.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
- Tabs tabs:
Returns
Tabs If the method is called asynchronously, returns the request thread.
def
create_template_workflow_step_definition(self, account_id, template_id, **kwargs)
3163 def create_template_workflow_step_definition(self, account_id, template_id, **kwargs): 3164 """ 3165 Creates and adds a new workflow step definition for a template's workflow 3166 This method makes a synchronous HTTP request by default. To make an 3167 asynchronous HTTP request, please define a `callback` function 3168 to be invoked when receiving the response. 3169 >>> def callback_function(response): 3170 >>> pprint(response) 3171 >>> 3172 >>> thread = api.create_template_workflow_step_definition(account_id, template_id, callback=callback_function) 3173 3174 :param callback function: The callback function 3175 for asynchronous request. (optional) 3176 :param str account_id: The external account number (int) or account ID Guid. (required) 3177 :param str template_id: The ID of the template being accessed. (required) 3178 :param WorkflowStep workflow_step: 3179 :return: WorkflowStep 3180 If the method is called asynchronously, 3181 returns the request thread. 3182 """ 3183 kwargs['_return_http_data_only'] = True 3184 if kwargs.get('callback'): 3185 return self.create_template_workflow_step_definition_with_http_info(account_id, template_id, **kwargs) 3186 else: 3187 (data) = self.create_template_workflow_step_definition_with_http_info(account_id, template_id, **kwargs) 3188 return data
Creates and adds a new workflow step definition for a template's workflow
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_template_workflow_step_definition(account_id, template_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str template_id: The ID of the template being accessed. (required)
- WorkflowStep workflow_step:
Returns
WorkflowStep If the method is called asynchronously, returns the request thread.
def
create_template_workflow_step_definition_with_http_info(self, account_id, template_id, **kwargs)
3190 def create_template_workflow_step_definition_with_http_info(self, account_id, template_id, **kwargs): 3191 """ 3192 Creates and adds a new workflow step definition for a template's workflow 3193 This method makes a synchronous HTTP request by default. To make an 3194 asynchronous HTTP request, please define a `callback` function 3195 to be invoked when receiving the response. 3196 >>> def callback_function(response): 3197 >>> pprint(response) 3198 >>> 3199 >>> thread = api.create_template_workflow_step_definition_with_http_info(account_id, template_id, callback=callback_function) 3200 3201 :param callback function: The callback function 3202 for asynchronous request. (optional) 3203 :param str account_id: The external account number (int) or account ID Guid. (required) 3204 :param str template_id: The ID of the template being accessed. (required) 3205 :param WorkflowStep workflow_step: 3206 :return: WorkflowStep 3207 If the method is called asynchronously, 3208 returns the request thread. 3209 """ 3210 3211 all_params = ['account_id', 'template_id', 'workflow_step'] 3212 all_params.append('callback') 3213 all_params.append('_return_http_data_only') 3214 all_params.append('_preload_content') 3215 all_params.append('_request_timeout') 3216 3217 params = locals() 3218 for key, val in iteritems(params['kwargs']): 3219 if key not in all_params: 3220 raise TypeError( 3221 "Got an unexpected keyword argument '%s'" 3222 " to method create_template_workflow_step_definition" % key 3223 ) 3224 params[key] = val 3225 del params['kwargs'] 3226 # verify the required parameter 'account_id' is set 3227 if ('account_id' not in params) or (params['account_id'] is None): 3228 raise ValueError("Missing the required parameter `account_id` when calling `create_template_workflow_step_definition`") 3229 # verify the required parameter 'template_id' is set 3230 if ('template_id' not in params) or (params['template_id'] is None): 3231 raise ValueError("Missing the required parameter `template_id` when calling `create_template_workflow_step_definition`") 3232 3233 3234 collection_formats = {} 3235 3236 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps'.replace('{format}', 'json') 3237 path_params = {} 3238 if 'account_id' in params: 3239 path_params['accountId'] = params['account_id'] 3240 if 'template_id' in params: 3241 path_params['templateId'] = params['template_id'] 3242 3243 query_params = {} 3244 3245 header_params = {} 3246 3247 form_params = [] 3248 local_var_files = {} 3249 3250 body_params = None 3251 if 'workflow_step' in params: 3252 body_params = params['workflow_step'] 3253 # HTTP header `Accept` 3254 header_params['Accept'] = self.api_client.\ 3255 select_header_accept(['application/json']) 3256 3257 # Authentication setting 3258 auth_settings = [] 3259 3260 return self.api_client.call_api(resource_path, 'POST', 3261 path_params, 3262 query_params, 3263 header_params, 3264 body=body_params, 3265 post_params=form_params, 3266 files=local_var_files, 3267 response_type='WorkflowStep', 3268 auth_settings=auth_settings, 3269 callback=params.get('callback'), 3270 _return_http_data_only=params.get('_return_http_data_only'), 3271 _preload_content=params.get('_preload_content', True), 3272 _request_timeout=params.get('_request_timeout'), 3273 collection_formats=collection_formats)
Creates and adds a new workflow step definition for a template's workflow
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_template_workflow_step_definition_with_http_info(account_id, template_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str template_id: The ID of the template being accessed. (required)
- WorkflowStep workflow_step:
Returns
WorkflowStep If the method is called asynchronously, returns the request thread.
def
delete_attachments(self, account_id, envelope_id, **kwargs)
3275 def delete_attachments(self, account_id, envelope_id, **kwargs): 3276 """ 3277 Delete one or more attachments from a DRAFT envelope. 3278 Deletes one or more attachments from a draft envelope. 3279 This method makes a synchronous HTTP request by default. To make an 3280 asynchronous HTTP request, please define a `callback` function 3281 to be invoked when receiving the response. 3282 >>> def callback_function(response): 3283 >>> pprint(response) 3284 >>> 3285 >>> thread = api.delete_attachments(account_id, envelope_id, callback=callback_function) 3286 3287 :param callback function: The callback function 3288 for asynchronous request. (optional) 3289 :param str account_id: The external account number (int) or account ID Guid. (required) 3290 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3291 :param EnvelopeAttachmentsRequest envelope_attachments_request: 3292 :return: EnvelopeAttachmentsResult 3293 If the method is called asynchronously, 3294 returns the request thread. 3295 """ 3296 kwargs['_return_http_data_only'] = True 3297 if kwargs.get('callback'): 3298 return self.delete_attachments_with_http_info(account_id, envelope_id, **kwargs) 3299 else: 3300 (data) = self.delete_attachments_with_http_info(account_id, envelope_id, **kwargs) 3301 return data
Delete one or more attachments from a DRAFT envelope.
Deletes one or more attachments from a draft envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_attachments(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- EnvelopeAttachmentsRequest envelope_attachments_request:
Returns
EnvelopeAttachmentsResult If the method is called asynchronously, returns the request thread.
def
delete_attachments_with_http_info(self, account_id, envelope_id, **kwargs)
3303 def delete_attachments_with_http_info(self, account_id, envelope_id, **kwargs): 3304 """ 3305 Delete one or more attachments from a DRAFT envelope. 3306 Deletes one or more attachments from a draft envelope. 3307 This method makes a synchronous HTTP request by default. To make an 3308 asynchronous HTTP request, please define a `callback` function 3309 to be invoked when receiving the response. 3310 >>> def callback_function(response): 3311 >>> pprint(response) 3312 >>> 3313 >>> thread = api.delete_attachments_with_http_info(account_id, envelope_id, callback=callback_function) 3314 3315 :param callback function: The callback function 3316 for asynchronous request. (optional) 3317 :param str account_id: The external account number (int) or account ID Guid. (required) 3318 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3319 :param EnvelopeAttachmentsRequest envelope_attachments_request: 3320 :return: EnvelopeAttachmentsResult 3321 If the method is called asynchronously, 3322 returns the request thread. 3323 """ 3324 3325 all_params = ['account_id', 'envelope_id', 'envelope_attachments_request'] 3326 all_params.append('callback') 3327 all_params.append('_return_http_data_only') 3328 all_params.append('_preload_content') 3329 all_params.append('_request_timeout') 3330 3331 params = locals() 3332 for key, val in iteritems(params['kwargs']): 3333 if key not in all_params: 3334 raise TypeError( 3335 "Got an unexpected keyword argument '%s'" 3336 " to method delete_attachments" % key 3337 ) 3338 params[key] = val 3339 del params['kwargs'] 3340 # verify the required parameter 'account_id' is set 3341 if ('account_id' not in params) or (params['account_id'] is None): 3342 raise ValueError("Missing the required parameter `account_id` when calling `delete_attachments`") 3343 # verify the required parameter 'envelope_id' is set 3344 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3345 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_attachments`") 3346 3347 3348 collection_formats = {} 3349 3350 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments'.replace('{format}', 'json') 3351 path_params = {} 3352 if 'account_id' in params: 3353 path_params['accountId'] = params['account_id'] 3354 if 'envelope_id' in params: 3355 path_params['envelopeId'] = params['envelope_id'] 3356 3357 query_params = {} 3358 3359 header_params = {} 3360 3361 form_params = [] 3362 local_var_files = {} 3363 3364 body_params = None 3365 if 'envelope_attachments_request' in params: 3366 body_params = params['envelope_attachments_request'] 3367 # HTTP header `Accept` 3368 header_params['Accept'] = self.api_client.\ 3369 select_header_accept(['application/json']) 3370 3371 # Authentication setting 3372 auth_settings = [] 3373 3374 return self.api_client.call_api(resource_path, 'DELETE', 3375 path_params, 3376 query_params, 3377 header_params, 3378 body=body_params, 3379 post_params=form_params, 3380 files=local_var_files, 3381 response_type='EnvelopeAttachmentsResult', 3382 auth_settings=auth_settings, 3383 callback=params.get('callback'), 3384 _return_http_data_only=params.get('_return_http_data_only'), 3385 _preload_content=params.get('_preload_content', True), 3386 _request_timeout=params.get('_request_timeout'), 3387 collection_formats=collection_formats)
Delete one or more attachments from a DRAFT envelope.
Deletes one or more attachments from a draft envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_attachments_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- EnvelopeAttachmentsRequest envelope_attachments_request:
Returns
EnvelopeAttachmentsResult If the method is called asynchronously, returns the request thread.
def
delete_chunked_upload(self, account_id, chunked_upload_id, **kwargs)
3389 def delete_chunked_upload(self, account_id, chunked_upload_id, **kwargs): 3390 """ 3391 Delete an existing ChunkedUpload. 3392 Deletes a chunked upload that has been committed but not yet consumed. This method cannot be used to delete the following types of chunked uploads, which the system deletes automatically: - Chunked uploads that have been consumed by use in another API call. - Expired chunked uploads. **Note:** If you are aware of a chunked upload that can be discarded, the best practice is to explicitly delete it. If you wait for the system to automatically delete it after it expires, the chunked upload will continue to count against your quota. 3393 This method makes a synchronous HTTP request by default. To make an 3394 asynchronous HTTP request, please define a `callback` function 3395 to be invoked when receiving the response. 3396 >>> def callback_function(response): 3397 >>> pprint(response) 3398 >>> 3399 >>> thread = api.delete_chunked_upload(account_id, chunked_upload_id, callback=callback_function) 3400 3401 :param callback function: The callback function 3402 for asynchronous request. (optional) 3403 :param str account_id: The external account number (int) or account ID Guid. (required) 3404 :param str chunked_upload_id: (required) 3405 :return: ChunkedUploadResponse 3406 If the method is called asynchronously, 3407 returns the request thread. 3408 """ 3409 kwargs['_return_http_data_only'] = True 3410 if kwargs.get('callback'): 3411 return self.delete_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 3412 else: 3413 (data) = self.delete_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 3414 return data
Delete an existing ChunkedUpload.
Deletes a chunked upload that has been committed but not yet consumed. This method cannot be used to delete the following types of chunked uploads, which the system deletes automatically: - Chunked uploads that have been consumed by use in another API call. - Expired chunked uploads. Note: If you are aware of a chunked upload that can be discarded, the best practice is to explicitly delete it. If you wait for the system to automatically delete it after it expires, the chunked upload will continue to count against your quota.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_chunked_upload(account_id, chunked_upload_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str chunked_upload_id: (required)
Returns
ChunkedUploadResponse If the method is called asynchronously, returns the request thread.
def
delete_chunked_upload_with_http_info(self, account_id, chunked_upload_id, **kwargs)
3416 def delete_chunked_upload_with_http_info(self, account_id, chunked_upload_id, **kwargs): 3417 """ 3418 Delete an existing ChunkedUpload. 3419 Deletes a chunked upload that has been committed but not yet consumed. This method cannot be used to delete the following types of chunked uploads, which the system deletes automatically: - Chunked uploads that have been consumed by use in another API call. - Expired chunked uploads. **Note:** If you are aware of a chunked upload that can be discarded, the best practice is to explicitly delete it. If you wait for the system to automatically delete it after it expires, the chunked upload will continue to count against your quota. 3420 This method makes a synchronous HTTP request by default. To make an 3421 asynchronous HTTP request, please define a `callback` function 3422 to be invoked when receiving the response. 3423 >>> def callback_function(response): 3424 >>> pprint(response) 3425 >>> 3426 >>> thread = api.delete_chunked_upload_with_http_info(account_id, chunked_upload_id, callback=callback_function) 3427 3428 :param callback function: The callback function 3429 for asynchronous request. (optional) 3430 :param str account_id: The external account number (int) or account ID Guid. (required) 3431 :param str chunked_upload_id: (required) 3432 :return: ChunkedUploadResponse 3433 If the method is called asynchronously, 3434 returns the request thread. 3435 """ 3436 3437 all_params = ['account_id', 'chunked_upload_id'] 3438 all_params.append('callback') 3439 all_params.append('_return_http_data_only') 3440 all_params.append('_preload_content') 3441 all_params.append('_request_timeout') 3442 3443 params = locals() 3444 for key, val in iteritems(params['kwargs']): 3445 if key not in all_params: 3446 raise TypeError( 3447 "Got an unexpected keyword argument '%s'" 3448 " to method delete_chunked_upload" % key 3449 ) 3450 params[key] = val 3451 del params['kwargs'] 3452 # verify the required parameter 'account_id' is set 3453 if ('account_id' not in params) or (params['account_id'] is None): 3454 raise ValueError("Missing the required parameter `account_id` when calling `delete_chunked_upload`") 3455 # verify the required parameter 'chunked_upload_id' is set 3456 if ('chunked_upload_id' not in params) or (params['chunked_upload_id'] is None): 3457 raise ValueError("Missing the required parameter `chunked_upload_id` when calling `delete_chunked_upload`") 3458 3459 3460 collection_formats = {} 3461 3462 resource_path = '/v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}'.replace('{format}', 'json') 3463 path_params = {} 3464 if 'account_id' in params: 3465 path_params['accountId'] = params['account_id'] 3466 if 'chunked_upload_id' in params: 3467 path_params['chunkedUploadId'] = params['chunked_upload_id'] 3468 3469 query_params = {} 3470 3471 header_params = {} 3472 3473 form_params = [] 3474 local_var_files = {} 3475 3476 body_params = None 3477 # HTTP header `Accept` 3478 header_params['Accept'] = self.api_client.\ 3479 select_header_accept(['application/json']) 3480 3481 # Authentication setting 3482 auth_settings = [] 3483 3484 return self.api_client.call_api(resource_path, 'DELETE', 3485 path_params, 3486 query_params, 3487 header_params, 3488 body=body_params, 3489 post_params=form_params, 3490 files=local_var_files, 3491 response_type='ChunkedUploadResponse', 3492 auth_settings=auth_settings, 3493 callback=params.get('callback'), 3494 _return_http_data_only=params.get('_return_http_data_only'), 3495 _preload_content=params.get('_preload_content', True), 3496 _request_timeout=params.get('_request_timeout'), 3497 collection_formats=collection_formats)
Delete an existing ChunkedUpload.
Deletes a chunked upload that has been committed but not yet consumed. This method cannot be used to delete the following types of chunked uploads, which the system deletes automatically: - Chunked uploads that have been consumed by use in another API call. - Expired chunked uploads. Note: If you are aware of a chunked upload that can be discarded, the best practice is to explicitly delete it. If you wait for the system to automatically delete it after it expires, the chunked upload will continue to count against your quota.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_chunked_upload_with_http_info(account_id, chunked_upload_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str chunked_upload_id: (required)
Returns
ChunkedUploadResponse If the method is called asynchronously, returns the request thread.
def
delete_custom_fields(self, account_id, envelope_id, **kwargs)
3499 def delete_custom_fields(self, account_id, envelope_id, **kwargs): 3500 """ 3501 Deletes envelope custom fields for draft and in-process envelopes. 3502 Deletes envelope custom fields for draft and in-process envelopes. 3503 This method makes a synchronous HTTP request by default. To make an 3504 asynchronous HTTP request, please define a `callback` function 3505 to be invoked when receiving the response. 3506 >>> def callback_function(response): 3507 >>> pprint(response) 3508 >>> 3509 >>> thread = api.delete_custom_fields(account_id, envelope_id, callback=callback_function) 3510 3511 :param callback function: The callback function 3512 for asynchronous request. (optional) 3513 :param str account_id: The external account number (int) or account ID Guid. (required) 3514 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3515 :param CustomFields custom_fields: 3516 :return: CustomFields 3517 If the method is called asynchronously, 3518 returns the request thread. 3519 """ 3520 kwargs['_return_http_data_only'] = True 3521 if kwargs.get('callback'): 3522 return self.delete_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 3523 else: 3524 (data) = self.delete_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 3525 return data
Deletes envelope custom fields for draft and in-process envelopes.
Deletes envelope custom fields for draft and in-process envelopes.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_custom_fields(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- CustomFields custom_fields:
Returns
CustomFields If the method is called asynchronously, returns the request thread.
def
delete_custom_fields_with_http_info(self, account_id, envelope_id, **kwargs)
3527 def delete_custom_fields_with_http_info(self, account_id, envelope_id, **kwargs): 3528 """ 3529 Deletes envelope custom fields for draft and in-process envelopes. 3530 Deletes envelope custom fields for draft and in-process envelopes. 3531 This method makes a synchronous HTTP request by default. To make an 3532 asynchronous HTTP request, please define a `callback` function 3533 to be invoked when receiving the response. 3534 >>> def callback_function(response): 3535 >>> pprint(response) 3536 >>> 3537 >>> thread = api.delete_custom_fields_with_http_info(account_id, envelope_id, callback=callback_function) 3538 3539 :param callback function: The callback function 3540 for asynchronous request. (optional) 3541 :param str account_id: The external account number (int) or account ID Guid. (required) 3542 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3543 :param CustomFields custom_fields: 3544 :return: CustomFields 3545 If the method is called asynchronously, 3546 returns the request thread. 3547 """ 3548 3549 all_params = ['account_id', 'envelope_id', 'custom_fields'] 3550 all_params.append('callback') 3551 all_params.append('_return_http_data_only') 3552 all_params.append('_preload_content') 3553 all_params.append('_request_timeout') 3554 3555 params = locals() 3556 for key, val in iteritems(params['kwargs']): 3557 if key not in all_params: 3558 raise TypeError( 3559 "Got an unexpected keyword argument '%s'" 3560 " to method delete_custom_fields" % key 3561 ) 3562 params[key] = val 3563 del params['kwargs'] 3564 # verify the required parameter 'account_id' is set 3565 if ('account_id' not in params) or (params['account_id'] is None): 3566 raise ValueError("Missing the required parameter `account_id` when calling `delete_custom_fields`") 3567 # verify the required parameter 'envelope_id' is set 3568 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3569 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_custom_fields`") 3570 3571 3572 collection_formats = {} 3573 3574 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/custom_fields'.replace('{format}', 'json') 3575 path_params = {} 3576 if 'account_id' in params: 3577 path_params['accountId'] = params['account_id'] 3578 if 'envelope_id' in params: 3579 path_params['envelopeId'] = params['envelope_id'] 3580 3581 query_params = {} 3582 3583 header_params = {} 3584 3585 form_params = [] 3586 local_var_files = {} 3587 3588 body_params = None 3589 if 'custom_fields' in params: 3590 body_params = params['custom_fields'] 3591 # HTTP header `Accept` 3592 header_params['Accept'] = self.api_client.\ 3593 select_header_accept(['application/json']) 3594 3595 # Authentication setting 3596 auth_settings = [] 3597 3598 return self.api_client.call_api(resource_path, 'DELETE', 3599 path_params, 3600 query_params, 3601 header_params, 3602 body=body_params, 3603 post_params=form_params, 3604 files=local_var_files, 3605 response_type='CustomFields', 3606 auth_settings=auth_settings, 3607 callback=params.get('callback'), 3608 _return_http_data_only=params.get('_return_http_data_only'), 3609 _preload_content=params.get('_preload_content', True), 3610 _request_timeout=params.get('_request_timeout'), 3611 collection_formats=collection_formats)
Deletes envelope custom fields for draft and in-process envelopes.
Deletes envelope custom fields for draft and in-process envelopes.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_custom_fields_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- CustomFields custom_fields:
Returns
CustomFields If the method is called asynchronously, returns the request thread.
def
delete_document_fields(self, account_id, document_id, envelope_id, **kwargs)
3613 def delete_document_fields(self, account_id, document_id, envelope_id, **kwargs): 3614 """ 3615 Deletes custom document fields from an existing envelope document. 3616 Deletes custom document fields from an existing envelope document. 3617 This method makes a synchronous HTTP request by default. To make an 3618 asynchronous HTTP request, please define a `callback` function 3619 to be invoked when receiving the response. 3620 >>> def callback_function(response): 3621 >>> pprint(response) 3622 >>> 3623 >>> thread = api.delete_document_fields(account_id, document_id, envelope_id, callback=callback_function) 3624 3625 :param callback function: The callback function 3626 for asynchronous request. (optional) 3627 :param str account_id: The external account number (int) or account ID Guid. (required) 3628 :param str document_id: The ID of the document being accessed. (required) 3629 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3630 :param DocumentFieldsInformation document_fields_information: 3631 :return: DocumentFieldsInformation 3632 If the method is called asynchronously, 3633 returns the request thread. 3634 """ 3635 kwargs['_return_http_data_only'] = True 3636 if kwargs.get('callback'): 3637 return self.delete_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 3638 else: 3639 (data) = self.delete_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 3640 return data
Deletes custom document fields from an existing envelope document.
Deletes custom document fields from an existing envelope document.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_document_fields(account_id, document_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- DocumentFieldsInformation document_fields_information:
Returns
DocumentFieldsInformation If the method is called asynchronously, returns the request thread.
def
delete_document_fields_with_http_info(self, account_id, document_id, envelope_id, **kwargs)
3642 def delete_document_fields_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 3643 """ 3644 Deletes custom document fields from an existing envelope document. 3645 Deletes custom document fields from an existing envelope document. 3646 This method makes a synchronous HTTP request by default. To make an 3647 asynchronous HTTP request, please define a `callback` function 3648 to be invoked when receiving the response. 3649 >>> def callback_function(response): 3650 >>> pprint(response) 3651 >>> 3652 >>> thread = api.delete_document_fields_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 3653 3654 :param callback function: The callback function 3655 for asynchronous request. (optional) 3656 :param str account_id: The external account number (int) or account ID Guid. (required) 3657 :param str document_id: The ID of the document being accessed. (required) 3658 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3659 :param DocumentFieldsInformation document_fields_information: 3660 :return: DocumentFieldsInformation 3661 If the method is called asynchronously, 3662 returns the request thread. 3663 """ 3664 3665 all_params = ['account_id', 'document_id', 'envelope_id', 'document_fields_information'] 3666 all_params.append('callback') 3667 all_params.append('_return_http_data_only') 3668 all_params.append('_preload_content') 3669 all_params.append('_request_timeout') 3670 3671 params = locals() 3672 for key, val in iteritems(params['kwargs']): 3673 if key not in all_params: 3674 raise TypeError( 3675 "Got an unexpected keyword argument '%s'" 3676 " to method delete_document_fields" % key 3677 ) 3678 params[key] = val 3679 del params['kwargs'] 3680 # verify the required parameter 'account_id' is set 3681 if ('account_id' not in params) or (params['account_id'] is None): 3682 raise ValueError("Missing the required parameter `account_id` when calling `delete_document_fields`") 3683 # verify the required parameter 'document_id' is set 3684 if ('document_id' not in params) or (params['document_id'] is None): 3685 raise ValueError("Missing the required parameter `document_id` when calling `delete_document_fields`") 3686 # verify the required parameter 'envelope_id' is set 3687 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3688 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_document_fields`") 3689 3690 3691 collection_formats = {} 3692 3693 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/fields'.replace('{format}', 'json') 3694 path_params = {} 3695 if 'account_id' in params: 3696 path_params['accountId'] = params['account_id'] 3697 if 'document_id' in params: 3698 path_params['documentId'] = params['document_id'] 3699 if 'envelope_id' in params: 3700 path_params['envelopeId'] = params['envelope_id'] 3701 3702 query_params = {} 3703 3704 header_params = {} 3705 3706 form_params = [] 3707 local_var_files = {} 3708 3709 body_params = None 3710 if 'document_fields_information' in params: 3711 body_params = params['document_fields_information'] 3712 # HTTP header `Accept` 3713 header_params['Accept'] = self.api_client.\ 3714 select_header_accept(['application/json']) 3715 3716 # Authentication setting 3717 auth_settings = [] 3718 3719 return self.api_client.call_api(resource_path, 'DELETE', 3720 path_params, 3721 query_params, 3722 header_params, 3723 body=body_params, 3724 post_params=form_params, 3725 files=local_var_files, 3726 response_type='DocumentFieldsInformation', 3727 auth_settings=auth_settings, 3728 callback=params.get('callback'), 3729 _return_http_data_only=params.get('_return_http_data_only'), 3730 _preload_content=params.get('_preload_content', True), 3731 _request_timeout=params.get('_request_timeout'), 3732 collection_formats=collection_formats)
Deletes custom document fields from an existing envelope document.
Deletes custom document fields from an existing envelope document.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_document_fields_with_http_info(account_id, document_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- DocumentFieldsInformation document_fields_information:
Returns
DocumentFieldsInformation If the method is called asynchronously, returns the request thread.
def
delete_document_page(self, account_id, document_id, envelope_id, page_number, **kwargs)
3734 def delete_document_page(self, account_id, document_id, envelope_id, page_number, **kwargs): 3735 """ 3736 Deletes a page from a document in an envelope. 3737 Deletes a page from a document in an envelope based on the page number. 3738 This method makes a synchronous HTTP request by default. To make an 3739 asynchronous HTTP request, please define a `callback` function 3740 to be invoked when receiving the response. 3741 >>> def callback_function(response): 3742 >>> pprint(response) 3743 >>> 3744 >>> thread = api.delete_document_page(account_id, document_id, envelope_id, page_number, callback=callback_function) 3745 3746 :param callback function: The callback function 3747 for asynchronous request. (optional) 3748 :param str account_id: The external account number (int) or account ID Guid. (required) 3749 :param str document_id: The ID of the document being accessed. (required) 3750 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3751 :param str page_number: The page number being accessed. (required) 3752 :return: None 3753 If the method is called asynchronously, 3754 returns the request thread. 3755 """ 3756 kwargs['_return_http_data_only'] = True 3757 if kwargs.get('callback'): 3758 return self.delete_document_page_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 3759 else: 3760 (data) = self.delete_document_page_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 3761 return data
Deletes a page from a document in an envelope.
Deletes a page from a document in an envelope based on the page number.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_document_page(account_id, document_id, envelope_id, page_number, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str page_number: The page number being accessed. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_document_page_with_http_info(self, account_id, document_id, envelope_id, page_number, **kwargs)
3763 def delete_document_page_with_http_info(self, account_id, document_id, envelope_id, page_number, **kwargs): 3764 """ 3765 Deletes a page from a document in an envelope. 3766 Deletes a page from a document in an envelope based on the page number. 3767 This method makes a synchronous HTTP request by default. To make an 3768 asynchronous HTTP request, please define a `callback` function 3769 to be invoked when receiving the response. 3770 >>> def callback_function(response): 3771 >>> pprint(response) 3772 >>> 3773 >>> thread = api.delete_document_page_with_http_info(account_id, document_id, envelope_id, page_number, callback=callback_function) 3774 3775 :param callback function: The callback function 3776 for asynchronous request. (optional) 3777 :param str account_id: The external account number (int) or account ID Guid. (required) 3778 :param str document_id: The ID of the document being accessed. (required) 3779 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3780 :param str page_number: The page number being accessed. (required) 3781 :return: None 3782 If the method is called asynchronously, 3783 returns the request thread. 3784 """ 3785 3786 all_params = ['account_id', 'document_id', 'envelope_id', 'page_number'] 3787 all_params.append('callback') 3788 all_params.append('_return_http_data_only') 3789 all_params.append('_preload_content') 3790 all_params.append('_request_timeout') 3791 3792 params = locals() 3793 for key, val in iteritems(params['kwargs']): 3794 if key not in all_params: 3795 raise TypeError( 3796 "Got an unexpected keyword argument '%s'" 3797 " to method delete_document_page" % key 3798 ) 3799 params[key] = val 3800 del params['kwargs'] 3801 # verify the required parameter 'account_id' is set 3802 if ('account_id' not in params) or (params['account_id'] is None): 3803 raise ValueError("Missing the required parameter `account_id` when calling `delete_document_page`") 3804 # verify the required parameter 'document_id' is set 3805 if ('document_id' not in params) or (params['document_id'] is None): 3806 raise ValueError("Missing the required parameter `document_id` when calling `delete_document_page`") 3807 # verify the required parameter 'envelope_id' is set 3808 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3809 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_document_page`") 3810 # verify the required parameter 'page_number' is set 3811 if ('page_number' not in params) or (params['page_number'] is None): 3812 raise ValueError("Missing the required parameter `page_number` when calling `delete_document_page`") 3813 3814 3815 collection_formats = {} 3816 3817 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/pages/{pageNumber}'.replace('{format}', 'json') 3818 path_params = {} 3819 if 'account_id' in params: 3820 path_params['accountId'] = params['account_id'] 3821 if 'document_id' in params: 3822 path_params['documentId'] = params['document_id'] 3823 if 'envelope_id' in params: 3824 path_params['envelopeId'] = params['envelope_id'] 3825 if 'page_number' in params: 3826 path_params['pageNumber'] = params['page_number'] 3827 3828 query_params = {} 3829 3830 header_params = {} 3831 3832 form_params = [] 3833 local_var_files = {} 3834 3835 body_params = None 3836 # HTTP header `Accept` 3837 header_params['Accept'] = self.api_client.\ 3838 select_header_accept(['application/json']) 3839 3840 # Authentication setting 3841 auth_settings = [] 3842 3843 return self.api_client.call_api(resource_path, 'DELETE', 3844 path_params, 3845 query_params, 3846 header_params, 3847 body=body_params, 3848 post_params=form_params, 3849 files=local_var_files, 3850 response_type=None, 3851 auth_settings=auth_settings, 3852 callback=params.get('callback'), 3853 _return_http_data_only=params.get('_return_http_data_only'), 3854 _preload_content=params.get('_preload_content', True), 3855 _request_timeout=params.get('_request_timeout'), 3856 collection_formats=collection_formats)
Deletes a page from a document in an envelope.
Deletes a page from a document in an envelope based on the page number.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_document_page_with_http_info(account_id, document_id, envelope_id, page_number, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str page_number: The page number being accessed. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_document_tabs(self, account_id, document_id, envelope_id, **kwargs)
3858 def delete_document_tabs(self, account_id, document_id, envelope_id, **kwargs): 3859 """ 3860 Deletes tabs from an envelope document 3861 Deletes tabs from the document specified by `documentId` in the envelope specified by `envelopeId`. 3862 This method makes a synchronous HTTP request by default. To make an 3863 asynchronous HTTP request, please define a `callback` function 3864 to be invoked when receiving the response. 3865 >>> def callback_function(response): 3866 >>> pprint(response) 3867 >>> 3868 >>> thread = api.delete_document_tabs(account_id, document_id, envelope_id, callback=callback_function) 3869 3870 :param callback function: The callback function 3871 for asynchronous request. (optional) 3872 :param str account_id: The external account number (int) or account ID Guid. (required) 3873 :param str document_id: The ID of the document being accessed. (required) 3874 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3875 :param Tabs tabs: 3876 :return: Tabs 3877 If the method is called asynchronously, 3878 returns the request thread. 3879 """ 3880 kwargs['_return_http_data_only'] = True 3881 if kwargs.get('callback'): 3882 return self.delete_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 3883 else: 3884 (data) = self.delete_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 3885 return data
Deletes tabs from an envelope document
Deletes tabs from the document specified by documentId in the envelope specified by envelopeId.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_document_tabs(account_id, document_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- Tabs tabs:
Returns
Tabs If the method is called asynchronously, returns the request thread.
def
delete_document_tabs_with_http_info(self, account_id, document_id, envelope_id, **kwargs)
3887 def delete_document_tabs_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 3888 """ 3889 Deletes tabs from an envelope document 3890 Deletes tabs from the document specified by `documentId` in the envelope specified by `envelopeId`. 3891 This method makes a synchronous HTTP request by default. To make an 3892 asynchronous HTTP request, please define a `callback` function 3893 to be invoked when receiving the response. 3894 >>> def callback_function(response): 3895 >>> pprint(response) 3896 >>> 3897 >>> thread = api.delete_document_tabs_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 3898 3899 :param callback function: The callback function 3900 for asynchronous request. (optional) 3901 :param str account_id: The external account number (int) or account ID Guid. (required) 3902 :param str document_id: The ID of the document being accessed. (required) 3903 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3904 :param Tabs tabs: 3905 :return: Tabs 3906 If the method is called asynchronously, 3907 returns the request thread. 3908 """ 3909 3910 all_params = ['account_id', 'document_id', 'envelope_id', 'tabs'] 3911 all_params.append('callback') 3912 all_params.append('_return_http_data_only') 3913 all_params.append('_preload_content') 3914 all_params.append('_request_timeout') 3915 3916 params = locals() 3917 for key, val in iteritems(params['kwargs']): 3918 if key not in all_params: 3919 raise TypeError( 3920 "Got an unexpected keyword argument '%s'" 3921 " to method delete_document_tabs" % key 3922 ) 3923 params[key] = val 3924 del params['kwargs'] 3925 # verify the required parameter 'account_id' is set 3926 if ('account_id' not in params) or (params['account_id'] is None): 3927 raise ValueError("Missing the required parameter `account_id` when calling `delete_document_tabs`") 3928 # verify the required parameter 'document_id' is set 3929 if ('document_id' not in params) or (params['document_id'] is None): 3930 raise ValueError("Missing the required parameter `document_id` when calling `delete_document_tabs`") 3931 # verify the required parameter 'envelope_id' is set 3932 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3933 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_document_tabs`") 3934 3935 3936 collection_formats = {} 3937 3938 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/tabs'.replace('{format}', 'json') 3939 path_params = {} 3940 if 'account_id' in params: 3941 path_params['accountId'] = params['account_id'] 3942 if 'document_id' in params: 3943 path_params['documentId'] = params['document_id'] 3944 if 'envelope_id' in params: 3945 path_params['envelopeId'] = params['envelope_id'] 3946 3947 query_params = {} 3948 3949 header_params = {} 3950 3951 form_params = [] 3952 local_var_files = {} 3953 3954 body_params = None 3955 if 'tabs' in params: 3956 body_params = params['tabs'] 3957 # HTTP header `Accept` 3958 header_params['Accept'] = self.api_client.\ 3959 select_header_accept(['application/json']) 3960 3961 # Authentication setting 3962 auth_settings = [] 3963 3964 return self.api_client.call_api(resource_path, 'DELETE', 3965 path_params, 3966 query_params, 3967 header_params, 3968 body=body_params, 3969 post_params=form_params, 3970 files=local_var_files, 3971 response_type='Tabs', 3972 auth_settings=auth_settings, 3973 callback=params.get('callback'), 3974 _return_http_data_only=params.get('_return_http_data_only'), 3975 _preload_content=params.get('_preload_content', True), 3976 _request_timeout=params.get('_request_timeout'), 3977 collection_formats=collection_formats)
Deletes tabs from an envelope document
Deletes tabs from the document specified by documentId in the envelope specified by envelopeId.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_document_tabs_with_http_info(account_id, document_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- Tabs tabs:
Returns
Tabs If the method is called asynchronously, returns the request thread.
def
delete_documents(self, account_id, envelope_id, **kwargs)
3979 def delete_documents(self, account_id, envelope_id, **kwargs): 3980 """ 3981 Deletes documents from a draft envelope. 3982 Deletes one or more documents from an existing draft envelope. 3983 This method makes a synchronous HTTP request by default. To make an 3984 asynchronous HTTP request, please define a `callback` function 3985 to be invoked when receiving the response. 3986 >>> def callback_function(response): 3987 >>> pprint(response) 3988 >>> 3989 >>> thread = api.delete_documents(account_id, envelope_id, callback=callback_function) 3990 3991 :param callback function: The callback function 3992 for asynchronous request. (optional) 3993 :param str account_id: The external account number (int) or account ID Guid. (required) 3994 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3995 :param EnvelopeDefinition envelope_definition: 3996 :return: EnvelopeDocumentsResult 3997 If the method is called asynchronously, 3998 returns the request thread. 3999 """ 4000 kwargs['_return_http_data_only'] = True 4001 if kwargs.get('callback'): 4002 return self.delete_documents_with_http_info(account_id, envelope_id, **kwargs) 4003 else: 4004 (data) = self.delete_documents_with_http_info(account_id, envelope_id, **kwargs) 4005 return data
Deletes documents from a draft envelope.
Deletes one or more documents from an existing draft envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_documents(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- EnvelopeDefinition envelope_definition:
Returns
EnvelopeDocumentsResult If the method is called asynchronously, returns the request thread.
def
delete_documents_with_http_info(self, account_id, envelope_id, **kwargs)
4007 def delete_documents_with_http_info(self, account_id, envelope_id, **kwargs): 4008 """ 4009 Deletes documents from a draft envelope. 4010 Deletes one or more documents from an existing draft envelope. 4011 This method makes a synchronous HTTP request by default. To make an 4012 asynchronous HTTP request, please define a `callback` function 4013 to be invoked when receiving the response. 4014 >>> def callback_function(response): 4015 >>> pprint(response) 4016 >>> 4017 >>> thread = api.delete_documents_with_http_info(account_id, envelope_id, callback=callback_function) 4018 4019 :param callback function: The callback function 4020 for asynchronous request. (optional) 4021 :param str account_id: The external account number (int) or account ID Guid. (required) 4022 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4023 :param EnvelopeDefinition envelope_definition: 4024 :return: EnvelopeDocumentsResult 4025 If the method is called asynchronously, 4026 returns the request thread. 4027 """ 4028 4029 all_params = ['account_id', 'envelope_id', 'envelope_definition'] 4030 all_params.append('callback') 4031 all_params.append('_return_http_data_only') 4032 all_params.append('_preload_content') 4033 all_params.append('_request_timeout') 4034 4035 params = locals() 4036 for key, val in iteritems(params['kwargs']): 4037 if key not in all_params: 4038 raise TypeError( 4039 "Got an unexpected keyword argument '%s'" 4040 " to method delete_documents" % key 4041 ) 4042 params[key] = val 4043 del params['kwargs'] 4044 # verify the required parameter 'account_id' is set 4045 if ('account_id' not in params) or (params['account_id'] is None): 4046 raise ValueError("Missing the required parameter `account_id` when calling `delete_documents`") 4047 # verify the required parameter 'envelope_id' is set 4048 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4049 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_documents`") 4050 4051 4052 collection_formats = {} 4053 4054 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents'.replace('{format}', 'json') 4055 path_params = {} 4056 if 'account_id' in params: 4057 path_params['accountId'] = params['account_id'] 4058 if 'envelope_id' in params: 4059 path_params['envelopeId'] = params['envelope_id'] 4060 4061 query_params = {} 4062 4063 header_params = {} 4064 4065 form_params = [] 4066 local_var_files = {} 4067 4068 body_params = None 4069 if 'envelope_definition' in params: 4070 body_params = params['envelope_definition'] 4071 # HTTP header `Accept` 4072 header_params['Accept'] = self.api_client.\ 4073 select_header_accept(['application/json']) 4074 4075 # Authentication setting 4076 auth_settings = [] 4077 4078 return self.api_client.call_api(resource_path, 'DELETE', 4079 path_params, 4080 query_params, 4081 header_params, 4082 body=body_params, 4083 post_params=form_params, 4084 files=local_var_files, 4085 response_type='EnvelopeDocumentsResult', 4086 auth_settings=auth_settings, 4087 callback=params.get('callback'), 4088 _return_http_data_only=params.get('_return_http_data_only'), 4089 _preload_content=params.get('_preload_content', True), 4090 _request_timeout=params.get('_request_timeout'), 4091 collection_formats=collection_formats)
Deletes documents from a draft envelope.
Deletes one or more documents from an existing draft envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_documents_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- EnvelopeDefinition envelope_definition:
Returns
EnvelopeDocumentsResult If the method is called asynchronously, returns the request thread.
def
delete_email_settings(self, account_id, envelope_id, **kwargs)
4093 def delete_email_settings(self, account_id, envelope_id, **kwargs): 4094 """ 4095 Deletes the email setting overrides for an envelope. 4096 Deletes all existing email override settings for the envelope. If you want to delete an individual email override setting, use the PUT and set the value to an empty string. Note that deleting email settings will only affect email communications that occur after the deletion and the normal account email settings are used for future email communications. 4097 This method makes a synchronous HTTP request by default. To make an 4098 asynchronous HTTP request, please define a `callback` function 4099 to be invoked when receiving the response. 4100 >>> def callback_function(response): 4101 >>> pprint(response) 4102 >>> 4103 >>> thread = api.delete_email_settings(account_id, envelope_id, callback=callback_function) 4104 4105 :param callback function: The callback function 4106 for asynchronous request. (optional) 4107 :param str account_id: The external account number (int) or account ID Guid. (required) 4108 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4109 :return: EmailSettings 4110 If the method is called asynchronously, 4111 returns the request thread. 4112 """ 4113 kwargs['_return_http_data_only'] = True 4114 if kwargs.get('callback'): 4115 return self.delete_email_settings_with_http_info(account_id, envelope_id, **kwargs) 4116 else: 4117 (data) = self.delete_email_settings_with_http_info(account_id, envelope_id, **kwargs) 4118 return data
Deletes the email setting overrides for an envelope.
Deletes all existing email override settings for the envelope. If you want to delete an individual email override setting, use the PUT and set the value to an empty string. Note that deleting email settings will only affect email communications that occur after the deletion and the normal account email settings are used for future email communications.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_email_settings(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
EmailSettings If the method is called asynchronously, returns the request thread.
def
delete_email_settings_with_http_info(self, account_id, envelope_id, **kwargs)
4120 def delete_email_settings_with_http_info(self, account_id, envelope_id, **kwargs): 4121 """ 4122 Deletes the email setting overrides for an envelope. 4123 Deletes all existing email override settings for the envelope. If you want to delete an individual email override setting, use the PUT and set the value to an empty string. Note that deleting email settings will only affect email communications that occur after the deletion and the normal account email settings are used for future email communications. 4124 This method makes a synchronous HTTP request by default. To make an 4125 asynchronous HTTP request, please define a `callback` function 4126 to be invoked when receiving the response. 4127 >>> def callback_function(response): 4128 >>> pprint(response) 4129 >>> 4130 >>> thread = api.delete_email_settings_with_http_info(account_id, envelope_id, callback=callback_function) 4131 4132 :param callback function: The callback function 4133 for asynchronous request. (optional) 4134 :param str account_id: The external account number (int) or account ID Guid. (required) 4135 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4136 :return: EmailSettings 4137 If the method is called asynchronously, 4138 returns the request thread. 4139 """ 4140 4141 all_params = ['account_id', 'envelope_id'] 4142 all_params.append('callback') 4143 all_params.append('_return_http_data_only') 4144 all_params.append('_preload_content') 4145 all_params.append('_request_timeout') 4146 4147 params = locals() 4148 for key, val in iteritems(params['kwargs']): 4149 if key not in all_params: 4150 raise TypeError( 4151 "Got an unexpected keyword argument '%s'" 4152 " to method delete_email_settings" % key 4153 ) 4154 params[key] = val 4155 del params['kwargs'] 4156 # verify the required parameter 'account_id' is set 4157 if ('account_id' not in params) or (params['account_id'] is None): 4158 raise ValueError("Missing the required parameter `account_id` when calling `delete_email_settings`") 4159 # verify the required parameter 'envelope_id' is set 4160 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4161 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_email_settings`") 4162 4163 4164 collection_formats = {} 4165 4166 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/email_settings'.replace('{format}', 'json') 4167 path_params = {} 4168 if 'account_id' in params: 4169 path_params['accountId'] = params['account_id'] 4170 if 'envelope_id' in params: 4171 path_params['envelopeId'] = params['envelope_id'] 4172 4173 query_params = {} 4174 4175 header_params = {} 4176 4177 form_params = [] 4178 local_var_files = {} 4179 4180 body_params = None 4181 # HTTP header `Accept` 4182 header_params['Accept'] = self.api_client.\ 4183 select_header_accept(['application/json']) 4184 4185 # Authentication setting 4186 auth_settings = [] 4187 4188 return self.api_client.call_api(resource_path, 'DELETE', 4189 path_params, 4190 query_params, 4191 header_params, 4192 body=body_params, 4193 post_params=form_params, 4194 files=local_var_files, 4195 response_type='EmailSettings', 4196 auth_settings=auth_settings, 4197 callback=params.get('callback'), 4198 _return_http_data_only=params.get('_return_http_data_only'), 4199 _preload_content=params.get('_preload_content', True), 4200 _request_timeout=params.get('_request_timeout'), 4201 collection_formats=collection_formats)
Deletes the email setting overrides for an envelope.
Deletes all existing email override settings for the envelope. If you want to delete an individual email override setting, use the PUT and set the value to an empty string. Note that deleting email settings will only affect email communications that occur after the deletion and the normal account email settings are used for future email communications.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_email_settings_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
EmailSettings If the method is called asynchronously, returns the request thread.
def
delete_envelope_correct_view(self, account_id, envelope_id, **kwargs)
4203 def delete_envelope_correct_view(self, account_id, envelope_id, **kwargs): 4204 """ 4205 Revokes the correction view URL to the Envelope UI 4206 Revokes the correction view URL to the Envelope UI. 4207 This method makes a synchronous HTTP request by default. To make an 4208 asynchronous HTTP request, please define a `callback` function 4209 to be invoked when receiving the response. 4210 >>> def callback_function(response): 4211 >>> pprint(response) 4212 >>> 4213 >>> thread = api.delete_envelope_correct_view(account_id, envelope_id, callback=callback_function) 4214 4215 :param callback function: The callback function 4216 for asynchronous request. (optional) 4217 :param str account_id: The external account number (int) or account ID Guid. (required) 4218 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4219 :param CorrectViewRequest correct_view_request: 4220 :return: None 4221 If the method is called asynchronously, 4222 returns the request thread. 4223 """ 4224 kwargs['_return_http_data_only'] = True 4225 if kwargs.get('callback'): 4226 return self.delete_envelope_correct_view_with_http_info(account_id, envelope_id, **kwargs) 4227 else: 4228 (data) = self.delete_envelope_correct_view_with_http_info(account_id, envelope_id, **kwargs) 4229 return data
Revokes the correction view URL to the Envelope UI
Revokes the correction view URL to the Envelope UI.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_envelope_correct_view(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- CorrectViewRequest correct_view_request:
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_envelope_correct_view_with_http_info(self, account_id, envelope_id, **kwargs)
4231 def delete_envelope_correct_view_with_http_info(self, account_id, envelope_id, **kwargs): 4232 """ 4233 Revokes the correction view URL to the Envelope UI 4234 Revokes the correction view URL to the Envelope UI. 4235 This method makes a synchronous HTTP request by default. To make an 4236 asynchronous HTTP request, please define a `callback` function 4237 to be invoked when receiving the response. 4238 >>> def callback_function(response): 4239 >>> pprint(response) 4240 >>> 4241 >>> thread = api.delete_envelope_correct_view_with_http_info(account_id, envelope_id, callback=callback_function) 4242 4243 :param callback function: The callback function 4244 for asynchronous request. (optional) 4245 :param str account_id: The external account number (int) or account ID Guid. (required) 4246 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4247 :param CorrectViewRequest correct_view_request: 4248 :return: None 4249 If the method is called asynchronously, 4250 returns the request thread. 4251 """ 4252 4253 all_params = ['account_id', 'envelope_id', 'correct_view_request'] 4254 all_params.append('callback') 4255 all_params.append('_return_http_data_only') 4256 all_params.append('_preload_content') 4257 all_params.append('_request_timeout') 4258 4259 params = locals() 4260 for key, val in iteritems(params['kwargs']): 4261 if key not in all_params: 4262 raise TypeError( 4263 "Got an unexpected keyword argument '%s'" 4264 " to method delete_envelope_correct_view" % key 4265 ) 4266 params[key] = val 4267 del params['kwargs'] 4268 # verify the required parameter 'account_id' is set 4269 if ('account_id' not in params) or (params['account_id'] is None): 4270 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_correct_view`") 4271 # verify the required parameter 'envelope_id' is set 4272 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4273 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_envelope_correct_view`") 4274 4275 4276 collection_formats = {} 4277 4278 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/correct'.replace('{format}', 'json') 4279 path_params = {} 4280 if 'account_id' in params: 4281 path_params['accountId'] = params['account_id'] 4282 if 'envelope_id' in params: 4283 path_params['envelopeId'] = params['envelope_id'] 4284 4285 query_params = {} 4286 4287 header_params = {} 4288 4289 form_params = [] 4290 local_var_files = {} 4291 4292 body_params = None 4293 if 'correct_view_request' in params: 4294 body_params = params['correct_view_request'] 4295 # HTTP header `Accept` 4296 header_params['Accept'] = self.api_client.\ 4297 select_header_accept(['application/json']) 4298 4299 # Authentication setting 4300 auth_settings = [] 4301 4302 return self.api_client.call_api(resource_path, 'DELETE', 4303 path_params, 4304 query_params, 4305 header_params, 4306 body=body_params, 4307 post_params=form_params, 4308 files=local_var_files, 4309 response_type=None, 4310 auth_settings=auth_settings, 4311 callback=params.get('callback'), 4312 _return_http_data_only=params.get('_return_http_data_only'), 4313 _preload_content=params.get('_preload_content', True), 4314 _request_timeout=params.get('_request_timeout'), 4315 collection_formats=collection_formats)
Revokes the correction view URL to the Envelope UI
Revokes the correction view URL to the Envelope UI.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_envelope_correct_view_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- CorrectViewRequest correct_view_request:
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_envelope_delayed_routing_definition(self, account_id, envelope_id, workflow_step_id, **kwargs)
4317 def delete_envelope_delayed_routing_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 4318 """ 4319 Deletes the delayed routing rules for the specified envelope workflow step. 4320 This method makes a synchronous HTTP request by default. To make an 4321 asynchronous HTTP request, please define a `callback` function 4322 to be invoked when receiving the response. 4323 >>> def callback_function(response): 4324 >>> pprint(response) 4325 >>> 4326 >>> thread = api.delete_envelope_delayed_routing_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 4327 4328 :param callback function: The callback function 4329 for asynchronous request. (optional) 4330 :param str account_id: The external account number (int) or account ID Guid. (required) 4331 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4332 :param str workflow_step_id: (required) 4333 :return: None 4334 If the method is called asynchronously, 4335 returns the request thread. 4336 """ 4337 kwargs['_return_http_data_only'] = True 4338 if kwargs.get('callback'): 4339 return self.delete_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 4340 else: 4341 (data) = self.delete_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 4342 return data
Deletes the delayed routing rules for the specified envelope workflow step.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_envelope_delayed_routing_definition(account_id, envelope_id, workflow_step_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str workflow_step_id: (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_envelope_delayed_routing_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs)
4344 def delete_envelope_delayed_routing_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 4345 """ 4346 Deletes the delayed routing rules for the specified envelope workflow step. 4347 This method makes a synchronous HTTP request by default. To make an 4348 asynchronous HTTP request, please define a `callback` function 4349 to be invoked when receiving the response. 4350 >>> def callback_function(response): 4351 >>> pprint(response) 4352 >>> 4353 >>> thread = api.delete_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 4354 4355 :param callback function: The callback function 4356 for asynchronous request. (optional) 4357 :param str account_id: The external account number (int) or account ID Guid. (required) 4358 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4359 :param str workflow_step_id: (required) 4360 :return: None 4361 If the method is called asynchronously, 4362 returns the request thread. 4363 """ 4364 4365 all_params = ['account_id', 'envelope_id', 'workflow_step_id'] 4366 all_params.append('callback') 4367 all_params.append('_return_http_data_only') 4368 all_params.append('_preload_content') 4369 all_params.append('_request_timeout') 4370 4371 params = locals() 4372 for key, val in iteritems(params['kwargs']): 4373 if key not in all_params: 4374 raise TypeError( 4375 "Got an unexpected keyword argument '%s'" 4376 " to method delete_envelope_delayed_routing_definition" % key 4377 ) 4378 params[key] = val 4379 del params['kwargs'] 4380 # verify the required parameter 'account_id' is set 4381 if ('account_id' not in params) or (params['account_id'] is None): 4382 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_delayed_routing_definition`") 4383 # verify the required parameter 'envelope_id' is set 4384 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4385 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_envelope_delayed_routing_definition`") 4386 # verify the required parameter 'workflow_step_id' is set 4387 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 4388 raise ValueError("Missing the required parameter `workflow_step_id` when calling `delete_envelope_delayed_routing_definition`") 4389 4390 4391 collection_formats = {} 4392 4393 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 4394 path_params = {} 4395 if 'account_id' in params: 4396 path_params['accountId'] = params['account_id'] 4397 if 'envelope_id' in params: 4398 path_params['envelopeId'] = params['envelope_id'] 4399 if 'workflow_step_id' in params: 4400 path_params['workflowStepId'] = params['workflow_step_id'] 4401 4402 query_params = {} 4403 4404 header_params = {} 4405 4406 form_params = [] 4407 local_var_files = {} 4408 4409 body_params = None 4410 # HTTP header `Accept` 4411 header_params['Accept'] = self.api_client.\ 4412 select_header_accept(['application/json']) 4413 4414 # Authentication setting 4415 auth_settings = [] 4416 4417 return self.api_client.call_api(resource_path, 'DELETE', 4418 path_params, 4419 query_params, 4420 header_params, 4421 body=body_params, 4422 post_params=form_params, 4423 files=local_var_files, 4424 response_type=None, 4425 auth_settings=auth_settings, 4426 callback=params.get('callback'), 4427 _return_http_data_only=params.get('_return_http_data_only'), 4428 _preload_content=params.get('_preload_content', True), 4429 _request_timeout=params.get('_request_timeout'), 4430 collection_formats=collection_formats)
Deletes the delayed routing rules for the specified envelope workflow step.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str workflow_step_id: (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_envelope_scheduled_sending_definition(self, account_id, envelope_id, **kwargs)
4432 def delete_envelope_scheduled_sending_definition(self, account_id, envelope_id, **kwargs): 4433 """ 4434 Deletes the scheduled sending rules for the envelope's workflow. 4435 This method makes a synchronous HTTP request by default. To make an 4436 asynchronous HTTP request, please define a `callback` function 4437 to be invoked when receiving the response. 4438 >>> def callback_function(response): 4439 >>> pprint(response) 4440 >>> 4441 >>> thread = api.delete_envelope_scheduled_sending_definition(account_id, envelope_id, callback=callback_function) 4442 4443 :param callback function: The callback function 4444 for asynchronous request. (optional) 4445 :param str account_id: The external account number (int) or account ID Guid. (required) 4446 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4447 :return: None 4448 If the method is called asynchronously, 4449 returns the request thread. 4450 """ 4451 kwargs['_return_http_data_only'] = True 4452 if kwargs.get('callback'): 4453 return self.delete_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 4454 else: 4455 (data) = self.delete_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 4456 return data
Deletes the scheduled sending rules for the envelope's workflow.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_envelope_scheduled_sending_definition(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_envelope_scheduled_sending_definition_with_http_info(self, account_id, envelope_id, **kwargs)
4458 def delete_envelope_scheduled_sending_definition_with_http_info(self, account_id, envelope_id, **kwargs): 4459 """ 4460 Deletes the scheduled sending rules for the envelope's workflow. 4461 This method makes a synchronous HTTP request by default. To make an 4462 asynchronous HTTP request, please define a `callback` function 4463 to be invoked when receiving the response. 4464 >>> def callback_function(response): 4465 >>> pprint(response) 4466 >>> 4467 >>> thread = api.delete_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, callback=callback_function) 4468 4469 :param callback function: The callback function 4470 for asynchronous request. (optional) 4471 :param str account_id: The external account number (int) or account ID Guid. (required) 4472 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4473 :return: None 4474 If the method is called asynchronously, 4475 returns the request thread. 4476 """ 4477 4478 all_params = ['account_id', 'envelope_id'] 4479 all_params.append('callback') 4480 all_params.append('_return_http_data_only') 4481 all_params.append('_preload_content') 4482 all_params.append('_request_timeout') 4483 4484 params = locals() 4485 for key, val in iteritems(params['kwargs']): 4486 if key not in all_params: 4487 raise TypeError( 4488 "Got an unexpected keyword argument '%s'" 4489 " to method delete_envelope_scheduled_sending_definition" % key 4490 ) 4491 params[key] = val 4492 del params['kwargs'] 4493 # verify the required parameter 'account_id' is set 4494 if ('account_id' not in params) or (params['account_id'] is None): 4495 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_scheduled_sending_definition`") 4496 # verify the required parameter 'envelope_id' is set 4497 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4498 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_envelope_scheduled_sending_definition`") 4499 4500 4501 collection_formats = {} 4502 4503 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/scheduledSending'.replace('{format}', 'json') 4504 path_params = {} 4505 if 'account_id' in params: 4506 path_params['accountId'] = params['account_id'] 4507 if 'envelope_id' in params: 4508 path_params['envelopeId'] = params['envelope_id'] 4509 4510 query_params = {} 4511 4512 header_params = {} 4513 4514 form_params = [] 4515 local_var_files = {} 4516 4517 body_params = None 4518 # HTTP header `Accept` 4519 header_params['Accept'] = self.api_client.\ 4520 select_header_accept(['application/json']) 4521 4522 # Authentication setting 4523 auth_settings = [] 4524 4525 return self.api_client.call_api(resource_path, 'DELETE', 4526 path_params, 4527 query_params, 4528 header_params, 4529 body=body_params, 4530 post_params=form_params, 4531 files=local_var_files, 4532 response_type=None, 4533 auth_settings=auth_settings, 4534 callback=params.get('callback'), 4535 _return_http_data_only=params.get('_return_http_data_only'), 4536 _preload_content=params.get('_preload_content', True), 4537 _request_timeout=params.get('_request_timeout'), 4538 collection_formats=collection_formats)
Deletes the scheduled sending rules for the envelope's workflow.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_envelope_transfer_rules(self, account_id, envelope_transfer_rule_id, **kwargs)
4540 def delete_envelope_transfer_rules(self, account_id, envelope_transfer_rule_id, **kwargs): 4541 """ 4542 Delete envelope transfer rules for an account. 4543 This method deletes an envelope transfer rule. **Note:** Only Administrators can delete envelope transfer rules. In addition, to use envelope transfer rules, the **Transfer Custody** feature must be enabled for your account. 4544 This method makes a synchronous HTTP request by default. To make an 4545 asynchronous HTTP request, please define a `callback` function 4546 to be invoked when receiving the response. 4547 >>> def callback_function(response): 4548 >>> pprint(response) 4549 >>> 4550 >>> thread = api.delete_envelope_transfer_rules(account_id, envelope_transfer_rule_id, callback=callback_function) 4551 4552 :param callback function: The callback function 4553 for asynchronous request. (optional) 4554 :param str account_id: The external account number (int) or account ID Guid. (required) 4555 :param str envelope_transfer_rule_id: (required) 4556 :return: None 4557 If the method is called asynchronously, 4558 returns the request thread. 4559 """ 4560 kwargs['_return_http_data_only'] = True 4561 if kwargs.get('callback'): 4562 return self.delete_envelope_transfer_rules_with_http_info(account_id, envelope_transfer_rule_id, **kwargs) 4563 else: 4564 (data) = self.delete_envelope_transfer_rules_with_http_info(account_id, envelope_transfer_rule_id, **kwargs) 4565 return data
Delete envelope transfer rules for an account.
This method deletes an envelope transfer rule. Note: Only Administrators can delete envelope transfer rules. In addition, to use envelope transfer rules, the Transfer Custody feature must be enabled for your account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_envelope_transfer_rules(account_id, envelope_transfer_rule_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_transfer_rule_id: (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_envelope_transfer_rules_with_http_info(self, account_id, envelope_transfer_rule_id, **kwargs)
4567 def delete_envelope_transfer_rules_with_http_info(self, account_id, envelope_transfer_rule_id, **kwargs): 4568 """ 4569 Delete envelope transfer rules for an account. 4570 This method deletes an envelope transfer rule. **Note:** Only Administrators can delete envelope transfer rules. In addition, to use envelope transfer rules, the **Transfer Custody** feature must be enabled for your account. 4571 This method makes a synchronous HTTP request by default. To make an 4572 asynchronous HTTP request, please define a `callback` function 4573 to be invoked when receiving the response. 4574 >>> def callback_function(response): 4575 >>> pprint(response) 4576 >>> 4577 >>> thread = api.delete_envelope_transfer_rules_with_http_info(account_id, envelope_transfer_rule_id, callback=callback_function) 4578 4579 :param callback function: The callback function 4580 for asynchronous request. (optional) 4581 :param str account_id: The external account number (int) or account ID Guid. (required) 4582 :param str envelope_transfer_rule_id: (required) 4583 :return: None 4584 If the method is called asynchronously, 4585 returns the request thread. 4586 """ 4587 4588 all_params = ['account_id', 'envelope_transfer_rule_id'] 4589 all_params.append('callback') 4590 all_params.append('_return_http_data_only') 4591 all_params.append('_preload_content') 4592 all_params.append('_request_timeout') 4593 4594 params = locals() 4595 for key, val in iteritems(params['kwargs']): 4596 if key not in all_params: 4597 raise TypeError( 4598 "Got an unexpected keyword argument '%s'" 4599 " to method delete_envelope_transfer_rules" % key 4600 ) 4601 params[key] = val 4602 del params['kwargs'] 4603 # verify the required parameter 'account_id' is set 4604 if ('account_id' not in params) or (params['account_id'] is None): 4605 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_transfer_rules`") 4606 # verify the required parameter 'envelope_transfer_rule_id' is set 4607 if ('envelope_transfer_rule_id' not in params) or (params['envelope_transfer_rule_id'] is None): 4608 raise ValueError("Missing the required parameter `envelope_transfer_rule_id` when calling `delete_envelope_transfer_rules`") 4609 4610 4611 collection_formats = {} 4612 4613 resource_path = '/v2.1/accounts/{accountId}/envelopes/transfer_rules/{envelopeTransferRuleId}'.replace('{format}', 'json') 4614 path_params = {} 4615 if 'account_id' in params: 4616 path_params['accountId'] = params['account_id'] 4617 if 'envelope_transfer_rule_id' in params: 4618 path_params['envelopeTransferRuleId'] = params['envelope_transfer_rule_id'] 4619 4620 query_params = {} 4621 4622 header_params = {} 4623 4624 form_params = [] 4625 local_var_files = {} 4626 4627 body_params = None 4628 # HTTP header `Accept` 4629 header_params['Accept'] = self.api_client.\ 4630 select_header_accept(['application/json']) 4631 4632 # Authentication setting 4633 auth_settings = [] 4634 4635 return self.api_client.call_api(resource_path, 'DELETE', 4636 path_params, 4637 query_params, 4638 header_params, 4639 body=body_params, 4640 post_params=form_params, 4641 files=local_var_files, 4642 response_type=None, 4643 auth_settings=auth_settings, 4644 callback=params.get('callback'), 4645 _return_http_data_only=params.get('_return_http_data_only'), 4646 _preload_content=params.get('_preload_content', True), 4647 _request_timeout=params.get('_request_timeout'), 4648 collection_formats=collection_formats)
Delete envelope transfer rules for an account.
This method deletes an envelope transfer rule. Note: Only Administrators can delete envelope transfer rules. In addition, to use envelope transfer rules, the Transfer Custody feature must be enabled for your account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_envelope_transfer_rules_with_http_info(account_id, envelope_transfer_rule_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_transfer_rule_id: (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_envelope_workflow_definition(self, account_id, envelope_id, **kwargs)
4650 def delete_envelope_workflow_definition(self, account_id, envelope_id, **kwargs): 4651 """ 4652 Delete the workflow definition for an envelope. 4653 Deletes the specified envelope's workflow definition if it has one. 4654 This method makes a synchronous HTTP request by default. To make an 4655 asynchronous HTTP request, please define a `callback` function 4656 to be invoked when receiving the response. 4657 >>> def callback_function(response): 4658 >>> pprint(response) 4659 >>> 4660 >>> thread = api.delete_envelope_workflow_definition(account_id, envelope_id, callback=callback_function) 4661 4662 :param callback function: The callback function 4663 for asynchronous request. (optional) 4664 :param str account_id: The external account number (int) or account ID Guid. (required) 4665 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4666 :return: None 4667 If the method is called asynchronously, 4668 returns the request thread. 4669 """ 4670 kwargs['_return_http_data_only'] = True 4671 if kwargs.get('callback'): 4672 return self.delete_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 4673 else: 4674 (data) = self.delete_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 4675 return data
Delete the workflow definition for an envelope.
Deletes the specified envelope's workflow definition if it has one.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_envelope_workflow_definition(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_envelope_workflow_definition_with_http_info(self, account_id, envelope_id, **kwargs)
4677 def delete_envelope_workflow_definition_with_http_info(self, account_id, envelope_id, **kwargs): 4678 """ 4679 Delete the workflow definition for an envelope. 4680 Deletes the specified envelope's workflow definition if it has one. 4681 This method makes a synchronous HTTP request by default. To make an 4682 asynchronous HTTP request, please define a `callback` function 4683 to be invoked when receiving the response. 4684 >>> def callback_function(response): 4685 >>> pprint(response) 4686 >>> 4687 >>> thread = api.delete_envelope_workflow_definition_with_http_info(account_id, envelope_id, callback=callback_function) 4688 4689 :param callback function: The callback function 4690 for asynchronous request. (optional) 4691 :param str account_id: The external account number (int) or account ID Guid. (required) 4692 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4693 :return: None 4694 If the method is called asynchronously, 4695 returns the request thread. 4696 """ 4697 4698 all_params = ['account_id', 'envelope_id'] 4699 all_params.append('callback') 4700 all_params.append('_return_http_data_only') 4701 all_params.append('_preload_content') 4702 all_params.append('_request_timeout') 4703 4704 params = locals() 4705 for key, val in iteritems(params['kwargs']): 4706 if key not in all_params: 4707 raise TypeError( 4708 "Got an unexpected keyword argument '%s'" 4709 " to method delete_envelope_workflow_definition" % key 4710 ) 4711 params[key] = val 4712 del params['kwargs'] 4713 # verify the required parameter 'account_id' is set 4714 if ('account_id' not in params) or (params['account_id'] is None): 4715 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_workflow_definition`") 4716 # verify the required parameter 'envelope_id' is set 4717 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4718 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_envelope_workflow_definition`") 4719 4720 4721 collection_formats = {} 4722 4723 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow'.replace('{format}', 'json') 4724 path_params = {} 4725 if 'account_id' in params: 4726 path_params['accountId'] = params['account_id'] 4727 if 'envelope_id' in params: 4728 path_params['envelopeId'] = params['envelope_id'] 4729 4730 query_params = {} 4731 4732 header_params = {} 4733 4734 form_params = [] 4735 local_var_files = {} 4736 4737 body_params = None 4738 # HTTP header `Accept` 4739 header_params['Accept'] = self.api_client.\ 4740 select_header_accept(['application/json']) 4741 4742 # Authentication setting 4743 auth_settings = [] 4744 4745 return self.api_client.call_api(resource_path, 'DELETE', 4746 path_params, 4747 query_params, 4748 header_params, 4749 body=body_params, 4750 post_params=form_params, 4751 files=local_var_files, 4752 response_type=None, 4753 auth_settings=auth_settings, 4754 callback=params.get('callback'), 4755 _return_http_data_only=params.get('_return_http_data_only'), 4756 _preload_content=params.get('_preload_content', True), 4757 _request_timeout=params.get('_request_timeout'), 4758 collection_formats=collection_formats)
Delete the workflow definition for an envelope.
Deletes the specified envelope's workflow definition if it has one.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_envelope_workflow_definition_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_envelope_workflow_step_definition(self, account_id, envelope_id, workflow_step_id, **kwargs)
4760 def delete_envelope_workflow_step_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 4761 """ 4762 Deletes the envelope workflow step definition for an envelope's workflow by step id. 4763 This method makes a synchronous HTTP request by default. To make an 4764 asynchronous HTTP request, please define a `callback` function 4765 to be invoked when receiving the response. 4766 >>> def callback_function(response): 4767 >>> pprint(response) 4768 >>> 4769 >>> thread = api.delete_envelope_workflow_step_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 4770 4771 :param callback function: The callback function 4772 for asynchronous request. (optional) 4773 :param str account_id: The external account number (int) or account ID Guid. (required) 4774 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4775 :param str workflow_step_id: (required) 4776 :return: None 4777 If the method is called asynchronously, 4778 returns the request thread. 4779 """ 4780 kwargs['_return_http_data_only'] = True 4781 if kwargs.get('callback'): 4782 return self.delete_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 4783 else: 4784 (data) = self.delete_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 4785 return data
Deletes the envelope workflow step definition for an envelope's workflow by step id.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_envelope_workflow_step_definition(account_id, envelope_id, workflow_step_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str workflow_step_id: (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_envelope_workflow_step_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs)
4787 def delete_envelope_workflow_step_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 4788 """ 4789 Deletes the envelope workflow step definition for an envelope's workflow by step id. 4790 This method makes a synchronous HTTP request by default. To make an 4791 asynchronous HTTP request, please define a `callback` function 4792 to be invoked when receiving the response. 4793 >>> def callback_function(response): 4794 >>> pprint(response) 4795 >>> 4796 >>> thread = api.delete_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 4797 4798 :param callback function: The callback function 4799 for asynchronous request. (optional) 4800 :param str account_id: The external account number (int) or account ID Guid. (required) 4801 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4802 :param str workflow_step_id: (required) 4803 :return: None 4804 If the method is called asynchronously, 4805 returns the request thread. 4806 """ 4807 4808 all_params = ['account_id', 'envelope_id', 'workflow_step_id'] 4809 all_params.append('callback') 4810 all_params.append('_return_http_data_only') 4811 all_params.append('_preload_content') 4812 all_params.append('_request_timeout') 4813 4814 params = locals() 4815 for key, val in iteritems(params['kwargs']): 4816 if key not in all_params: 4817 raise TypeError( 4818 "Got an unexpected keyword argument '%s'" 4819 " to method delete_envelope_workflow_step_definition" % key 4820 ) 4821 params[key] = val 4822 del params['kwargs'] 4823 # verify the required parameter 'account_id' is set 4824 if ('account_id' not in params) or (params['account_id'] is None): 4825 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_workflow_step_definition`") 4826 # verify the required parameter 'envelope_id' is set 4827 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4828 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_envelope_workflow_step_definition`") 4829 # verify the required parameter 'workflow_step_id' is set 4830 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 4831 raise ValueError("Missing the required parameter `workflow_step_id` when calling `delete_envelope_workflow_step_definition`") 4832 4833 4834 collection_formats = {} 4835 4836 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 4837 path_params = {} 4838 if 'account_id' in params: 4839 path_params['accountId'] = params['account_id'] 4840 if 'envelope_id' in params: 4841 path_params['envelopeId'] = params['envelope_id'] 4842 if 'workflow_step_id' in params: 4843 path_params['workflowStepId'] = params['workflow_step_id'] 4844 4845 query_params = {} 4846 4847 header_params = {} 4848 4849 form_params = [] 4850 local_var_files = {} 4851 4852 body_params = None 4853 # HTTP header `Accept` 4854 header_params['Accept'] = self.api_client.\ 4855 select_header_accept(['application/json']) 4856 4857 # Authentication setting 4858 auth_settings = [] 4859 4860 return self.api_client.call_api(resource_path, 'DELETE', 4861 path_params, 4862 query_params, 4863 header_params, 4864 body=body_params, 4865 post_params=form_params, 4866 files=local_var_files, 4867 response_type=None, 4868 auth_settings=auth_settings, 4869 callback=params.get('callback'), 4870 _return_http_data_only=params.get('_return_http_data_only'), 4871 _preload_content=params.get('_preload_content', True), 4872 _request_timeout=params.get('_request_timeout'), 4873 collection_formats=collection_formats)
Deletes the envelope workflow step definition for an envelope's workflow by step id.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str workflow_step_id: (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_lock(self, account_id, envelope_id, **kwargs)
4875 def delete_lock(self, account_id, envelope_id, **kwargs): 4876 """ 4877 Deletes an envelope lock. 4878 Deletes the lock from the specified envelope. The `X-DocuSign-Edit` header must be included in the request. 4879 This method makes a synchronous HTTP request by default. To make an 4880 asynchronous HTTP request, please define a `callback` function 4881 to be invoked when receiving the response. 4882 >>> def callback_function(response): 4883 >>> pprint(response) 4884 >>> 4885 >>> thread = api.delete_lock(account_id, envelope_id, callback=callback_function) 4886 4887 :param callback function: The callback function 4888 for asynchronous request. (optional) 4889 :param str account_id: The external account number (int) or account ID Guid. (required) 4890 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4891 :return: LockInformation 4892 If the method is called asynchronously, 4893 returns the request thread. 4894 """ 4895 kwargs['_return_http_data_only'] = True 4896 if kwargs.get('callback'): 4897 return self.delete_lock_with_http_info(account_id, envelope_id, **kwargs) 4898 else: 4899 (data) = self.delete_lock_with_http_info(account_id, envelope_id, **kwargs) 4900 return data
Deletes an envelope lock.
Deletes the lock from the specified envelope. The X-DocuSign-Edit header must be included in the request.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_lock(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
LockInformation If the method is called asynchronously, returns the request thread.
def
delete_lock_with_http_info(self, account_id, envelope_id, **kwargs)
4902 def delete_lock_with_http_info(self, account_id, envelope_id, **kwargs): 4903 """ 4904 Deletes an envelope lock. 4905 Deletes the lock from the specified envelope. The `X-DocuSign-Edit` header must be included in the request. 4906 This method makes a synchronous HTTP request by default. To make an 4907 asynchronous HTTP request, please define a `callback` function 4908 to be invoked when receiving the response. 4909 >>> def callback_function(response): 4910 >>> pprint(response) 4911 >>> 4912 >>> thread = api.delete_lock_with_http_info(account_id, envelope_id, callback=callback_function) 4913 4914 :param callback function: The callback function 4915 for asynchronous request. (optional) 4916 :param str account_id: The external account number (int) or account ID Guid. (required) 4917 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4918 :return: LockInformation 4919 If the method is called asynchronously, 4920 returns the request thread. 4921 """ 4922 4923 all_params = ['account_id', 'envelope_id'] 4924 all_params.append('callback') 4925 all_params.append('_return_http_data_only') 4926 all_params.append('_preload_content') 4927 all_params.append('_request_timeout') 4928 4929 params = locals() 4930 for key, val in iteritems(params['kwargs']): 4931 if key not in all_params: 4932 raise TypeError( 4933 "Got an unexpected keyword argument '%s'" 4934 " to method delete_lock" % key 4935 ) 4936 params[key] = val 4937 del params['kwargs'] 4938 # verify the required parameter 'account_id' is set 4939 if ('account_id' not in params) or (params['account_id'] is None): 4940 raise ValueError("Missing the required parameter `account_id` when calling `delete_lock`") 4941 # verify the required parameter 'envelope_id' is set 4942 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4943 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_lock`") 4944 4945 4946 collection_formats = {} 4947 4948 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/lock'.replace('{format}', 'json') 4949 path_params = {} 4950 if 'account_id' in params: 4951 path_params['accountId'] = params['account_id'] 4952 if 'envelope_id' in params: 4953 path_params['envelopeId'] = params['envelope_id'] 4954 4955 query_params = {} 4956 4957 header_params = {} 4958 4959 form_params = [] 4960 local_var_files = {} 4961 4962 body_params = None 4963 # HTTP header `Accept` 4964 header_params['Accept'] = self.api_client.\ 4965 select_header_accept(['application/json']) 4966 4967 # Authentication setting 4968 auth_settings = [] 4969 4970 return self.api_client.call_api(resource_path, 'DELETE', 4971 path_params, 4972 query_params, 4973 header_params, 4974 body=body_params, 4975 post_params=form_params, 4976 files=local_var_files, 4977 response_type='LockInformation', 4978 auth_settings=auth_settings, 4979 callback=params.get('callback'), 4980 _return_http_data_only=params.get('_return_http_data_only'), 4981 _preload_content=params.get('_preload_content', True), 4982 _request_timeout=params.get('_request_timeout'), 4983 collection_formats=collection_formats)
Deletes an envelope lock.
Deletes the lock from the specified envelope. The X-DocuSign-Edit header must be included in the request.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_lock_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
LockInformation If the method is called asynchronously, returns the request thread.
def
delete_recipient(self, account_id, envelope_id, recipient_id, **kwargs)
4985 def delete_recipient(self, account_id, envelope_id, recipient_id, **kwargs): 4986 """ 4987 Deletes a recipient from an envelope. 4988 Deletes the specified recipient file from the specified envelope. This cannot be used if the envelope has been sent. 4989 This method makes a synchronous HTTP request by default. To make an 4990 asynchronous HTTP request, please define a `callback` function 4991 to be invoked when receiving the response. 4992 >>> def callback_function(response): 4993 >>> pprint(response) 4994 >>> 4995 >>> thread = api.delete_recipient(account_id, envelope_id, recipient_id, callback=callback_function) 4996 4997 :param callback function: The callback function 4998 for asynchronous request. (optional) 4999 :param str account_id: The external account number (int) or account ID Guid. (required) 5000 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5001 :param str recipient_id: The ID of the recipient being accessed. (required) 5002 :return: Recipients 5003 If the method is called asynchronously, 5004 returns the request thread. 5005 """ 5006 kwargs['_return_http_data_only'] = True 5007 if kwargs.get('callback'): 5008 return self.delete_recipient_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 5009 else: 5010 (data) = self.delete_recipient_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 5011 return data
Deletes a recipient from an envelope.
Deletes the specified recipient file from the specified envelope. This cannot be used if the envelope has been sent.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_recipient(account_id, envelope_id, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
Returns
Recipients If the method is called asynchronously, returns the request thread.
def
delete_recipient_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs)
5013 def delete_recipient_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 5014 """ 5015 Deletes a recipient from an envelope. 5016 Deletes the specified recipient file from the specified envelope. This cannot be used if the envelope has been sent. 5017 This method makes a synchronous HTTP request by default. To make an 5018 asynchronous HTTP request, please define a `callback` function 5019 to be invoked when receiving the response. 5020 >>> def callback_function(response): 5021 >>> pprint(response) 5022 >>> 5023 >>> thread = api.delete_recipient_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 5024 5025 :param callback function: The callback function 5026 for asynchronous request. (optional) 5027 :param str account_id: The external account number (int) or account ID Guid. (required) 5028 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5029 :param str recipient_id: The ID of the recipient being accessed. (required) 5030 :return: Recipients 5031 If the method is called asynchronously, 5032 returns the request thread. 5033 """ 5034 5035 all_params = ['account_id', 'envelope_id', 'recipient_id'] 5036 all_params.append('callback') 5037 all_params.append('_return_http_data_only') 5038 all_params.append('_preload_content') 5039 all_params.append('_request_timeout') 5040 5041 params = locals() 5042 for key, val in iteritems(params['kwargs']): 5043 if key not in all_params: 5044 raise TypeError( 5045 "Got an unexpected keyword argument '%s'" 5046 " to method delete_recipient" % key 5047 ) 5048 params[key] = val 5049 del params['kwargs'] 5050 # verify the required parameter 'account_id' is set 5051 if ('account_id' not in params) or (params['account_id'] is None): 5052 raise ValueError("Missing the required parameter `account_id` when calling `delete_recipient`") 5053 # verify the required parameter 'envelope_id' is set 5054 if ('envelope_id' not in params) or (params['envelope_id'] is None): 5055 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_recipient`") 5056 # verify the required parameter 'recipient_id' is set 5057 if ('recipient_id' not in params) or (params['recipient_id'] is None): 5058 raise ValueError("Missing the required parameter `recipient_id` when calling `delete_recipient`") 5059 5060 5061 collection_formats = {} 5062 5063 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}'.replace('{format}', 'json') 5064 path_params = {} 5065 if 'account_id' in params: 5066 path_params['accountId'] = params['account_id'] 5067 if 'envelope_id' in params: 5068 path_params['envelopeId'] = params['envelope_id'] 5069 if 'recipient_id' in params: 5070 path_params['recipientId'] = params['recipient_id'] 5071 5072 query_params = {} 5073 5074 header_params = {} 5075 5076 form_params = [] 5077 local_var_files = {} 5078 5079 body_params = None 5080 # HTTP header `Accept` 5081 header_params['Accept'] = self.api_client.\ 5082 select_header_accept(['application/json']) 5083 5084 # Authentication setting 5085 auth_settings = [] 5086 5087 return self.api_client.call_api(resource_path, 'DELETE', 5088 path_params, 5089 query_params, 5090 header_params, 5091 body=body_params, 5092 post_params=form_params, 5093 files=local_var_files, 5094 response_type='Recipients', 5095 auth_settings=auth_settings, 5096 callback=params.get('callback'), 5097 _return_http_data_only=params.get('_return_http_data_only'), 5098 _preload_content=params.get('_preload_content', True), 5099 _request_timeout=params.get('_request_timeout'), 5100 collection_formats=collection_formats)
Deletes a recipient from an envelope.
Deletes the specified recipient file from the specified envelope. This cannot be used if the envelope has been sent.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_recipient_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
Returns
Recipients If the method is called asynchronously, returns the request thread.
def
delete_recipients(self, account_id, envelope_id, **kwargs)
5102 def delete_recipients(self, account_id, envelope_id, **kwargs): 5103 """ 5104 Deletes recipients from an envelope. 5105 Deletes one or more recipients from a draft or sent envelope. Recipients to be deleted are listed in the request, with the `recipientId` being used as the key for deleting recipients. If the envelope is `In Process`, meaning that it has been sent and has not been completed or voided, recipients that have completed their actions cannot be deleted. 5106 This method makes a synchronous HTTP request by default. To make an 5107 asynchronous HTTP request, please define a `callback` function 5108 to be invoked when receiving the response. 5109 >>> def callback_function(response): 5110 >>> pprint(response) 5111 >>> 5112 >>> thread = api.delete_recipients(account_id, envelope_id, callback=callback_function) 5113 5114 :param callback function: The callback function 5115 for asynchronous request. (optional) 5116 :param str account_id: The external account number (int) or account ID Guid. (required) 5117 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5118 :param Recipients recipients: 5119 :return: Recipients 5120 If the method is called asynchronously, 5121 returns the request thread. 5122 """ 5123 kwargs['_return_http_data_only'] = True 5124 if kwargs.get('callback'): 5125 return self.delete_recipients_with_http_info(account_id, envelope_id, **kwargs) 5126 else: 5127 (data) = self.delete_recipients_with_http_info(account_id, envelope_id, **kwargs) 5128 return data
Deletes recipients from an envelope.
Deletes one or more recipients from a draft or sent envelope. Recipients to be deleted are listed in the request, with the recipientId being used as the key for deleting recipients. If the envelope is In Process, meaning that it has been sent and has not been completed or voided, recipients that have completed their actions cannot be deleted.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_recipients(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- Recipients recipients:
Returns
Recipients If the method is called asynchronously, returns the request thread.
def
delete_recipients_with_http_info(self, account_id, envelope_id, **kwargs)
5130 def delete_recipients_with_http_info(self, account_id, envelope_id, **kwargs): 5131 """ 5132 Deletes recipients from an envelope. 5133 Deletes one or more recipients from a draft or sent envelope. Recipients to be deleted are listed in the request, with the `recipientId` being used as the key for deleting recipients. If the envelope is `In Process`, meaning that it has been sent and has not been completed or voided, recipients that have completed their actions cannot be deleted. 5134 This method makes a synchronous HTTP request by default. To make an 5135 asynchronous HTTP request, please define a `callback` function 5136 to be invoked when receiving the response. 5137 >>> def callback_function(response): 5138 >>> pprint(response) 5139 >>> 5140 >>> thread = api.delete_recipients_with_http_info(account_id, envelope_id, callback=callback_function) 5141 5142 :param callback function: The callback function 5143 for asynchronous request. (optional) 5144 :param str account_id: The external account number (int) or account ID Guid. (required) 5145 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5146 :param Recipients recipients: 5147 :return: Recipients 5148 If the method is called asynchronously, 5149 returns the request thread. 5150 """ 5151 5152 all_params = ['account_id', 'envelope_id', 'recipients'] 5153 all_params.append('callback') 5154 all_params.append('_return_http_data_only') 5155 all_params.append('_preload_content') 5156 all_params.append('_request_timeout') 5157 5158 params = locals() 5159 for key, val in iteritems(params['kwargs']): 5160 if key not in all_params: 5161 raise TypeError( 5162 "Got an unexpected keyword argument '%s'" 5163 " to method delete_recipients" % key 5164 ) 5165 params[key] = val 5166 del params['kwargs'] 5167 # verify the required parameter 'account_id' is set 5168 if ('account_id' not in params) or (params['account_id'] is None): 5169 raise ValueError("Missing the required parameter `account_id` when calling `delete_recipients`") 5170 # verify the required parameter 'envelope_id' is set 5171 if ('envelope_id' not in params) or (params['envelope_id'] is None): 5172 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_recipients`") 5173 5174 5175 collection_formats = {} 5176 5177 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients'.replace('{format}', 'json') 5178 path_params = {} 5179 if 'account_id' in params: 5180 path_params['accountId'] = params['account_id'] 5181 if 'envelope_id' in params: 5182 path_params['envelopeId'] = params['envelope_id'] 5183 5184 query_params = {} 5185 5186 header_params = {} 5187 5188 form_params = [] 5189 local_var_files = {} 5190 5191 body_params = None 5192 if 'recipients' in params: 5193 body_params = params['recipients'] 5194 # HTTP header `Accept` 5195 header_params['Accept'] = self.api_client.\ 5196 select_header_accept(['application/json']) 5197 5198 # Authentication setting 5199 auth_settings = [] 5200 5201 return self.api_client.call_api(resource_path, 'DELETE', 5202 path_params, 5203 query_params, 5204 header_params, 5205 body=body_params, 5206 post_params=form_params, 5207 files=local_var_files, 5208 response_type='Recipients', 5209 auth_settings=auth_settings, 5210 callback=params.get('callback'), 5211 _return_http_data_only=params.get('_return_http_data_only'), 5212 _preload_content=params.get('_preload_content', True), 5213 _request_timeout=params.get('_request_timeout'), 5214 collection_formats=collection_formats)
Deletes recipients from an envelope.
Deletes one or more recipients from a draft or sent envelope. Recipients to be deleted are listed in the request, with the recipientId being used as the key for deleting recipients. If the envelope is In Process, meaning that it has been sent and has not been completed or voided, recipients that have completed their actions cannot be deleted.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_recipients_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- Recipients recipients:
Returns
Recipients If the method is called asynchronously, returns the request thread.
def
delete_tabs(self, account_id, envelope_id, recipient_id, **kwargs)
5216 def delete_tabs(self, account_id, envelope_id, recipient_id, **kwargs): 5217 """ 5218 Deletes the tabs associated with a recipient. 5219 Deletes one or more tabs associated with a recipient in a draft envelope. 5220 This method makes a synchronous HTTP request by default. To make an 5221 asynchronous HTTP request, please define a `callback` function 5222 to be invoked when receiving the response. 5223 >>> def callback_function(response): 5224 >>> pprint(response) 5225 >>> 5226 >>> thread = api.delete_tabs(account_id, envelope_id, recipient_id, callback=callback_function) 5227 5228 :param callback function: The callback function 5229 for asynchronous request. (optional) 5230 :param str account_id: The external account number (int) or account ID Guid. (required) 5231 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5232 :param str recipient_id: The ID of the recipient being accessed. (required) 5233 :param Tabs tabs: 5234 :return: Tabs 5235 If the method is called asynchronously, 5236 returns the request thread. 5237 """ 5238 kwargs['_return_http_data_only'] = True 5239 if kwargs.get('callback'): 5240 return self.delete_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 5241 else: 5242 (data) = self.delete_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 5243 return data
Deletes the tabs associated with a recipient.
Deletes one or more tabs associated with a recipient in a draft envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_tabs(account_id, envelope_id, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
- Tabs tabs:
Returns
Tabs If the method is called asynchronously, returns the request thread.
def
delete_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs)
5245 def delete_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 5246 """ 5247 Deletes the tabs associated with a recipient. 5248 Deletes one or more tabs associated with a recipient in a draft envelope. 5249 This method makes a synchronous HTTP request by default. To make an 5250 asynchronous HTTP request, please define a `callback` function 5251 to be invoked when receiving the response. 5252 >>> def callback_function(response): 5253 >>> pprint(response) 5254 >>> 5255 >>> thread = api.delete_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 5256 5257 :param callback function: The callback function 5258 for asynchronous request. (optional) 5259 :param str account_id: The external account number (int) or account ID Guid. (required) 5260 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5261 :param str recipient_id: The ID of the recipient being accessed. (required) 5262 :param Tabs tabs: 5263 :return: Tabs 5264 If the method is called asynchronously, 5265 returns the request thread. 5266 """ 5267 5268 all_params = ['account_id', 'envelope_id', 'recipient_id', 'tabs'] 5269 all_params.append('callback') 5270 all_params.append('_return_http_data_only') 5271 all_params.append('_preload_content') 5272 all_params.append('_request_timeout') 5273 5274 params = locals() 5275 for key, val in iteritems(params['kwargs']): 5276 if key not in all_params: 5277 raise TypeError( 5278 "Got an unexpected keyword argument '%s'" 5279 " to method delete_tabs" % key 5280 ) 5281 params[key] = val 5282 del params['kwargs'] 5283 # verify the required parameter 'account_id' is set 5284 if ('account_id' not in params) or (params['account_id'] is None): 5285 raise ValueError("Missing the required parameter `account_id` when calling `delete_tabs`") 5286 # verify the required parameter 'envelope_id' is set 5287 if ('envelope_id' not in params) or (params['envelope_id'] is None): 5288 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_tabs`") 5289 # verify the required parameter 'recipient_id' is set 5290 if ('recipient_id' not in params) or (params['recipient_id'] is None): 5291 raise ValueError("Missing the required parameter `recipient_id` when calling `delete_tabs`") 5292 5293 5294 collection_formats = {} 5295 5296 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/tabs'.replace('{format}', 'json') 5297 path_params = {} 5298 if 'account_id' in params: 5299 path_params['accountId'] = params['account_id'] 5300 if 'envelope_id' in params: 5301 path_params['envelopeId'] = params['envelope_id'] 5302 if 'recipient_id' in params: 5303 path_params['recipientId'] = params['recipient_id'] 5304 5305 query_params = {} 5306 5307 header_params = {} 5308 5309 form_params = [] 5310 local_var_files = {} 5311 5312 body_params = None 5313 if 'tabs' in params: 5314 body_params = params['tabs'] 5315 # HTTP header `Accept` 5316 header_params['Accept'] = self.api_client.\ 5317 select_header_accept(['application/json']) 5318 5319 # Authentication setting 5320 auth_settings = [] 5321 5322 return self.api_client.call_api(resource_path, 'DELETE', 5323 path_params, 5324 query_params, 5325 header_params, 5326 body=body_params, 5327 post_params=form_params, 5328 files=local_var_files, 5329 response_type='Tabs', 5330 auth_settings=auth_settings, 5331 callback=params.get('callback'), 5332 _return_http_data_only=params.get('_return_http_data_only'), 5333 _preload_content=params.get('_preload_content', True), 5334 _request_timeout=params.get('_request_timeout'), 5335 collection_formats=collection_formats)
Deletes the tabs associated with a recipient.
Deletes one or more tabs associated with a recipient in a draft envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
- Tabs tabs:
Returns
Tabs If the method is called asynchronously, returns the request thread.
def
delete_template_delayed_routing_definition(self, account_id, template_id, workflow_step_id, **kwargs)
5337 def delete_template_delayed_routing_definition(self, account_id, template_id, workflow_step_id, **kwargs): 5338 """ 5339 Deletes the delayed routing rules for the specified template workflow step. 5340 This method makes a synchronous HTTP request by default. To make an 5341 asynchronous HTTP request, please define a `callback` function 5342 to be invoked when receiving the response. 5343 >>> def callback_function(response): 5344 >>> pprint(response) 5345 >>> 5346 >>> thread = api.delete_template_delayed_routing_definition(account_id, template_id, workflow_step_id, callback=callback_function) 5347 5348 :param callback function: The callback function 5349 for asynchronous request. (optional) 5350 :param str account_id: The external account number (int) or account ID Guid. (required) 5351 :param str template_id: The ID of the template being accessed. (required) 5352 :param str workflow_step_id: (required) 5353 :return: None 5354 If the method is called asynchronously, 5355 returns the request thread. 5356 """ 5357 kwargs['_return_http_data_only'] = True 5358 if kwargs.get('callback'): 5359 return self.delete_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 5360 else: 5361 (data) = self.delete_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 5362 return data
Deletes the delayed routing rules for the specified template workflow step.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_template_delayed_routing_definition(account_id, template_id, workflow_step_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str template_id: The ID of the template being accessed. (required)
- str workflow_step_id: (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_template_delayed_routing_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs)
5364 def delete_template_delayed_routing_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 5365 """ 5366 Deletes the delayed routing rules for the specified template workflow step. 5367 This method makes a synchronous HTTP request by default. To make an 5368 asynchronous HTTP request, please define a `callback` function 5369 to be invoked when receiving the response. 5370 >>> def callback_function(response): 5371 >>> pprint(response) 5372 >>> 5373 >>> thread = api.delete_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 5374 5375 :param callback function: The callback function 5376 for asynchronous request. (optional) 5377 :param str account_id: The external account number (int) or account ID Guid. (required) 5378 :param str template_id: The ID of the template being accessed. (required) 5379 :param str workflow_step_id: (required) 5380 :return: None 5381 If the method is called asynchronously, 5382 returns the request thread. 5383 """ 5384 5385 all_params = ['account_id', 'template_id', 'workflow_step_id'] 5386 all_params.append('callback') 5387 all_params.append('_return_http_data_only') 5388 all_params.append('_preload_content') 5389 all_params.append('_request_timeout') 5390 5391 params = locals() 5392 for key, val in iteritems(params['kwargs']): 5393 if key not in all_params: 5394 raise TypeError( 5395 "Got an unexpected keyword argument '%s'" 5396 " to method delete_template_delayed_routing_definition" % key 5397 ) 5398 params[key] = val 5399 del params['kwargs'] 5400 # verify the required parameter 'account_id' is set 5401 if ('account_id' not in params) or (params['account_id'] is None): 5402 raise ValueError("Missing the required parameter `account_id` when calling `delete_template_delayed_routing_definition`") 5403 # verify the required parameter 'template_id' is set 5404 if ('template_id' not in params) or (params['template_id'] is None): 5405 raise ValueError("Missing the required parameter `template_id` when calling `delete_template_delayed_routing_definition`") 5406 # verify the required parameter 'workflow_step_id' is set 5407 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 5408 raise ValueError("Missing the required parameter `workflow_step_id` when calling `delete_template_delayed_routing_definition`") 5409 5410 5411 collection_formats = {} 5412 5413 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 5414 path_params = {} 5415 if 'account_id' in params: 5416 path_params['accountId'] = params['account_id'] 5417 if 'template_id' in params: 5418 path_params['templateId'] = params['template_id'] 5419 if 'workflow_step_id' in params: 5420 path_params['workflowStepId'] = params['workflow_step_id'] 5421 5422 query_params = {} 5423 5424 header_params = {} 5425 5426 form_params = [] 5427 local_var_files = {} 5428 5429 body_params = None 5430 # HTTP header `Accept` 5431 header_params['Accept'] = self.api_client.\ 5432 select_header_accept(['application/json']) 5433 5434 # Authentication setting 5435 auth_settings = [] 5436 5437 return self.api_client.call_api(resource_path, 'DELETE', 5438 path_params, 5439 query_params, 5440 header_params, 5441 body=body_params, 5442 post_params=form_params, 5443 files=local_var_files, 5444 response_type=None, 5445 auth_settings=auth_settings, 5446 callback=params.get('callback'), 5447 _return_http_data_only=params.get('_return_http_data_only'), 5448 _preload_content=params.get('_preload_content', True), 5449 _request_timeout=params.get('_request_timeout'), 5450 collection_formats=collection_formats)
Deletes the delayed routing rules for the specified template workflow step.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str template_id: The ID of the template being accessed. (required)
- str workflow_step_id: (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_template_scheduled_sending_definition(self, account_id, template_id, **kwargs)
5452 def delete_template_scheduled_sending_definition(self, account_id, template_id, **kwargs): 5453 """ 5454 Deletes the scheduled sending rules for the template's workflow. 5455 This method makes a synchronous HTTP request by default. To make an 5456 asynchronous HTTP request, please define a `callback` function 5457 to be invoked when receiving the response. 5458 >>> def callback_function(response): 5459 >>> pprint(response) 5460 >>> 5461 >>> thread = api.delete_template_scheduled_sending_definition(account_id, template_id, callback=callback_function) 5462 5463 :param callback function: The callback function 5464 for asynchronous request. (optional) 5465 :param str account_id: The external account number (int) or account ID Guid. (required) 5466 :param str template_id: The ID of the template being accessed. (required) 5467 :return: None 5468 If the method is called asynchronously, 5469 returns the request thread. 5470 """ 5471 kwargs['_return_http_data_only'] = True 5472 if kwargs.get('callback'): 5473 return self.delete_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 5474 else: 5475 (data) = self.delete_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 5476 return data
Deletes the scheduled sending rules for the template's workflow.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_template_scheduled_sending_definition(account_id, template_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str template_id: The ID of the template being accessed. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_template_scheduled_sending_definition_with_http_info(self, account_id, template_id, **kwargs)
5478 def delete_template_scheduled_sending_definition_with_http_info(self, account_id, template_id, **kwargs): 5479 """ 5480 Deletes the scheduled sending rules for the template's workflow. 5481 This method makes a synchronous HTTP request by default. To make an 5482 asynchronous HTTP request, please define a `callback` function 5483 to be invoked when receiving the response. 5484 >>> def callback_function(response): 5485 >>> pprint(response) 5486 >>> 5487 >>> thread = api.delete_template_scheduled_sending_definition_with_http_info(account_id, template_id, callback=callback_function) 5488 5489 :param callback function: The callback function 5490 for asynchronous request. (optional) 5491 :param str account_id: The external account number (int) or account ID Guid. (required) 5492 :param str template_id: The ID of the template being accessed. (required) 5493 :return: None 5494 If the method is called asynchronously, 5495 returns the request thread. 5496 """ 5497 5498 all_params = ['account_id', 'template_id'] 5499 all_params.append('callback') 5500 all_params.append('_return_http_data_only') 5501 all_params.append('_preload_content') 5502 all_params.append('_request_timeout') 5503 5504 params = locals() 5505 for key, val in iteritems(params['kwargs']): 5506 if key not in all_params: 5507 raise TypeError( 5508 "Got an unexpected keyword argument '%s'" 5509 " to method delete_template_scheduled_sending_definition" % key 5510 ) 5511 params[key] = val 5512 del params['kwargs'] 5513 # verify the required parameter 'account_id' is set 5514 if ('account_id' not in params) or (params['account_id'] is None): 5515 raise ValueError("Missing the required parameter `account_id` when calling `delete_template_scheduled_sending_definition`") 5516 # verify the required parameter 'template_id' is set 5517 if ('template_id' not in params) or (params['template_id'] is None): 5518 raise ValueError("Missing the required parameter `template_id` when calling `delete_template_scheduled_sending_definition`") 5519 5520 5521 collection_formats = {} 5522 5523 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/scheduledSending'.replace('{format}', 'json') 5524 path_params = {} 5525 if 'account_id' in params: 5526 path_params['accountId'] = params['account_id'] 5527 if 'template_id' in params: 5528 path_params['templateId'] = params['template_id'] 5529 5530 query_params = {} 5531 5532 header_params = {} 5533 5534 form_params = [] 5535 local_var_files = {} 5536 5537 body_params = None 5538 # HTTP header `Accept` 5539 header_params['Accept'] = self.api_client.\ 5540 select_header_accept(['application/json']) 5541 5542 # Authentication setting 5543 auth_settings = [] 5544 5545 return self.api_client.call_api(resource_path, 'DELETE', 5546 path_params, 5547 query_params, 5548 header_params, 5549 body=body_params, 5550 post_params=form_params, 5551 files=local_var_files, 5552 response_type=None, 5553 auth_settings=auth_settings, 5554 callback=params.get('callback'), 5555 _return_http_data_only=params.get('_return_http_data_only'), 5556 _preload_content=params.get('_preload_content', True), 5557 _request_timeout=params.get('_request_timeout'), 5558 collection_formats=collection_formats)
Deletes the scheduled sending rules for the template's workflow.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_template_scheduled_sending_definition_with_http_info(account_id, template_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str template_id: The ID of the template being accessed. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_template_workflow_definition(self, account_id, template_id, **kwargs)
5560 def delete_template_workflow_definition(self, account_id, template_id, **kwargs): 5561 """ 5562 Delete the workflow definition for a template. 5563 Deletes the specified template's workflow definition if it has one. 5564 This method makes a synchronous HTTP request by default. To make an 5565 asynchronous HTTP request, please define a `callback` function 5566 to be invoked when receiving the response. 5567 >>> def callback_function(response): 5568 >>> pprint(response) 5569 >>> 5570 >>> thread = api.delete_template_workflow_definition(account_id, template_id, callback=callback_function) 5571 5572 :param callback function: The callback function 5573 for asynchronous request. (optional) 5574 :param str account_id: The external account number (int) or account ID Guid. (required) 5575 :param str template_id: The ID of the template being accessed. (required) 5576 :return: None 5577 If the method is called asynchronously, 5578 returns the request thread. 5579 """ 5580 kwargs['_return_http_data_only'] = True 5581 if kwargs.get('callback'): 5582 return self.delete_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 5583 else: 5584 (data) = self.delete_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 5585 return data
Delete the workflow definition for a template.
Deletes the specified template's workflow definition if it has one.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_template_workflow_definition(account_id, template_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str template_id: The ID of the template being accessed. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_template_workflow_definition_with_http_info(self, account_id, template_id, **kwargs)
5587 def delete_template_workflow_definition_with_http_info(self, account_id, template_id, **kwargs): 5588 """ 5589 Delete the workflow definition for a template. 5590 Deletes the specified template's workflow definition if it has one. 5591 This method makes a synchronous HTTP request by default. To make an 5592 asynchronous HTTP request, please define a `callback` function 5593 to be invoked when receiving the response. 5594 >>> def callback_function(response): 5595 >>> pprint(response) 5596 >>> 5597 >>> thread = api.delete_template_workflow_definition_with_http_info(account_id, template_id, callback=callback_function) 5598 5599 :param callback function: The callback function 5600 for asynchronous request. (optional) 5601 :param str account_id: The external account number (int) or account ID Guid. (required) 5602 :param str template_id: The ID of the template being accessed. (required) 5603 :return: None 5604 If the method is called asynchronously, 5605 returns the request thread. 5606 """ 5607 5608 all_params = ['account_id', 'template_id'] 5609 all_params.append('callback') 5610 all_params.append('_return_http_data_only') 5611 all_params.append('_preload_content') 5612 all_params.append('_request_timeout') 5613 5614 params = locals() 5615 for key, val in iteritems(params['kwargs']): 5616 if key not in all_params: 5617 raise TypeError( 5618 "Got an unexpected keyword argument '%s'" 5619 " to method delete_template_workflow_definition" % key 5620 ) 5621 params[key] = val 5622 del params['kwargs'] 5623 # verify the required parameter 'account_id' is set 5624 if ('account_id' not in params) or (params['account_id'] is None): 5625 raise ValueError("Missing the required parameter `account_id` when calling `delete_template_workflow_definition`") 5626 # verify the required parameter 'template_id' is set 5627 if ('template_id' not in params) or (params['template_id'] is None): 5628 raise ValueError("Missing the required parameter `template_id` when calling `delete_template_workflow_definition`") 5629 5630 5631 collection_formats = {} 5632 5633 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow'.replace('{format}', 'json') 5634 path_params = {} 5635 if 'account_id' in params: 5636 path_params['accountId'] = params['account_id'] 5637 if 'template_id' in params: 5638 path_params['templateId'] = params['template_id'] 5639 5640 query_params = {} 5641 5642 header_params = {} 5643 5644 form_params = [] 5645 local_var_files = {} 5646 5647 body_params = None 5648 # HTTP header `Accept` 5649 header_params['Accept'] = self.api_client.\ 5650 select_header_accept(['application/json']) 5651 5652 # Authentication setting 5653 auth_settings = [] 5654 5655 return self.api_client.call_api(resource_path, 'DELETE', 5656 path_params, 5657 query_params, 5658 header_params, 5659 body=body_params, 5660 post_params=form_params, 5661 files=local_var_files, 5662 response_type=None, 5663 auth_settings=auth_settings, 5664 callback=params.get('callback'), 5665 _return_http_data_only=params.get('_return_http_data_only'), 5666 _preload_content=params.get('_preload_content', True), 5667 _request_timeout=params.get('_request_timeout'), 5668 collection_formats=collection_formats)
Delete the workflow definition for a template.
Deletes the specified template's workflow definition if it has one.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_template_workflow_definition_with_http_info(account_id, template_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str template_id: The ID of the template being accessed. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_template_workflow_step_definition(self, account_id, template_id, workflow_step_id, **kwargs)
5670 def delete_template_workflow_step_definition(self, account_id, template_id, workflow_step_id, **kwargs): 5671 """ 5672 Deletes the workflow step definition for an template's workflow by step id. 5673 This method makes a synchronous HTTP request by default. To make an 5674 asynchronous HTTP request, please define a `callback` function 5675 to be invoked when receiving the response. 5676 >>> def callback_function(response): 5677 >>> pprint(response) 5678 >>> 5679 >>> thread = api.delete_template_workflow_step_definition(account_id, template_id, workflow_step_id, callback=callback_function) 5680 5681 :param callback function: The callback function 5682 for asynchronous request. (optional) 5683 :param str account_id: The external account number (int) or account ID Guid. (required) 5684 :param str template_id: The ID of the template being accessed. (required) 5685 :param str workflow_step_id: (required) 5686 :return: None 5687 If the method is called asynchronously, 5688 returns the request thread. 5689 """ 5690 kwargs['_return_http_data_only'] = True 5691 if kwargs.get('callback'): 5692 return self.delete_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 5693 else: 5694 (data) = self.delete_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 5695 return data
Deletes the workflow step definition for an template's workflow by step id.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_template_workflow_step_definition(account_id, template_id, workflow_step_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str template_id: The ID of the template being accessed. (required)
- str workflow_step_id: (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_template_workflow_step_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs)
5697 def delete_template_workflow_step_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 5698 """ 5699 Deletes the workflow step definition for an template's workflow by step id. 5700 This method makes a synchronous HTTP request by default. To make an 5701 asynchronous HTTP request, please define a `callback` function 5702 to be invoked when receiving the response. 5703 >>> def callback_function(response): 5704 >>> pprint(response) 5705 >>> 5706 >>> thread = api.delete_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 5707 5708 :param callback function: The callback function 5709 for asynchronous request. (optional) 5710 :param str account_id: The external account number (int) or account ID Guid. (required) 5711 :param str template_id: The ID of the template being accessed. (required) 5712 :param str workflow_step_id: (required) 5713 :return: None 5714 If the method is called asynchronously, 5715 returns the request thread. 5716 """ 5717 5718 all_params = ['account_id', 'template_id', 'workflow_step_id'] 5719 all_params.append('callback') 5720 all_params.append('_return_http_data_only') 5721 all_params.append('_preload_content') 5722 all_params.append('_request_timeout') 5723 5724 params = locals() 5725 for key, val in iteritems(params['kwargs']): 5726 if key not in all_params: 5727 raise TypeError( 5728 "Got an unexpected keyword argument '%s'" 5729 " to method delete_template_workflow_step_definition" % key 5730 ) 5731 params[key] = val 5732 del params['kwargs'] 5733 # verify the required parameter 'account_id' is set 5734 if ('account_id' not in params) or (params['account_id'] is None): 5735 raise ValueError("Missing the required parameter `account_id` when calling `delete_template_workflow_step_definition`") 5736 # verify the required parameter 'template_id' is set 5737 if ('template_id' not in params) or (params['template_id'] is None): 5738 raise ValueError("Missing the required parameter `template_id` when calling `delete_template_workflow_step_definition`") 5739 # verify the required parameter 'workflow_step_id' is set 5740 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 5741 raise ValueError("Missing the required parameter `workflow_step_id` when calling `delete_template_workflow_step_definition`") 5742 5743 5744 collection_formats = {} 5745 5746 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 5747 path_params = {} 5748 if 'account_id' in params: 5749 path_params['accountId'] = params['account_id'] 5750 if 'template_id' in params: 5751 path_params['templateId'] = params['template_id'] 5752 if 'workflow_step_id' in params: 5753 path_params['workflowStepId'] = params['workflow_step_id'] 5754 5755 query_params = {} 5756 5757 header_params = {} 5758 5759 form_params = [] 5760 local_var_files = {} 5761 5762 body_params = None 5763 # HTTP header `Accept` 5764 header_params['Accept'] = self.api_client.\ 5765 select_header_accept(['application/json']) 5766 5767 # Authentication setting 5768 auth_settings = [] 5769 5770 return self.api_client.call_api(resource_path, 'DELETE', 5771 path_params, 5772 query_params, 5773 header_params, 5774 body=body_params, 5775 post_params=form_params, 5776 files=local_var_files, 5777 response_type=None, 5778 auth_settings=auth_settings, 5779 callback=params.get('callback'), 5780 _return_http_data_only=params.get('_return_http_data_only'), 5781 _preload_content=params.get('_preload_content', True), 5782 _request_timeout=params.get('_request_timeout'), 5783 collection_formats=collection_formats)
Deletes the workflow step definition for an template's workflow by step id.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str template_id: The ID of the template being accessed. (required)
- str workflow_step_id: (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_templates_from_document(self, account_id, document_id, envelope_id, template_id, **kwargs)
5785 def delete_templates_from_document(self, account_id, document_id, envelope_id, template_id, **kwargs): 5786 """ 5787 Deletes a template from a document in an existing envelope. 5788 Deletes the specified template from a document in an existing envelope. 5789 This method makes a synchronous HTTP request by default. To make an 5790 asynchronous HTTP request, please define a `callback` function 5791 to be invoked when receiving the response. 5792 >>> def callback_function(response): 5793 >>> pprint(response) 5794 >>> 5795 >>> thread = api.delete_templates_from_document(account_id, document_id, envelope_id, template_id, callback=callback_function) 5796 5797 :param callback function: The callback function 5798 for asynchronous request. (optional) 5799 :param str account_id: The external account number (int) or account ID Guid. (required) 5800 :param str document_id: The ID of the document being accessed. (required) 5801 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5802 :param str template_id: The ID of the template being accessed. (required) 5803 :return: None 5804 If the method is called asynchronously, 5805 returns the request thread. 5806 """ 5807 kwargs['_return_http_data_only'] = True 5808 if kwargs.get('callback'): 5809 return self.delete_templates_from_document_with_http_info(account_id, document_id, envelope_id, template_id, **kwargs) 5810 else: 5811 (data) = self.delete_templates_from_document_with_http_info(account_id, document_id, envelope_id, template_id, **kwargs) 5812 return data
Deletes a template from a document in an existing envelope.
Deletes the specified template from a document in an existing envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_templates_from_document(account_id, document_id, envelope_id, template_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str template_id: The ID of the template being accessed. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_templates_from_document_with_http_info(self, account_id, document_id, envelope_id, template_id, **kwargs)
5814 def delete_templates_from_document_with_http_info(self, account_id, document_id, envelope_id, template_id, **kwargs): 5815 """ 5816 Deletes a template from a document in an existing envelope. 5817 Deletes the specified template from a document in an existing envelope. 5818 This method makes a synchronous HTTP request by default. To make an 5819 asynchronous HTTP request, please define a `callback` function 5820 to be invoked when receiving the response. 5821 >>> def callback_function(response): 5822 >>> pprint(response) 5823 >>> 5824 >>> thread = api.delete_templates_from_document_with_http_info(account_id, document_id, envelope_id, template_id, callback=callback_function) 5825 5826 :param callback function: The callback function 5827 for asynchronous request. (optional) 5828 :param str account_id: The external account number (int) or account ID Guid. (required) 5829 :param str document_id: The ID of the document being accessed. (required) 5830 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5831 :param str template_id: The ID of the template being accessed. (required) 5832 :return: None 5833 If the method is called asynchronously, 5834 returns the request thread. 5835 """ 5836 5837 all_params = ['account_id', 'document_id', 'envelope_id', 'template_id'] 5838 all_params.append('callback') 5839 all_params.append('_return_http_data_only') 5840 all_params.append('_preload_content') 5841 all_params.append('_request_timeout') 5842 5843 params = locals() 5844 for key, val in iteritems(params['kwargs']): 5845 if key not in all_params: 5846 raise TypeError( 5847 "Got an unexpected keyword argument '%s'" 5848 " to method delete_templates_from_document" % key 5849 ) 5850 params[key] = val 5851 del params['kwargs'] 5852 # verify the required parameter 'account_id' is set 5853 if ('account_id' not in params) or (params['account_id'] is None): 5854 raise ValueError("Missing the required parameter `account_id` when calling `delete_templates_from_document`") 5855 # verify the required parameter 'document_id' is set 5856 if ('document_id' not in params) or (params['document_id'] is None): 5857 raise ValueError("Missing the required parameter `document_id` when calling `delete_templates_from_document`") 5858 # verify the required parameter 'envelope_id' is set 5859 if ('envelope_id' not in params) or (params['envelope_id'] is None): 5860 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_templates_from_document`") 5861 # verify the required parameter 'template_id' is set 5862 if ('template_id' not in params) or (params['template_id'] is None): 5863 raise ValueError("Missing the required parameter `template_id` when calling `delete_templates_from_document`") 5864 5865 5866 collection_formats = {} 5867 5868 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/templates/{templateId}'.replace('{format}', 'json') 5869 path_params = {} 5870 if 'account_id' in params: 5871 path_params['accountId'] = params['account_id'] 5872 if 'document_id' in params: 5873 path_params['documentId'] = params['document_id'] 5874 if 'envelope_id' in params: 5875 path_params['envelopeId'] = params['envelope_id'] 5876 if 'template_id' in params: 5877 path_params['templateId'] = params['template_id'] 5878 5879 query_params = {} 5880 5881 header_params = {} 5882 5883 form_params = [] 5884 local_var_files = {} 5885 5886 body_params = None 5887 # HTTP header `Accept` 5888 header_params['Accept'] = self.api_client.\ 5889 select_header_accept(['application/json']) 5890 5891 # Authentication setting 5892 auth_settings = [] 5893 5894 return self.api_client.call_api(resource_path, 'DELETE', 5895 path_params, 5896 query_params, 5897 header_params, 5898 body=body_params, 5899 post_params=form_params, 5900 files=local_var_files, 5901 response_type=None, 5902 auth_settings=auth_settings, 5903 callback=params.get('callback'), 5904 _return_http_data_only=params.get('_return_http_data_only'), 5905 _preload_content=params.get('_preload_content', True), 5906 _request_timeout=params.get('_request_timeout'), 5907 collection_formats=collection_formats)
Deletes a template from a document in an existing envelope.
Deletes the specified template from a document in an existing envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_templates_from_document_with_http_info(account_id, document_id, envelope_id, template_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str template_id: The ID of the template being accessed. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
get_attachment(self, account_id, attachment_id, envelope_id, **kwargs)
5909 def get_attachment(self, account_id, attachment_id, envelope_id, **kwargs): 5910 """ 5911 Retrieves an attachment from the envelope. 5912 Retrieves an attachment from an envelope. 5913 This method makes a synchronous HTTP request by default. To make an 5914 asynchronous HTTP request, please define a `callback` function 5915 to be invoked when receiving the response. 5916 >>> def callback_function(response): 5917 >>> pprint(response) 5918 >>> 5919 >>> thread = api.get_attachment(account_id, attachment_id, envelope_id, callback=callback_function) 5920 5921 :param callback function: The callback function 5922 for asynchronous request. (optional) 5923 :param str account_id: The external account number (int) or account ID Guid. (required) 5924 :param str attachment_id: (required) 5925 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5926 :return: file 5927 If the method is called asynchronously, 5928 returns the request thread. 5929 """ 5930 kwargs['_return_http_data_only'] = True 5931 if kwargs.get('callback'): 5932 return self.get_attachment_with_http_info(account_id, attachment_id, envelope_id, **kwargs) 5933 else: 5934 (data) = self.get_attachment_with_http_info(account_id, attachment_id, envelope_id, **kwargs) 5935 return data
Retrieves an attachment from the envelope.
Retrieves an attachment from an envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_attachment(account_id, attachment_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str attachment_id: (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
file If the method is called asynchronously, returns the request thread.
def
get_attachment_with_http_info(self, account_id, attachment_id, envelope_id, **kwargs)
5937 def get_attachment_with_http_info(self, account_id, attachment_id, envelope_id, **kwargs): 5938 """ 5939 Retrieves an attachment from the envelope. 5940 Retrieves an attachment from an envelope. 5941 This method makes a synchronous HTTP request by default. To make an 5942 asynchronous HTTP request, please define a `callback` function 5943 to be invoked when receiving the response. 5944 >>> def callback_function(response): 5945 >>> pprint(response) 5946 >>> 5947 >>> thread = api.get_attachment_with_http_info(account_id, attachment_id, envelope_id, callback=callback_function) 5948 5949 :param callback function: The callback function 5950 for asynchronous request. (optional) 5951 :param str account_id: The external account number (int) or account ID Guid. (required) 5952 :param str attachment_id: (required) 5953 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5954 :return: file 5955 If the method is called asynchronously, 5956 returns the request thread. 5957 """ 5958 5959 all_params = ['account_id', 'attachment_id', 'envelope_id'] 5960 all_params.append('callback') 5961 all_params.append('_return_http_data_only') 5962 all_params.append('_preload_content') 5963 all_params.append('_request_timeout') 5964 5965 params = locals() 5966 for key, val in iteritems(params['kwargs']): 5967 if key not in all_params: 5968 raise TypeError( 5969 "Got an unexpected keyword argument '%s'" 5970 " to method get_attachment" % key 5971 ) 5972 params[key] = val 5973 del params['kwargs'] 5974 # verify the required parameter 'account_id' is set 5975 if ('account_id' not in params) or (params['account_id'] is None): 5976 raise ValueError("Missing the required parameter `account_id` when calling `get_attachment`") 5977 # verify the required parameter 'attachment_id' is set 5978 if ('attachment_id' not in params) or (params['attachment_id'] is None): 5979 raise ValueError("Missing the required parameter `attachment_id` when calling `get_attachment`") 5980 # verify the required parameter 'envelope_id' is set 5981 if ('envelope_id' not in params) or (params['envelope_id'] is None): 5982 raise ValueError("Missing the required parameter `envelope_id` when calling `get_attachment`") 5983 5984 5985 collection_formats = {} 5986 5987 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments/{attachmentId}'.replace('{format}', 'json') 5988 path_params = {} 5989 if 'account_id' in params: 5990 path_params['accountId'] = params['account_id'] 5991 if 'attachment_id' in params: 5992 path_params['attachmentId'] = params['attachment_id'] 5993 if 'envelope_id' in params: 5994 path_params['envelopeId'] = params['envelope_id'] 5995 5996 query_params = {} 5997 5998 header_params = {} 5999 6000 form_params = [] 6001 local_var_files = {} 6002 6003 body_params = None 6004 # HTTP header `Accept` 6005 header_params['Accept'] = self.api_client.\ 6006 select_header_accept(['application/octet-stream']) 6007 6008 # Authentication setting 6009 auth_settings = [] 6010 6011 return self.api_client.call_api(resource_path, 'GET', 6012 path_params, 6013 query_params, 6014 header_params, 6015 body=body_params, 6016 post_params=form_params, 6017 files=local_var_files, 6018 response_type='file', 6019 auth_settings=auth_settings, 6020 callback=params.get('callback'), 6021 _return_http_data_only=params.get('_return_http_data_only'), 6022 _preload_content=params.get('_preload_content', True), 6023 _request_timeout=params.get('_request_timeout'), 6024 collection_formats=collection_formats)
Retrieves an attachment from the envelope.
Retrieves an attachment from an envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_attachment_with_http_info(account_id, attachment_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str attachment_id: (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
file If the method is called asynchronously, returns the request thread.
def
get_attachments(self, account_id, envelope_id, **kwargs)
6026 def get_attachments(self, account_id, envelope_id, **kwargs): 6027 """ 6028 Returns a list of attachments associated with the specified envelope 6029 Returns a list of attachments associated with a specified envelope 6030 This method makes a synchronous HTTP request by default. To make an 6031 asynchronous HTTP request, please define a `callback` function 6032 to be invoked when receiving the response. 6033 >>> def callback_function(response): 6034 >>> pprint(response) 6035 >>> 6036 >>> thread = api.get_attachments(account_id, envelope_id, callback=callback_function) 6037 6038 :param callback function: The callback function 6039 for asynchronous request. (optional) 6040 :param str account_id: The external account number (int) or account ID Guid. (required) 6041 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6042 :return: EnvelopeAttachmentsResult 6043 If the method is called asynchronously, 6044 returns the request thread. 6045 """ 6046 kwargs['_return_http_data_only'] = True 6047 if kwargs.get('callback'): 6048 return self.get_attachments_with_http_info(account_id, envelope_id, **kwargs) 6049 else: 6050 (data) = self.get_attachments_with_http_info(account_id, envelope_id, **kwargs) 6051 return data
Returns a list of attachments associated with the specified envelope
Returns a list of attachments associated with a specified envelope
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_attachments(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
EnvelopeAttachmentsResult If the method is called asynchronously, returns the request thread.
def
get_attachments_with_http_info(self, account_id, envelope_id, **kwargs)
6053 def get_attachments_with_http_info(self, account_id, envelope_id, **kwargs): 6054 """ 6055 Returns a list of attachments associated with the specified envelope 6056 Returns a list of attachments associated with a specified envelope 6057 This method makes a synchronous HTTP request by default. To make an 6058 asynchronous HTTP request, please define a `callback` function 6059 to be invoked when receiving the response. 6060 >>> def callback_function(response): 6061 >>> pprint(response) 6062 >>> 6063 >>> thread = api.get_attachments_with_http_info(account_id, envelope_id, callback=callback_function) 6064 6065 :param callback function: The callback function 6066 for asynchronous request. (optional) 6067 :param str account_id: The external account number (int) or account ID Guid. (required) 6068 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6069 :return: EnvelopeAttachmentsResult 6070 If the method is called asynchronously, 6071 returns the request thread. 6072 """ 6073 6074 all_params = ['account_id', 'envelope_id'] 6075 all_params.append('callback') 6076 all_params.append('_return_http_data_only') 6077 all_params.append('_preload_content') 6078 all_params.append('_request_timeout') 6079 6080 params = locals() 6081 for key, val in iteritems(params['kwargs']): 6082 if key not in all_params: 6083 raise TypeError( 6084 "Got an unexpected keyword argument '%s'" 6085 " to method get_attachments" % key 6086 ) 6087 params[key] = val 6088 del params['kwargs'] 6089 # verify the required parameter 'account_id' is set 6090 if ('account_id' not in params) or (params['account_id'] is None): 6091 raise ValueError("Missing the required parameter `account_id` when calling `get_attachments`") 6092 # verify the required parameter 'envelope_id' is set 6093 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6094 raise ValueError("Missing the required parameter `envelope_id` when calling `get_attachments`") 6095 6096 6097 collection_formats = {} 6098 6099 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments'.replace('{format}', 'json') 6100 path_params = {} 6101 if 'account_id' in params: 6102 path_params['accountId'] = params['account_id'] 6103 if 'envelope_id' in params: 6104 path_params['envelopeId'] = params['envelope_id'] 6105 6106 query_params = {} 6107 6108 header_params = {} 6109 6110 form_params = [] 6111 local_var_files = {} 6112 6113 body_params = None 6114 # HTTP header `Accept` 6115 header_params['Accept'] = self.api_client.\ 6116 select_header_accept(['application/json']) 6117 6118 # Authentication setting 6119 auth_settings = [] 6120 6121 return self.api_client.call_api(resource_path, 'GET', 6122 path_params, 6123 query_params, 6124 header_params, 6125 body=body_params, 6126 post_params=form_params, 6127 files=local_var_files, 6128 response_type='EnvelopeAttachmentsResult', 6129 auth_settings=auth_settings, 6130 callback=params.get('callback'), 6131 _return_http_data_only=params.get('_return_http_data_only'), 6132 _preload_content=params.get('_preload_content', True), 6133 _request_timeout=params.get('_request_timeout'), 6134 collection_formats=collection_formats)
Returns a list of attachments associated with the specified envelope
Returns a list of attachments associated with a specified envelope
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_attachments_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
EnvelopeAttachmentsResult If the method is called asynchronously, returns the request thread.
def
get_chunked_upload(self, account_id, chunked_upload_id, **kwargs)
6136 def get_chunked_upload(self, account_id, chunked_upload_id, **kwargs): 6137 """ 6138 Retrieves the current metadata of a ChunkedUpload. 6139 Returns the details (but not the content) about a chunked upload. **Note:** You cannot obtain details about a chunked upload that has expired, been deleted, or consumed by other actions. 6140 This method makes a synchronous HTTP request by default. To make an 6141 asynchronous HTTP request, please define a `callback` function 6142 to be invoked when receiving the response. 6143 >>> def callback_function(response): 6144 >>> pprint(response) 6145 >>> 6146 >>> thread = api.get_chunked_upload(account_id, chunked_upload_id, callback=callback_function) 6147 6148 :param callback function: The callback function 6149 for asynchronous request. (optional) 6150 :param str account_id: The external account number (int) or account ID Guid. (required) 6151 :param str chunked_upload_id: (required) 6152 :param str include: 6153 :return: ChunkedUploadResponse 6154 If the method is called asynchronously, 6155 returns the request thread. 6156 """ 6157 kwargs['_return_http_data_only'] = True 6158 if kwargs.get('callback'): 6159 return self.get_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 6160 else: 6161 (data) = self.get_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 6162 return data
Retrieves the current metadata of a ChunkedUpload.
Returns the details (but not the content) about a chunked upload. Note: You cannot obtain details about a chunked upload that has expired, been deleted, or consumed by other actions.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_chunked_upload(account_id, chunked_upload_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str chunked_upload_id: (required)
- str include:
Returns
ChunkedUploadResponse If the method is called asynchronously, returns the request thread.
def
get_chunked_upload_with_http_info(self, account_id, chunked_upload_id, **kwargs)
6164 def get_chunked_upload_with_http_info(self, account_id, chunked_upload_id, **kwargs): 6165 """ 6166 Retrieves the current metadata of a ChunkedUpload. 6167 Returns the details (but not the content) about a chunked upload. **Note:** You cannot obtain details about a chunked upload that has expired, been deleted, or consumed by other actions. 6168 This method makes a synchronous HTTP request by default. To make an 6169 asynchronous HTTP request, please define a `callback` function 6170 to be invoked when receiving the response. 6171 >>> def callback_function(response): 6172 >>> pprint(response) 6173 >>> 6174 >>> thread = api.get_chunked_upload_with_http_info(account_id, chunked_upload_id, callback=callback_function) 6175 6176 :param callback function: The callback function 6177 for asynchronous request. (optional) 6178 :param str account_id: The external account number (int) or account ID Guid. (required) 6179 :param str chunked_upload_id: (required) 6180 :param str include: 6181 :return: ChunkedUploadResponse 6182 If the method is called asynchronously, 6183 returns the request thread. 6184 """ 6185 6186 all_params = ['account_id', 'chunked_upload_id', 'include'] 6187 all_params.append('callback') 6188 all_params.append('_return_http_data_only') 6189 all_params.append('_preload_content') 6190 all_params.append('_request_timeout') 6191 6192 params = locals() 6193 for key, val in iteritems(params['kwargs']): 6194 if key not in all_params: 6195 raise TypeError( 6196 "Got an unexpected keyword argument '%s'" 6197 " to method get_chunked_upload" % key 6198 ) 6199 params[key] = val 6200 del params['kwargs'] 6201 # verify the required parameter 'account_id' is set 6202 if ('account_id' not in params) or (params['account_id'] is None): 6203 raise ValueError("Missing the required parameter `account_id` when calling `get_chunked_upload`") 6204 # verify the required parameter 'chunked_upload_id' is set 6205 if ('chunked_upload_id' not in params) or (params['chunked_upload_id'] is None): 6206 raise ValueError("Missing the required parameter `chunked_upload_id` when calling `get_chunked_upload`") 6207 6208 6209 collection_formats = {} 6210 6211 resource_path = '/v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}'.replace('{format}', 'json') 6212 path_params = {} 6213 if 'account_id' in params: 6214 path_params['accountId'] = params['account_id'] 6215 if 'chunked_upload_id' in params: 6216 path_params['chunkedUploadId'] = params['chunked_upload_id'] 6217 6218 query_params = {} 6219 if 'include' in params: 6220 query_params['include'] = params['include'] 6221 6222 header_params = {} 6223 6224 form_params = [] 6225 local_var_files = {} 6226 6227 body_params = None 6228 # HTTP header `Accept` 6229 header_params['Accept'] = self.api_client.\ 6230 select_header_accept(['application/json']) 6231 6232 # Authentication setting 6233 auth_settings = [] 6234 6235 return self.api_client.call_api(resource_path, 'GET', 6236 path_params, 6237 query_params, 6238 header_params, 6239 body=body_params, 6240 post_params=form_params, 6241 files=local_var_files, 6242 response_type='ChunkedUploadResponse', 6243 auth_settings=auth_settings, 6244 callback=params.get('callback'), 6245 _return_http_data_only=params.get('_return_http_data_only'), 6246 _preload_content=params.get('_preload_content', True), 6247 _request_timeout=params.get('_request_timeout'), 6248 collection_formats=collection_formats)
Retrieves the current metadata of a ChunkedUpload.
Returns the details (but not the content) about a chunked upload. Note: You cannot obtain details about a chunked upload that has expired, been deleted, or consumed by other actions.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_chunked_upload_with_http_info(account_id, chunked_upload_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str chunked_upload_id: (required)
- str include:
Returns
ChunkedUploadResponse If the method is called asynchronously, returns the request thread.
def
get_comments_transcript(self, account_id, envelope_id, **kwargs)
6250 def get_comments_transcript(self, account_id, envelope_id, **kwargs): 6251 """ 6252 Gets comment transcript for envelope and user 6253 Retrieves a PDF file containing all of the comments that senders and recipients have added to the documents in an envelope. The response body of this method is the PDF file as a byte stream. **Note:** Comments are disabled by default. To use the comments feature, an account administrator must enable comments on the account (in the `accountSettingsInformation` object, set the `enableSigningExtensionComments` property to **true**). 6254 This method makes a synchronous HTTP request by default. To make an 6255 asynchronous HTTP request, please define a `callback` function 6256 to be invoked when receiving the response. 6257 >>> def callback_function(response): 6258 >>> pprint(response) 6259 >>> 6260 >>> thread = api.get_comments_transcript(account_id, envelope_id, callback=callback_function) 6261 6262 :param callback function: The callback function 6263 for asynchronous request. (optional) 6264 :param str account_id: The external account number (int) or account ID Guid. (required) 6265 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6266 :param str encoding: 6267 :return: file 6268 If the method is called asynchronously, 6269 returns the request thread. 6270 """ 6271 kwargs['_return_http_data_only'] = True 6272 if kwargs.get('callback'): 6273 return self.get_comments_transcript_with_http_info(account_id, envelope_id, **kwargs) 6274 else: 6275 (data) = self.get_comments_transcript_with_http_info(account_id, envelope_id, **kwargs) 6276 return data
Gets comment transcript for envelope and user
Retrieves a PDF file containing all of the comments that senders and recipients have added to the documents in an envelope. The response body of this method is the PDF file as a byte stream. Note: Comments are disabled by default. To use the comments feature, an account administrator must enable comments on the account (in the accountSettingsInformation object, set the enableSigningExtensionComments property to true).
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_comments_transcript(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str encoding:
Returns
file If the method is called asynchronously, returns the request thread.
def
get_comments_transcript_with_http_info(self, account_id, envelope_id, **kwargs)
6278 def get_comments_transcript_with_http_info(self, account_id, envelope_id, **kwargs): 6279 """ 6280 Gets comment transcript for envelope and user 6281 Retrieves a PDF file containing all of the comments that senders and recipients have added to the documents in an envelope. The response body of this method is the PDF file as a byte stream. **Note:** Comments are disabled by default. To use the comments feature, an account administrator must enable comments on the account (in the `accountSettingsInformation` object, set the `enableSigningExtensionComments` property to **true**). 6282 This method makes a synchronous HTTP request by default. To make an 6283 asynchronous HTTP request, please define a `callback` function 6284 to be invoked when receiving the response. 6285 >>> def callback_function(response): 6286 >>> pprint(response) 6287 >>> 6288 >>> thread = api.get_comments_transcript_with_http_info(account_id, envelope_id, callback=callback_function) 6289 6290 :param callback function: The callback function 6291 for asynchronous request. (optional) 6292 :param str account_id: The external account number (int) or account ID Guid. (required) 6293 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6294 :param str encoding: 6295 :return: file 6296 If the method is called asynchronously, 6297 returns the request thread. 6298 """ 6299 6300 all_params = ['account_id', 'envelope_id', 'encoding'] 6301 all_params.append('callback') 6302 all_params.append('_return_http_data_only') 6303 all_params.append('_preload_content') 6304 all_params.append('_request_timeout') 6305 6306 params = locals() 6307 for key, val in iteritems(params['kwargs']): 6308 if key not in all_params: 6309 raise TypeError( 6310 "Got an unexpected keyword argument '%s'" 6311 " to method get_comments_transcript" % key 6312 ) 6313 params[key] = val 6314 del params['kwargs'] 6315 # verify the required parameter 'account_id' is set 6316 if ('account_id' not in params) or (params['account_id'] is None): 6317 raise ValueError("Missing the required parameter `account_id` when calling `get_comments_transcript`") 6318 # verify the required parameter 'envelope_id' is set 6319 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6320 raise ValueError("Missing the required parameter `envelope_id` when calling `get_comments_transcript`") 6321 6322 6323 collection_formats = {} 6324 6325 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/comments/transcript'.replace('{format}', 'json') 6326 path_params = {} 6327 if 'account_id' in params: 6328 path_params['accountId'] = params['account_id'] 6329 if 'envelope_id' in params: 6330 path_params['envelopeId'] = params['envelope_id'] 6331 6332 query_params = {} 6333 if 'encoding' in params: 6334 query_params['encoding'] = params['encoding'] 6335 6336 header_params = {} 6337 6338 form_params = [] 6339 local_var_files = {} 6340 6341 body_params = None 6342 # HTTP header `Accept` 6343 header_params['Accept'] = self.api_client.\ 6344 select_header_accept(['application/pdf']) 6345 6346 # Authentication setting 6347 auth_settings = [] 6348 6349 return self.api_client.call_api(resource_path, 'GET', 6350 path_params, 6351 query_params, 6352 header_params, 6353 body=body_params, 6354 post_params=form_params, 6355 files=local_var_files, 6356 response_type='file', 6357 auth_settings=auth_settings, 6358 callback=params.get('callback'), 6359 _return_http_data_only=params.get('_return_http_data_only'), 6360 _preload_content=params.get('_preload_content', True), 6361 _request_timeout=params.get('_request_timeout'), 6362 collection_formats=collection_formats)
Gets comment transcript for envelope and user
Retrieves a PDF file containing all of the comments that senders and recipients have added to the documents in an envelope. The response body of this method is the PDF file as a byte stream. Note: Comments are disabled by default. To use the comments feature, an account administrator must enable comments on the account (in the accountSettingsInformation object, set the enableSigningExtensionComments property to true).
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_comments_transcript_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str encoding:
Returns
file If the method is called asynchronously, returns the request thread.
def
get_consumer_disclosure(self, account_id, envelope_id, lang_code, recipient_id, **kwargs)
6364 def get_consumer_disclosure(self, account_id, envelope_id, lang_code, recipient_id, **kwargs): 6365 """ 6366 Reserved: Gets the Electronic Record and Signature Disclosure associated with the account. 6367 Reserved: Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, associated with the account. 6368 This method makes a synchronous HTTP request by default. To make an 6369 asynchronous HTTP request, please define a `callback` function 6370 to be invoked when receiving the response. 6371 >>> def callback_function(response): 6372 >>> pprint(response) 6373 >>> 6374 >>> thread = api.get_consumer_disclosure(account_id, envelope_id, lang_code, recipient_id, callback=callback_function) 6375 6376 :param callback function: The callback function 6377 for asynchronous request. (optional) 6378 :param str account_id: The external account number (int) or account ID Guid. (required) 6379 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6380 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 6381 :param str recipient_id: The ID of the recipient being accessed. (required) 6382 :param str lang_code2: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. 6383 :return: ConsumerDisclosure 6384 If the method is called asynchronously, 6385 returns the request thread. 6386 """ 6387 kwargs['_return_http_data_only'] = True 6388 if kwargs.get('callback'): 6389 return self.get_consumer_disclosure_with_http_info(account_id, envelope_id, lang_code, recipient_id, **kwargs) 6390 else: 6391 (data) = self.get_consumer_disclosure_with_http_info(account_id, envelope_id, lang_code, recipient_id, **kwargs) 6392 return data
Reserved: Gets the Electronic Record and Signature Disclosure associated with the account.
Reserved: Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, associated with the account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_consumer_disclosure(account_id, envelope_id, lang_code, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are: Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
- str lang_code2: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are: Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language.
Returns
ConsumerDisclosure If the method is called asynchronously, returns the request thread.
def
get_consumer_disclosure_with_http_info(self, account_id, envelope_id, lang_code, recipient_id, **kwargs)
6394 def get_consumer_disclosure_with_http_info(self, account_id, envelope_id, lang_code, recipient_id, **kwargs): 6395 """ 6396 Reserved: Gets the Electronic Record and Signature Disclosure associated with the account. 6397 Reserved: Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, associated with the account. 6398 This method makes a synchronous HTTP request by default. To make an 6399 asynchronous HTTP request, please define a `callback` function 6400 to be invoked when receiving the response. 6401 >>> def callback_function(response): 6402 >>> pprint(response) 6403 >>> 6404 >>> thread = api.get_consumer_disclosure_with_http_info(account_id, envelope_id, lang_code, recipient_id, callback=callback_function) 6405 6406 :param callback function: The callback function 6407 for asynchronous request. (optional) 6408 :param str account_id: The external account number (int) or account ID Guid. (required) 6409 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6410 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 6411 :param str recipient_id: The ID of the recipient being accessed. (required) 6412 :param str lang_code2: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. 6413 :return: ConsumerDisclosure 6414 If the method is called asynchronously, 6415 returns the request thread. 6416 """ 6417 6418 all_params = ['account_id', 'envelope_id', 'lang_code', 'recipient_id', 'lang_code2'] 6419 all_params.append('callback') 6420 all_params.append('_return_http_data_only') 6421 all_params.append('_preload_content') 6422 all_params.append('_request_timeout') 6423 6424 params = locals() 6425 for key, val in iteritems(params['kwargs']): 6426 if key not in all_params: 6427 raise TypeError( 6428 "Got an unexpected keyword argument '%s'" 6429 " to method get_consumer_disclosure" % key 6430 ) 6431 params[key] = val 6432 del params['kwargs'] 6433 # verify the required parameter 'account_id' is set 6434 if ('account_id' not in params) or (params['account_id'] is None): 6435 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure`") 6436 # verify the required parameter 'envelope_id' is set 6437 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6438 raise ValueError("Missing the required parameter `envelope_id` when calling `get_consumer_disclosure`") 6439 # verify the required parameter 'lang_code' is set 6440 if ('lang_code' not in params) or (params['lang_code'] is None): 6441 raise ValueError("Missing the required parameter `lang_code` when calling `get_consumer_disclosure`") 6442 # verify the required parameter 'recipient_id' is set 6443 if ('recipient_id' not in params) or (params['recipient_id'] is None): 6444 raise ValueError("Missing the required parameter `recipient_id` when calling `get_consumer_disclosure`") 6445 6446 6447 collection_formats = {} 6448 6449 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 6450 path_params = {} 6451 if 'account_id' in params: 6452 path_params['accountId'] = params['account_id'] 6453 if 'envelope_id' in params: 6454 path_params['envelopeId'] = params['envelope_id'] 6455 if 'lang_code' in params: 6456 path_params['langCode'] = params['lang_code'] 6457 if 'recipient_id' in params: 6458 path_params['recipientId'] = params['recipient_id'] 6459 6460 query_params = {} 6461 if 'lang_code2' in params: 6462 query_params['langCode'] = params['lang_code2'] 6463 6464 header_params = {} 6465 6466 form_params = [] 6467 local_var_files = {} 6468 6469 body_params = None 6470 # HTTP header `Accept` 6471 header_params['Accept'] = self.api_client.\ 6472 select_header_accept(['application/json']) 6473 6474 # Authentication setting 6475 auth_settings = [] 6476 6477 return self.api_client.call_api(resource_path, 'GET', 6478 path_params, 6479 query_params, 6480 header_params, 6481 body=body_params, 6482 post_params=form_params, 6483 files=local_var_files, 6484 response_type='ConsumerDisclosure', 6485 auth_settings=auth_settings, 6486 callback=params.get('callback'), 6487 _return_http_data_only=params.get('_return_http_data_only'), 6488 _preload_content=params.get('_preload_content', True), 6489 _request_timeout=params.get('_request_timeout'), 6490 collection_formats=collection_formats)
Reserved: Gets the Electronic Record and Signature Disclosure associated with the account.
Reserved: Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, associated with the account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_consumer_disclosure_with_http_info(account_id, envelope_id, lang_code, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are: Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
- str lang_code2: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are: Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language.
Returns
ConsumerDisclosure If the method is called asynchronously, returns the request thread.
def
get_consumer_disclosure_default(self, account_id, envelope_id, recipient_id, **kwargs)
6492 def get_consumer_disclosure_default(self, account_id, envelope_id, recipient_id, **kwargs): 6493 """ 6494 Gets the Electronic Record and Signature Disclosure associated with the account. 6495 Retrieves the Electronic Record and Signature Disclosure, with html formatting, associated with the account. You can use an optional query string to set the language for the disclosure. 6496 This method makes a synchronous HTTP request by default. To make an 6497 asynchronous HTTP request, please define a `callback` function 6498 to be invoked when receiving the response. 6499 >>> def callback_function(response): 6500 >>> pprint(response) 6501 >>> 6502 >>> thread = api.get_consumer_disclosure_default(account_id, envelope_id, recipient_id, callback=callback_function) 6503 6504 :param callback function: The callback function 6505 for asynchronous request. (optional) 6506 :param str account_id: The external account number (int) or account ID Guid. (required) 6507 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6508 :param str recipient_id: The ID of the recipient being accessed. (required) 6509 :param str lang_code: 6510 :return: ConsumerDisclosure 6511 If the method is called asynchronously, 6512 returns the request thread. 6513 """ 6514 kwargs['_return_http_data_only'] = True 6515 if kwargs.get('callback'): 6516 return self.get_consumer_disclosure_default_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 6517 else: 6518 (data) = self.get_consumer_disclosure_default_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 6519 return data
Gets the Electronic Record and Signature Disclosure associated with the account.
Retrieves the Electronic Record and Signature Disclosure, with html formatting, associated with the account. You can use an optional query string to set the language for the disclosure.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_consumer_disclosure_default(account_id, envelope_id, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
- str lang_code:
Returns
ConsumerDisclosure If the method is called asynchronously, returns the request thread.
def
get_consumer_disclosure_default_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs)
6521 def get_consumer_disclosure_default_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 6522 """ 6523 Gets the Electronic Record and Signature Disclosure associated with the account. 6524 Retrieves the Electronic Record and Signature Disclosure, with html formatting, associated with the account. You can use an optional query string to set the language for the disclosure. 6525 This method makes a synchronous HTTP request by default. To make an 6526 asynchronous HTTP request, please define a `callback` function 6527 to be invoked when receiving the response. 6528 >>> def callback_function(response): 6529 >>> pprint(response) 6530 >>> 6531 >>> thread = api.get_consumer_disclosure_default_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 6532 6533 :param callback function: The callback function 6534 for asynchronous request. (optional) 6535 :param str account_id: The external account number (int) or account ID Guid. (required) 6536 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6537 :param str recipient_id: The ID of the recipient being accessed. (required) 6538 :param str lang_code: 6539 :return: ConsumerDisclosure 6540 If the method is called asynchronously, 6541 returns the request thread. 6542 """ 6543 6544 all_params = ['account_id', 'envelope_id', 'recipient_id', 'lang_code'] 6545 all_params.append('callback') 6546 all_params.append('_return_http_data_only') 6547 all_params.append('_preload_content') 6548 all_params.append('_request_timeout') 6549 6550 params = locals() 6551 for key, val in iteritems(params['kwargs']): 6552 if key not in all_params: 6553 raise TypeError( 6554 "Got an unexpected keyword argument '%s'" 6555 " to method get_consumer_disclosure_default" % key 6556 ) 6557 params[key] = val 6558 del params['kwargs'] 6559 # verify the required parameter 'account_id' is set 6560 if ('account_id' not in params) or (params['account_id'] is None): 6561 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure_default`") 6562 # verify the required parameter 'envelope_id' is set 6563 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6564 raise ValueError("Missing the required parameter `envelope_id` when calling `get_consumer_disclosure_default`") 6565 # verify the required parameter 'recipient_id' is set 6566 if ('recipient_id' not in params) or (params['recipient_id'] is None): 6567 raise ValueError("Missing the required parameter `recipient_id` when calling `get_consumer_disclosure_default`") 6568 6569 6570 collection_formats = {} 6571 6572 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/consumer_disclosure'.replace('{format}', 'json') 6573 path_params = {} 6574 if 'account_id' in params: 6575 path_params['accountId'] = params['account_id'] 6576 if 'envelope_id' in params: 6577 path_params['envelopeId'] = params['envelope_id'] 6578 if 'recipient_id' in params: 6579 path_params['recipientId'] = params['recipient_id'] 6580 6581 query_params = {} 6582 if 'lang_code' in params: 6583 query_params['langCode'] = params['lang_code'] 6584 6585 header_params = {} 6586 6587 form_params = [] 6588 local_var_files = {} 6589 6590 body_params = None 6591 # HTTP header `Accept` 6592 header_params['Accept'] = self.api_client.\ 6593 select_header_accept(['application/json']) 6594 6595 # Authentication setting 6596 auth_settings = [] 6597 6598 return self.api_client.call_api(resource_path, 'GET', 6599 path_params, 6600 query_params, 6601 header_params, 6602 body=body_params, 6603 post_params=form_params, 6604 files=local_var_files, 6605 response_type='ConsumerDisclosure', 6606 auth_settings=auth_settings, 6607 callback=params.get('callback'), 6608 _return_http_data_only=params.get('_return_http_data_only'), 6609 _preload_content=params.get('_preload_content', True), 6610 _request_timeout=params.get('_request_timeout'), 6611 collection_formats=collection_formats)
Gets the Electronic Record and Signature Disclosure associated with the account.
Retrieves the Electronic Record and Signature Disclosure, with html formatting, associated with the account. You can use an optional query string to set the language for the disclosure.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_consumer_disclosure_default_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
- str lang_code:
Returns
ConsumerDisclosure If the method is called asynchronously, returns the request thread.
def
get_document(self, account_id, document_id, envelope_id, **kwargs)
6613 def get_document(self, account_id, document_id, envelope_id, **kwargs): 6614 """ 6615 Gets a document from an envelope. 6616 Retrieves the specified document from the envelope. If the account has the Highlight Data Changes feature enabled, there is an option to request that any changes in the envelope be highlighted. You can also use this method to retrieve a PDF containing the combined content of all documents and the certificate. If the account has the Highlight Data Changes feature enabled, there is an option to request that any changes in the envelope be highlighted. To retrieve the combined content replace the `{documentId}` parameter in the endpoint with `combined`. /accounts/{accountId}/envelopes/{envelopeId}/documents/combined 6617 This method makes a synchronous HTTP request by default. To make an 6618 asynchronous HTTP request, please define a `callback` function 6619 to be invoked when receiving the response. 6620 >>> def callback_function(response): 6621 >>> pprint(response) 6622 >>> 6623 >>> thread = api.get_document(account_id, document_id, envelope_id, callback=callback_function) 6624 6625 :param callback function: The callback function 6626 for asynchronous request. (optional) 6627 :param str account_id: The external account number (int) or account ID Guid. (required) 6628 :param str document_id: The ID of the document being accessed. (required) 6629 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6630 :param str certificate: When set to **false**, the envelope signing certificate is removed from the download. 6631 :param str documents_by_userid: 6632 :param str encoding: 6633 :param str encrypt: When set to **true**, the PDF bytes returned in the response are encrypted for all the key managers configured on your DocuSign account. The documents can be decrypted with the KeyManager Decrypt Document API. 6634 :param str language: Specifies the language for the Certificate of Completion in the response. The supported languages, with the language value shown in parenthesis, are: Chinese Simplified (zh_CN), , Chinese Traditional (zh_TW), Dutch (nl), English US (en), French (fr), German (de), Italian (it), Japanese (ja), Korean (ko), Portuguese (pt), Portuguese (Brazil) (pt_BR), Russian (ru), Spanish (es). 6635 :param str recipient_id: 6636 :param str shared_user_id: 6637 :param str show_changes: When set to **true**, any changed fields for the returned PDF are highlighted in yellow and optional signatures or initials outlined in red. 6638 :param str watermark: When set to **true**, the account has the watermark feature enabled, and the envelope is not complete, the watermark for the account is added to the PDF documents. This option can remove the watermark. 6639 :return: file 6640 If the method is called asynchronously, 6641 returns the request thread. 6642 """ 6643 kwargs['_return_http_data_only'] = True 6644 if kwargs.get('callback'): 6645 return self.get_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 6646 else: 6647 (data) = self.get_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 6648 return data
Gets a document from an envelope.
Retrieves the specified document from the envelope. If the account has the Highlight Data Changes feature enabled, there is an option to request that any changes in the envelope be highlighted. You can also use this method to retrieve a PDF containing the combined content of all documents and the certificate. If the account has the Highlight Data Changes feature enabled, there is an option to request that any changes in the envelope be highlighted. To retrieve the combined content replace the {documentId} parameter in the endpoint with combined. /accounts/{accountId}/envelopes/{envelopeId}/documents/combined
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_document(account_id, document_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str certificate: When set to false, the envelope signing certificate is removed from the download.
- str documents_by_userid:
- str encoding:
- str encrypt: When set to true, the PDF bytes returned in the response are encrypted for all the key managers configured on your DocuSign account. The documents can be decrypted with the KeyManager Decrypt Document API.
- str language: Specifies the language for the Certificate of Completion in the response. The supported languages, with the language value shown in parenthesis, are: Chinese Simplified (zh_CN), , Chinese Traditional (zh_TW), Dutch (nl), English US (en), French (fr), German (de), Italian (it), Japanese (ja), Korean (ko), Portuguese (pt), Portuguese (Brazil) (pt_BR), Russian (ru), Spanish (es).
- str recipient_id:
- str shared_user_id:
- str show_changes: When set to true, any changed fields for the returned PDF are highlighted in yellow and optional signatures or initials outlined in red.
- str watermark: When set to true, the account has the watermark feature enabled, and the envelope is not complete, the watermark for the account is added to the PDF documents. This option can remove the watermark.
Returns
file If the method is called asynchronously, returns the request thread.
def
get_document_with_http_info(self, account_id, document_id, envelope_id, **kwargs)
6650 def get_document_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 6651 """ 6652 Gets a document from an envelope. 6653 Retrieves the specified document from the envelope. If the account has the Highlight Data Changes feature enabled, there is an option to request that any changes in the envelope be highlighted. You can also use this method to retrieve a PDF containing the combined content of all documents and the certificate. If the account has the Highlight Data Changes feature enabled, there is an option to request that any changes in the envelope be highlighted. To retrieve the combined content replace the `{documentId}` parameter in the endpoint with `combined`. /accounts/{accountId}/envelopes/{envelopeId}/documents/combined 6654 This method makes a synchronous HTTP request by default. To make an 6655 asynchronous HTTP request, please define a `callback` function 6656 to be invoked when receiving the response. 6657 >>> def callback_function(response): 6658 >>> pprint(response) 6659 >>> 6660 >>> thread = api.get_document_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 6661 6662 :param callback function: The callback function 6663 for asynchronous request. (optional) 6664 :param str account_id: The external account number (int) or account ID Guid. (required) 6665 :param str document_id: The ID of the document being accessed. (required) 6666 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6667 :param str certificate: When set to **false**, the envelope signing certificate is removed from the download. 6668 :param str documents_by_userid: 6669 :param str encoding: 6670 :param str encrypt: When set to **true**, the PDF bytes returned in the response are encrypted for all the key managers configured on your DocuSign account. The documents can be decrypted with the KeyManager Decrypt Document API. 6671 :param str language: Specifies the language for the Certificate of Completion in the response. The supported languages, with the language value shown in parenthesis, are: Chinese Simplified (zh_CN), , Chinese Traditional (zh_TW), Dutch (nl), English US (en), French (fr), German (de), Italian (it), Japanese (ja), Korean (ko), Portuguese (pt), Portuguese (Brazil) (pt_BR), Russian (ru), Spanish (es). 6672 :param str recipient_id: 6673 :param str shared_user_id: 6674 :param str show_changes: When set to **true**, any changed fields for the returned PDF are highlighted in yellow and optional signatures or initials outlined in red. 6675 :param str watermark: When set to **true**, the account has the watermark feature enabled, and the envelope is not complete, the watermark for the account is added to the PDF documents. This option can remove the watermark. 6676 :return: file 6677 If the method is called asynchronously, 6678 returns the request thread. 6679 """ 6680 6681 all_params = ['account_id', 'document_id', 'envelope_id', 'certificate', 'documents_by_userid', 'encoding', 'encrypt', 'language', 'recipient_id', 'shared_user_id', 'show_changes', 'watermark'] 6682 all_params.append('callback') 6683 all_params.append('_return_http_data_only') 6684 all_params.append('_preload_content') 6685 all_params.append('_request_timeout') 6686 6687 params = locals() 6688 for key, val in iteritems(params['kwargs']): 6689 if key not in all_params: 6690 raise TypeError( 6691 "Got an unexpected keyword argument '%s'" 6692 " to method get_document" % key 6693 ) 6694 params[key] = val 6695 del params['kwargs'] 6696 # verify the required parameter 'account_id' is set 6697 if ('account_id' not in params) or (params['account_id'] is None): 6698 raise ValueError("Missing the required parameter `account_id` when calling `get_document`") 6699 # verify the required parameter 'document_id' is set 6700 if ('document_id' not in params) or (params['document_id'] is None): 6701 raise ValueError("Missing the required parameter `document_id` when calling `get_document`") 6702 # verify the required parameter 'envelope_id' is set 6703 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6704 raise ValueError("Missing the required parameter `envelope_id` when calling `get_document`") 6705 6706 6707 collection_formats = {} 6708 6709 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}'.replace('{format}', 'json') 6710 path_params = {} 6711 if 'account_id' in params: 6712 path_params['accountId'] = params['account_id'] 6713 if 'document_id' in params: 6714 path_params['documentId'] = params['document_id'] 6715 if 'envelope_id' in params: 6716 path_params['envelopeId'] = params['envelope_id'] 6717 6718 query_params = {} 6719 if 'certificate' in params: 6720 query_params['certificate'] = params['certificate'] 6721 if 'documents_by_userid' in params: 6722 query_params['documents_by_userid'] = params['documents_by_userid'] 6723 if 'encoding' in params: 6724 query_params['encoding'] = params['encoding'] 6725 if 'encrypt' in params: 6726 query_params['encrypt'] = params['encrypt'] 6727 if 'language' in params: 6728 query_params['language'] = params['language'] 6729 if 'recipient_id' in params: 6730 query_params['recipient_id'] = params['recipient_id'] 6731 if 'shared_user_id' in params: 6732 query_params['shared_user_id'] = params['shared_user_id'] 6733 if 'show_changes' in params: 6734 query_params['show_changes'] = params['show_changes'] 6735 if 'watermark' in params: 6736 query_params['watermark'] = params['watermark'] 6737 6738 header_params = {} 6739 6740 form_params = [] 6741 local_var_files = {} 6742 6743 body_params = None 6744 # HTTP header `Accept` 6745 header_params['Accept'] = self.api_client.\ 6746 select_header_accept(['application/pdf']) 6747 6748 # Authentication setting 6749 auth_settings = [] 6750 6751 return self.api_client.call_api(resource_path, 'GET', 6752 path_params, 6753 query_params, 6754 header_params, 6755 body=body_params, 6756 post_params=form_params, 6757 files=local_var_files, 6758 response_type='file', 6759 auth_settings=auth_settings, 6760 callback=params.get('callback'), 6761 _return_http_data_only=params.get('_return_http_data_only'), 6762 _preload_content=params.get('_preload_content', True), 6763 _request_timeout=params.get('_request_timeout'), 6764 collection_formats=collection_formats)
Gets a document from an envelope.
Retrieves the specified document from the envelope. If the account has the Highlight Data Changes feature enabled, there is an option to request that any changes in the envelope be highlighted. You can also use this method to retrieve a PDF containing the combined content of all documents and the certificate. If the account has the Highlight Data Changes feature enabled, there is an option to request that any changes in the envelope be highlighted. To retrieve the combined content replace the {documentId} parameter in the endpoint with combined. /accounts/{accountId}/envelopes/{envelopeId}/documents/combined
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_document_with_http_info(account_id, document_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str certificate: When set to false, the envelope signing certificate is removed from the download.
- str documents_by_userid:
- str encoding:
- str encrypt: When set to true, the PDF bytes returned in the response are encrypted for all the key managers configured on your DocuSign account. The documents can be decrypted with the KeyManager Decrypt Document API.
- str language: Specifies the language for the Certificate of Completion in the response. The supported languages, with the language value shown in parenthesis, are: Chinese Simplified (zh_CN), , Chinese Traditional (zh_TW), Dutch (nl), English US (en), French (fr), German (de), Italian (it), Japanese (ja), Korean (ko), Portuguese (pt), Portuguese (Brazil) (pt_BR), Russian (ru), Spanish (es).
- str recipient_id:
- str shared_user_id:
- str show_changes: When set to true, any changed fields for the returned PDF are highlighted in yellow and optional signatures or initials outlined in red.
- str watermark: When set to true, the account has the watermark feature enabled, and the envelope is not complete, the watermark for the account is added to the PDF documents. This option can remove the watermark.
Returns
file If the method is called asynchronously, returns the request thread.
def
get_document_page_image(self, account_id, document_id, envelope_id, page_number, **kwargs)
6766 def get_document_page_image(self, account_id, document_id, envelope_id, page_number, **kwargs): 6767 """ 6768 Gets a page image from an envelope for display. 6769 Retrieves a page image for display from the specified envelope. 6770 This method makes a synchronous HTTP request by default. To make an 6771 asynchronous HTTP request, please define a `callback` function 6772 to be invoked when receiving the response. 6773 >>> def callback_function(response): 6774 >>> pprint(response) 6775 >>> 6776 >>> thread = api.get_document_page_image(account_id, document_id, envelope_id, page_number, callback=callback_function) 6777 6778 :param callback function: The callback function 6779 for asynchronous request. (optional) 6780 :param str account_id: The external account number (int) or account ID Guid. (required) 6781 :param str document_id: The ID of the document being accessed. (required) 6782 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6783 :param str page_number: The page number being accessed. (required) 6784 :param str dpi: Sets the dpi for the image. 6785 :param str max_height: Sets the maximum height for the page image in pixels. The dpi is recalculated based on this setting. 6786 :param str max_width: Sets the maximum width for the page image in pixels. The dpi is recalculated based on this setting. 6787 :param str show_changes: 6788 :return: file 6789 If the method is called asynchronously, 6790 returns the request thread. 6791 """ 6792 kwargs['_return_http_data_only'] = True 6793 if kwargs.get('callback'): 6794 return self.get_document_page_image_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 6795 else: 6796 (data) = self.get_document_page_image_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 6797 return data
Gets a page image from an envelope for display.
Retrieves a page image for display from the specified envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_document_page_image(account_id, document_id, envelope_id, page_number, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str page_number: The page number being accessed. (required)
- str dpi: Sets the dpi for the image.
- str max_height: Sets the maximum height for the page image in pixels. The dpi is recalculated based on this setting.
- str max_width: Sets the maximum width for the page image in pixels. The dpi is recalculated based on this setting.
- str show_changes:
Returns
file If the method is called asynchronously, returns the request thread.
def
get_document_page_image_with_http_info(self, account_id, document_id, envelope_id, page_number, **kwargs)
6799 def get_document_page_image_with_http_info(self, account_id, document_id, envelope_id, page_number, **kwargs): 6800 """ 6801 Gets a page image from an envelope for display. 6802 Retrieves a page image for display from the specified envelope. 6803 This method makes a synchronous HTTP request by default. To make an 6804 asynchronous HTTP request, please define a `callback` function 6805 to be invoked when receiving the response. 6806 >>> def callback_function(response): 6807 >>> pprint(response) 6808 >>> 6809 >>> thread = api.get_document_page_image_with_http_info(account_id, document_id, envelope_id, page_number, callback=callback_function) 6810 6811 :param callback function: The callback function 6812 for asynchronous request. (optional) 6813 :param str account_id: The external account number (int) or account ID Guid. (required) 6814 :param str document_id: The ID of the document being accessed. (required) 6815 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6816 :param str page_number: The page number being accessed. (required) 6817 :param str dpi: Sets the dpi for the image. 6818 :param str max_height: Sets the maximum height for the page image in pixels. The dpi is recalculated based on this setting. 6819 :param str max_width: Sets the maximum width for the page image in pixels. The dpi is recalculated based on this setting. 6820 :param str show_changes: 6821 :return: file 6822 If the method is called asynchronously, 6823 returns the request thread. 6824 """ 6825 6826 all_params = ['account_id', 'document_id', 'envelope_id', 'page_number', 'dpi', 'max_height', 'max_width', 'show_changes'] 6827 all_params.append('callback') 6828 all_params.append('_return_http_data_only') 6829 all_params.append('_preload_content') 6830 all_params.append('_request_timeout') 6831 6832 params = locals() 6833 for key, val in iteritems(params['kwargs']): 6834 if key not in all_params: 6835 raise TypeError( 6836 "Got an unexpected keyword argument '%s'" 6837 " to method get_document_page_image" % key 6838 ) 6839 params[key] = val 6840 del params['kwargs'] 6841 # verify the required parameter 'account_id' is set 6842 if ('account_id' not in params) or (params['account_id'] is None): 6843 raise ValueError("Missing the required parameter `account_id` when calling `get_document_page_image`") 6844 # verify the required parameter 'document_id' is set 6845 if ('document_id' not in params) or (params['document_id'] is None): 6846 raise ValueError("Missing the required parameter `document_id` when calling `get_document_page_image`") 6847 # verify the required parameter 'envelope_id' is set 6848 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6849 raise ValueError("Missing the required parameter `envelope_id` when calling `get_document_page_image`") 6850 # verify the required parameter 'page_number' is set 6851 if ('page_number' not in params) or (params['page_number'] is None): 6852 raise ValueError("Missing the required parameter `page_number` when calling `get_document_page_image`") 6853 6854 6855 collection_formats = {} 6856 6857 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/pages/{pageNumber}/page_image'.replace('{format}', 'json') 6858 path_params = {} 6859 if 'account_id' in params: 6860 path_params['accountId'] = params['account_id'] 6861 if 'document_id' in params: 6862 path_params['documentId'] = params['document_id'] 6863 if 'envelope_id' in params: 6864 path_params['envelopeId'] = params['envelope_id'] 6865 if 'page_number' in params: 6866 path_params['pageNumber'] = params['page_number'] 6867 6868 query_params = {} 6869 if 'dpi' in params: 6870 query_params['dpi'] = params['dpi'] 6871 if 'max_height' in params: 6872 query_params['max_height'] = params['max_height'] 6873 if 'max_width' in params: 6874 query_params['max_width'] = params['max_width'] 6875 if 'show_changes' in params: 6876 query_params['show_changes'] = params['show_changes'] 6877 6878 header_params = {} 6879 6880 form_params = [] 6881 local_var_files = {} 6882 6883 body_params = None 6884 # HTTP header `Accept` 6885 header_params['Accept'] = self.api_client.\ 6886 select_header_accept(['image/png']) 6887 6888 # Authentication setting 6889 auth_settings = [] 6890 6891 return self.api_client.call_api(resource_path, 'GET', 6892 path_params, 6893 query_params, 6894 header_params, 6895 body=body_params, 6896 post_params=form_params, 6897 files=local_var_files, 6898 response_type='file', 6899 auth_settings=auth_settings, 6900 callback=params.get('callback'), 6901 _return_http_data_only=params.get('_return_http_data_only'), 6902 _preload_content=params.get('_preload_content', True), 6903 _request_timeout=params.get('_request_timeout'), 6904 collection_formats=collection_formats)
Gets a page image from an envelope for display.
Retrieves a page image for display from the specified envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_document_page_image_with_http_info(account_id, document_id, envelope_id, page_number, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str page_number: The page number being accessed. (required)
- str dpi: Sets the dpi for the image.
- str max_height: Sets the maximum height for the page image in pixels. The dpi is recalculated based on this setting.
- str max_width: Sets the maximum width for the page image in pixels. The dpi is recalculated based on this setting.
- str show_changes:
Returns
file If the method is called asynchronously, returns the request thread.
def
get_document_tabs(self, account_id, document_id, envelope_id, **kwargs)
6906 def get_document_tabs(self, account_id, document_id, envelope_id, **kwargs): 6907 """ 6908 Returns tabs on the document. 6909 Returns the tabs on the document specified by `documentId` in the envelope specified by `envelopeId`. 6910 This method makes a synchronous HTTP request by default. To make an 6911 asynchronous HTTP request, please define a `callback` function 6912 to be invoked when receiving the response. 6913 >>> def callback_function(response): 6914 >>> pprint(response) 6915 >>> 6916 >>> thread = api.get_document_tabs(account_id, document_id, envelope_id, callback=callback_function) 6917 6918 :param callback function: The callback function 6919 for asynchronous request. (optional) 6920 :param str account_id: The external account number (int) or account ID Guid. (required) 6921 :param str document_id: The ID of the document being accessed. (required) 6922 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6923 :param str include_metadata: 6924 :param str page_numbers: 6925 :return: Tabs 6926 If the method is called asynchronously, 6927 returns the request thread. 6928 """ 6929 kwargs['_return_http_data_only'] = True 6930 if kwargs.get('callback'): 6931 return self.get_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 6932 else: 6933 (data) = self.get_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 6934 return data
Returns tabs on the document.
Returns the tabs on the document specified by documentId in the envelope specified by envelopeId.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_document_tabs(account_id, document_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str include_metadata:
- str page_numbers:
Returns
Tabs If the method is called asynchronously, returns the request thread.
def
get_document_tabs_with_http_info(self, account_id, document_id, envelope_id, **kwargs)
6936 def get_document_tabs_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 6937 """ 6938 Returns tabs on the document. 6939 Returns the tabs on the document specified by `documentId` in the envelope specified by `envelopeId`. 6940 This method makes a synchronous HTTP request by default. To make an 6941 asynchronous HTTP request, please define a `callback` function 6942 to be invoked when receiving the response. 6943 >>> def callback_function(response): 6944 >>> pprint(response) 6945 >>> 6946 >>> thread = api.get_document_tabs_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 6947 6948 :param callback function: The callback function 6949 for asynchronous request. (optional) 6950 :param str account_id: The external account number (int) or account ID Guid. (required) 6951 :param str document_id: The ID of the document being accessed. (required) 6952 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6953 :param str include_metadata: 6954 :param str page_numbers: 6955 :return: Tabs 6956 If the method is called asynchronously, 6957 returns the request thread. 6958 """ 6959 6960 all_params = ['account_id', 'document_id', 'envelope_id', 'include_metadata', 'page_numbers'] 6961 all_params.append('callback') 6962 all_params.append('_return_http_data_only') 6963 all_params.append('_preload_content') 6964 all_params.append('_request_timeout') 6965 6966 params = locals() 6967 for key, val in iteritems(params['kwargs']): 6968 if key not in all_params: 6969 raise TypeError( 6970 "Got an unexpected keyword argument '%s'" 6971 " to method get_document_tabs" % key 6972 ) 6973 params[key] = val 6974 del params['kwargs'] 6975 # verify the required parameter 'account_id' is set 6976 if ('account_id' not in params) or (params['account_id'] is None): 6977 raise ValueError("Missing the required parameter `account_id` when calling `get_document_tabs`") 6978 # verify the required parameter 'document_id' is set 6979 if ('document_id' not in params) or (params['document_id'] is None): 6980 raise ValueError("Missing the required parameter `document_id` when calling `get_document_tabs`") 6981 # verify the required parameter 'envelope_id' is set 6982 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6983 raise ValueError("Missing the required parameter `envelope_id` when calling `get_document_tabs`") 6984 6985 6986 collection_formats = {} 6987 6988 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/tabs'.replace('{format}', 'json') 6989 path_params = {} 6990 if 'account_id' in params: 6991 path_params['accountId'] = params['account_id'] 6992 if 'document_id' in params: 6993 path_params['documentId'] = params['document_id'] 6994 if 'envelope_id' in params: 6995 path_params['envelopeId'] = params['envelope_id'] 6996 6997 query_params = {} 6998 if 'include_metadata' in params: 6999 query_params['include_metadata'] = params['include_metadata'] 7000 if 'page_numbers' in params: 7001 query_params['page_numbers'] = params['page_numbers'] 7002 7003 header_params = {} 7004 7005 form_params = [] 7006 local_var_files = {} 7007 7008 body_params = None 7009 # HTTP header `Accept` 7010 header_params['Accept'] = self.api_client.\ 7011 select_header_accept(['application/json']) 7012 7013 # Authentication setting 7014 auth_settings = [] 7015 7016 return self.api_client.call_api(resource_path, 'GET', 7017 path_params, 7018 query_params, 7019 header_params, 7020 body=body_params, 7021 post_params=form_params, 7022 files=local_var_files, 7023 response_type='Tabs', 7024 auth_settings=auth_settings, 7025 callback=params.get('callback'), 7026 _return_http_data_only=params.get('_return_http_data_only'), 7027 _preload_content=params.get('_preload_content', True), 7028 _request_timeout=params.get('_request_timeout'), 7029 collection_formats=collection_formats)
Returns tabs on the document.
Returns the tabs on the document specified by documentId in the envelope specified by envelopeId.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_document_tabs_with_http_info(account_id, document_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str include_metadata:
- str page_numbers:
Returns
Tabs If the method is called asynchronously, returns the request thread.
def
get_email_settings(self, account_id, envelope_id, **kwargs)
7031 def get_email_settings(self, account_id, envelope_id, **kwargs): 7032 """ 7033 Gets the email setting overrides for an envelope. 7034 Retrieves the email override settings for the specified envelope. 7035 This method makes a synchronous HTTP request by default. To make an 7036 asynchronous HTTP request, please define a `callback` function 7037 to be invoked when receiving the response. 7038 >>> def callback_function(response): 7039 >>> pprint(response) 7040 >>> 7041 >>> thread = api.get_email_settings(account_id, envelope_id, callback=callback_function) 7042 7043 :param callback function: The callback function 7044 for asynchronous request. (optional) 7045 :param str account_id: The external account number (int) or account ID Guid. (required) 7046 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7047 :return: EmailSettings 7048 If the method is called asynchronously, 7049 returns the request thread. 7050 """ 7051 kwargs['_return_http_data_only'] = True 7052 if kwargs.get('callback'): 7053 return self.get_email_settings_with_http_info(account_id, envelope_id, **kwargs) 7054 else: 7055 (data) = self.get_email_settings_with_http_info(account_id, envelope_id, **kwargs) 7056 return data
Gets the email setting overrides for an envelope.
Retrieves the email override settings for the specified envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_email_settings(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
EmailSettings If the method is called asynchronously, returns the request thread.
def
get_email_settings_with_http_info(self, account_id, envelope_id, **kwargs)
7058 def get_email_settings_with_http_info(self, account_id, envelope_id, **kwargs): 7059 """ 7060 Gets the email setting overrides for an envelope. 7061 Retrieves the email override settings for the specified envelope. 7062 This method makes a synchronous HTTP request by default. To make an 7063 asynchronous HTTP request, please define a `callback` function 7064 to be invoked when receiving the response. 7065 >>> def callback_function(response): 7066 >>> pprint(response) 7067 >>> 7068 >>> thread = api.get_email_settings_with_http_info(account_id, envelope_id, callback=callback_function) 7069 7070 :param callback function: The callback function 7071 for asynchronous request. (optional) 7072 :param str account_id: The external account number (int) or account ID Guid. (required) 7073 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7074 :return: EmailSettings 7075 If the method is called asynchronously, 7076 returns the request thread. 7077 """ 7078 7079 all_params = ['account_id', 'envelope_id'] 7080 all_params.append('callback') 7081 all_params.append('_return_http_data_only') 7082 all_params.append('_preload_content') 7083 all_params.append('_request_timeout') 7084 7085 params = locals() 7086 for key, val in iteritems(params['kwargs']): 7087 if key not in all_params: 7088 raise TypeError( 7089 "Got an unexpected keyword argument '%s'" 7090 " to method get_email_settings" % key 7091 ) 7092 params[key] = val 7093 del params['kwargs'] 7094 # verify the required parameter 'account_id' is set 7095 if ('account_id' not in params) or (params['account_id'] is None): 7096 raise ValueError("Missing the required parameter `account_id` when calling `get_email_settings`") 7097 # verify the required parameter 'envelope_id' is set 7098 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7099 raise ValueError("Missing the required parameter `envelope_id` when calling `get_email_settings`") 7100 7101 7102 collection_formats = {} 7103 7104 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/email_settings'.replace('{format}', 'json') 7105 path_params = {} 7106 if 'account_id' in params: 7107 path_params['accountId'] = params['account_id'] 7108 if 'envelope_id' in params: 7109 path_params['envelopeId'] = params['envelope_id'] 7110 7111 query_params = {} 7112 7113 header_params = {} 7114 7115 form_params = [] 7116 local_var_files = {} 7117 7118 body_params = None 7119 # HTTP header `Accept` 7120 header_params['Accept'] = self.api_client.\ 7121 select_header_accept(['application/json']) 7122 7123 # Authentication setting 7124 auth_settings = [] 7125 7126 return self.api_client.call_api(resource_path, 'GET', 7127 path_params, 7128 query_params, 7129 header_params, 7130 body=body_params, 7131 post_params=form_params, 7132 files=local_var_files, 7133 response_type='EmailSettings', 7134 auth_settings=auth_settings, 7135 callback=params.get('callback'), 7136 _return_http_data_only=params.get('_return_http_data_only'), 7137 _preload_content=params.get('_preload_content', True), 7138 _request_timeout=params.get('_request_timeout'), 7139 collection_formats=collection_formats)
Gets the email setting overrides for an envelope.
Retrieves the email override settings for the specified envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_email_settings_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
EmailSettings If the method is called asynchronously, returns the request thread.
def
get_envelope(self, account_id, envelope_id, **kwargs)
7141 def get_envelope(self, account_id, envelope_id, **kwargs): 7142 """ 7143 Gets the status of a envelope. 7144 Retrieves the overall status for the specified envelope. 7145 This method makes a synchronous HTTP request by default. To make an 7146 asynchronous HTTP request, please define a `callback` function 7147 to be invoked when receiving the response. 7148 >>> def callback_function(response): 7149 >>> pprint(response) 7150 >>> 7151 >>> thread = api.get_envelope(account_id, envelope_id, callback=callback_function) 7152 7153 :param callback function: The callback function 7154 for asynchronous request. (optional) 7155 :param str account_id: The external account number (int) or account ID Guid. (required) 7156 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7157 :param str advanced_update: When true, envelope information can be added or modified. 7158 :param str include: 7159 :param str include_anchor_tab_locations: 7160 :return: Envelope 7161 If the method is called asynchronously, 7162 returns the request thread. 7163 """ 7164 kwargs['_return_http_data_only'] = True 7165 if kwargs.get('callback'): 7166 return self.get_envelope_with_http_info(account_id, envelope_id, **kwargs) 7167 else: 7168 (data) = self.get_envelope_with_http_info(account_id, envelope_id, **kwargs) 7169 return data
Gets the status of a envelope.
Retrieves the overall status for the specified envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_envelope(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str advanced_update: When true, envelope information can be added or modified.
- str include:
- str include_anchor_tab_locations:
Returns
Envelope If the method is called asynchronously, returns the request thread.
def
get_envelope_with_http_info(self, account_id, envelope_id, **kwargs)
7171 def get_envelope_with_http_info(self, account_id, envelope_id, **kwargs): 7172 """ 7173 Gets the status of a envelope. 7174 Retrieves the overall status for the specified envelope. 7175 This method makes a synchronous HTTP request by default. To make an 7176 asynchronous HTTP request, please define a `callback` function 7177 to be invoked when receiving the response. 7178 >>> def callback_function(response): 7179 >>> pprint(response) 7180 >>> 7181 >>> thread = api.get_envelope_with_http_info(account_id, envelope_id, callback=callback_function) 7182 7183 :param callback function: The callback function 7184 for asynchronous request. (optional) 7185 :param str account_id: The external account number (int) or account ID Guid. (required) 7186 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7187 :param str advanced_update: When true, envelope information can be added or modified. 7188 :param str include: 7189 :param str include_anchor_tab_locations: 7190 :return: Envelope 7191 If the method is called asynchronously, 7192 returns the request thread. 7193 """ 7194 7195 all_params = ['account_id', 'envelope_id', 'advanced_update', 'include', 'include_anchor_tab_locations'] 7196 all_params.append('callback') 7197 all_params.append('_return_http_data_only') 7198 all_params.append('_preload_content') 7199 all_params.append('_request_timeout') 7200 7201 params = locals() 7202 for key, val in iteritems(params['kwargs']): 7203 if key not in all_params: 7204 raise TypeError( 7205 "Got an unexpected keyword argument '%s'" 7206 " to method get_envelope" % key 7207 ) 7208 params[key] = val 7209 del params['kwargs'] 7210 # verify the required parameter 'account_id' is set 7211 if ('account_id' not in params) or (params['account_id'] is None): 7212 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope`") 7213 # verify the required parameter 'envelope_id' is set 7214 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7215 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope`") 7216 7217 7218 collection_formats = {} 7219 7220 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}'.replace('{format}', 'json') 7221 path_params = {} 7222 if 'account_id' in params: 7223 path_params['accountId'] = params['account_id'] 7224 if 'envelope_id' in params: 7225 path_params['envelopeId'] = params['envelope_id'] 7226 7227 query_params = {} 7228 if 'advanced_update' in params: 7229 query_params['advanced_update'] = params['advanced_update'] 7230 if 'include' in params: 7231 query_params['include'] = params['include'] 7232 if 'include_anchor_tab_locations' in params: 7233 query_params['include_anchor_tab_locations'] = params['include_anchor_tab_locations'] 7234 7235 header_params = {} 7236 7237 form_params = [] 7238 local_var_files = {} 7239 7240 body_params = None 7241 # HTTP header `Accept` 7242 header_params['Accept'] = self.api_client.\ 7243 select_header_accept(['application/json']) 7244 7245 # Authentication setting 7246 auth_settings = [] 7247 7248 return self.api_client.call_api(resource_path, 'GET', 7249 path_params, 7250 query_params, 7251 header_params, 7252 body=body_params, 7253 post_params=form_params, 7254 files=local_var_files, 7255 response_type='Envelope', 7256 auth_settings=auth_settings, 7257 callback=params.get('callback'), 7258 _return_http_data_only=params.get('_return_http_data_only'), 7259 _preload_content=params.get('_preload_content', True), 7260 _request_timeout=params.get('_request_timeout'), 7261 collection_formats=collection_formats)
Gets the status of a envelope.
Retrieves the overall status for the specified envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_envelope_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str advanced_update: When true, envelope information can be added or modified.
- str include:
- str include_anchor_tab_locations:
Returns
Envelope If the method is called asynchronously, returns the request thread.
def
get_envelope_delayed_routing_definition(self, account_id, envelope_id, workflow_step_id, **kwargs)
7263 def get_envelope_delayed_routing_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 7264 """ 7265 Returns the delayed routing rules for an envelope's workflow step definition. 7266 This method makes a synchronous HTTP request by default. To make an 7267 asynchronous HTTP request, please define a `callback` function 7268 to be invoked when receiving the response. 7269 >>> def callback_function(response): 7270 >>> pprint(response) 7271 >>> 7272 >>> thread = api.get_envelope_delayed_routing_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 7273 7274 :param callback function: The callback function 7275 for asynchronous request. (optional) 7276 :param str account_id: The external account number (int) or account ID Guid. (required) 7277 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7278 :param str workflow_step_id: (required) 7279 :return: DelayedRouting 7280 If the method is called asynchronously, 7281 returns the request thread. 7282 """ 7283 kwargs['_return_http_data_only'] = True 7284 if kwargs.get('callback'): 7285 return self.get_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 7286 else: 7287 (data) = self.get_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 7288 return data
Returns the delayed routing rules for an envelope's workflow step definition.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_envelope_delayed_routing_definition(account_id, envelope_id, workflow_step_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str workflow_step_id: (required)
Returns
DelayedRouting If the method is called asynchronously, returns the request thread.
def
get_envelope_delayed_routing_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs)
7290 def get_envelope_delayed_routing_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 7291 """ 7292 Returns the delayed routing rules for an envelope's workflow step definition. 7293 This method makes a synchronous HTTP request by default. To make an 7294 asynchronous HTTP request, please define a `callback` function 7295 to be invoked when receiving the response. 7296 >>> def callback_function(response): 7297 >>> pprint(response) 7298 >>> 7299 >>> thread = api.get_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 7300 7301 :param callback function: The callback function 7302 for asynchronous request. (optional) 7303 :param str account_id: The external account number (int) or account ID Guid. (required) 7304 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7305 :param str workflow_step_id: (required) 7306 :return: DelayedRouting 7307 If the method is called asynchronously, 7308 returns the request thread. 7309 """ 7310 7311 all_params = ['account_id', 'envelope_id', 'workflow_step_id'] 7312 all_params.append('callback') 7313 all_params.append('_return_http_data_only') 7314 all_params.append('_preload_content') 7315 all_params.append('_request_timeout') 7316 7317 params = locals() 7318 for key, val in iteritems(params['kwargs']): 7319 if key not in all_params: 7320 raise TypeError( 7321 "Got an unexpected keyword argument '%s'" 7322 " to method get_envelope_delayed_routing_definition" % key 7323 ) 7324 params[key] = val 7325 del params['kwargs'] 7326 # verify the required parameter 'account_id' is set 7327 if ('account_id' not in params) or (params['account_id'] is None): 7328 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_delayed_routing_definition`") 7329 # verify the required parameter 'envelope_id' is set 7330 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7331 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_delayed_routing_definition`") 7332 # verify the required parameter 'workflow_step_id' is set 7333 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 7334 raise ValueError("Missing the required parameter `workflow_step_id` when calling `get_envelope_delayed_routing_definition`") 7335 7336 7337 collection_formats = {} 7338 7339 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 7340 path_params = {} 7341 if 'account_id' in params: 7342 path_params['accountId'] = params['account_id'] 7343 if 'envelope_id' in params: 7344 path_params['envelopeId'] = params['envelope_id'] 7345 if 'workflow_step_id' in params: 7346 path_params['workflowStepId'] = params['workflow_step_id'] 7347 7348 query_params = {} 7349 7350 header_params = {} 7351 7352 form_params = [] 7353 local_var_files = {} 7354 7355 body_params = None 7356 # HTTP header `Accept` 7357 header_params['Accept'] = self.api_client.\ 7358 select_header_accept(['application/json']) 7359 7360 # Authentication setting 7361 auth_settings = [] 7362 7363 return self.api_client.call_api(resource_path, 'GET', 7364 path_params, 7365 query_params, 7366 header_params, 7367 body=body_params, 7368 post_params=form_params, 7369 files=local_var_files, 7370 response_type='DelayedRouting', 7371 auth_settings=auth_settings, 7372 callback=params.get('callback'), 7373 _return_http_data_only=params.get('_return_http_data_only'), 7374 _preload_content=params.get('_preload_content', True), 7375 _request_timeout=params.get('_request_timeout'), 7376 collection_formats=collection_formats)
Returns the delayed routing rules for an envelope's workflow step definition.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str workflow_step_id: (required)
Returns
DelayedRouting If the method is called asynchronously, returns the request thread.
def
get_envelope_doc_gen_form_fields(self, account_id, envelope_id, **kwargs)
7378 def get_envelope_doc_gen_form_fields(self, account_id, envelope_id, **kwargs): 7379 """ 7380 Returns formfields for an envelope 7381 This method makes a synchronous HTTP request by default. To make an 7382 asynchronous HTTP request, please define a `callback` function 7383 to be invoked when receiving the response. 7384 >>> def callback_function(response): 7385 >>> pprint(response) 7386 >>> 7387 >>> thread = api.get_envelope_doc_gen_form_fields(account_id, envelope_id, callback=callback_function) 7388 7389 :param callback function: The callback function 7390 for asynchronous request. (optional) 7391 :param str account_id: The external account number (int) or account ID Guid. (required) 7392 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7393 :return: DocGenFormFieldResponse 7394 If the method is called asynchronously, 7395 returns the request thread. 7396 """ 7397 kwargs['_return_http_data_only'] = True 7398 if kwargs.get('callback'): 7399 return self.get_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, **kwargs) 7400 else: 7401 (data) = self.get_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, **kwargs) 7402 return data
Returns formfields for an envelope
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_envelope_doc_gen_form_fields(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
DocGenFormFieldResponse If the method is called asynchronously, returns the request thread.
def
get_envelope_doc_gen_form_fields_with_http_info(self, account_id, envelope_id, **kwargs)
7404 def get_envelope_doc_gen_form_fields_with_http_info(self, account_id, envelope_id, **kwargs): 7405 """ 7406 Returns formfields for an envelope 7407 This method makes a synchronous HTTP request by default. To make an 7408 asynchronous HTTP request, please define a `callback` function 7409 to be invoked when receiving the response. 7410 >>> def callback_function(response): 7411 >>> pprint(response) 7412 >>> 7413 >>> thread = api.get_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, callback=callback_function) 7414 7415 :param callback function: The callback function 7416 for asynchronous request. (optional) 7417 :param str account_id: The external account number (int) or account ID Guid. (required) 7418 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7419 :return: DocGenFormFieldResponse 7420 If the method is called asynchronously, 7421 returns the request thread. 7422 """ 7423 7424 all_params = ['account_id', 'envelope_id'] 7425 all_params.append('callback') 7426 all_params.append('_return_http_data_only') 7427 all_params.append('_preload_content') 7428 all_params.append('_request_timeout') 7429 7430 params = locals() 7431 for key, val in iteritems(params['kwargs']): 7432 if key not in all_params: 7433 raise TypeError( 7434 "Got an unexpected keyword argument '%s'" 7435 " to method get_envelope_doc_gen_form_fields" % key 7436 ) 7437 params[key] = val 7438 del params['kwargs'] 7439 # verify the required parameter 'account_id' is set 7440 if ('account_id' not in params) or (params['account_id'] is None): 7441 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_doc_gen_form_fields`") 7442 # verify the required parameter 'envelope_id' is set 7443 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7444 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_doc_gen_form_fields`") 7445 7446 7447 collection_formats = {} 7448 7449 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/docGenFormFields'.replace('{format}', 'json') 7450 path_params = {} 7451 if 'account_id' in params: 7452 path_params['accountId'] = params['account_id'] 7453 if 'envelope_id' in params: 7454 path_params['envelopeId'] = params['envelope_id'] 7455 7456 query_params = {} 7457 7458 header_params = {} 7459 7460 form_params = [] 7461 local_var_files = {} 7462 7463 body_params = None 7464 # HTTP header `Accept` 7465 header_params['Accept'] = self.api_client.\ 7466 select_header_accept(['application/json']) 7467 7468 # Authentication setting 7469 auth_settings = [] 7470 7471 return self.api_client.call_api(resource_path, 'GET', 7472 path_params, 7473 query_params, 7474 header_params, 7475 body=body_params, 7476 post_params=form_params, 7477 files=local_var_files, 7478 response_type='DocGenFormFieldResponse', 7479 auth_settings=auth_settings, 7480 callback=params.get('callback'), 7481 _return_http_data_only=params.get('_return_http_data_only'), 7482 _preload_content=params.get('_preload_content', True), 7483 _request_timeout=params.get('_request_timeout'), 7484 collection_formats=collection_formats)
Returns formfields for an envelope
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
DocGenFormFieldResponse If the method is called asynchronously, returns the request thread.
def
get_envelope_document_html_definitions(self, account_id, document_id, envelope_id, **kwargs)
7486 def get_envelope_document_html_definitions(self, account_id, document_id, envelope_id, **kwargs): 7487 """ 7488 Get the Original HTML Definition used to generate the Responsive HTML for a given document. 7489 7490 This method makes a synchronous HTTP request by default. To make an 7491 asynchronous HTTP request, please define a `callback` function 7492 to be invoked when receiving the response. 7493 >>> def callback_function(response): 7494 >>> pprint(response) 7495 >>> 7496 >>> thread = api.get_envelope_document_html_definitions(account_id, document_id, envelope_id, callback=callback_function) 7497 7498 :param callback function: The callback function 7499 for asynchronous request. (optional) 7500 :param str account_id: The external account number (int) or account ID Guid. (required) 7501 :param str document_id: The ID of the document being accessed. (required) 7502 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7503 :return: DocumentHtmlDefinitionOriginals 7504 If the method is called asynchronously, 7505 returns the request thread. 7506 """ 7507 kwargs['_return_http_data_only'] = True 7508 if kwargs.get('callback'): 7509 return self.get_envelope_document_html_definitions_with_http_info(account_id, document_id, envelope_id, **kwargs) 7510 else: 7511 (data) = self.get_envelope_document_html_definitions_with_http_info(account_id, document_id, envelope_id, **kwargs) 7512 return data
Get the Original HTML Definition used to generate the Responsive HTML for a given document.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_envelope_document_html_definitions(account_id, document_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
DocumentHtmlDefinitionOriginals If the method is called asynchronously, returns the request thread.
def
get_envelope_document_html_definitions_with_http_info(self, account_id, document_id, envelope_id, **kwargs)
7514 def get_envelope_document_html_definitions_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 7515 """ 7516 Get the Original HTML Definition used to generate the Responsive HTML for a given document. 7517 7518 This method makes a synchronous HTTP request by default. To make an 7519 asynchronous HTTP request, please define a `callback` function 7520 to be invoked when receiving the response. 7521 >>> def callback_function(response): 7522 >>> pprint(response) 7523 >>> 7524 >>> thread = api.get_envelope_document_html_definitions_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 7525 7526 :param callback function: The callback function 7527 for asynchronous request. (optional) 7528 :param str account_id: The external account number (int) or account ID Guid. (required) 7529 :param str document_id: The ID of the document being accessed. (required) 7530 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7531 :return: DocumentHtmlDefinitionOriginals 7532 If the method is called asynchronously, 7533 returns the request thread. 7534 """ 7535 7536 all_params = ['account_id', 'document_id', 'envelope_id'] 7537 all_params.append('callback') 7538 all_params.append('_return_http_data_only') 7539 all_params.append('_preload_content') 7540 all_params.append('_request_timeout') 7541 7542 params = locals() 7543 for key, val in iteritems(params['kwargs']): 7544 if key not in all_params: 7545 raise TypeError( 7546 "Got an unexpected keyword argument '%s'" 7547 " to method get_envelope_document_html_definitions" % key 7548 ) 7549 params[key] = val 7550 del params['kwargs'] 7551 # verify the required parameter 'account_id' is set 7552 if ('account_id' not in params) or (params['account_id'] is None): 7553 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_document_html_definitions`") 7554 # verify the required parameter 'document_id' is set 7555 if ('document_id' not in params) or (params['document_id'] is None): 7556 raise ValueError("Missing the required parameter `document_id` when calling `get_envelope_document_html_definitions`") 7557 # verify the required parameter 'envelope_id' is set 7558 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7559 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_document_html_definitions`") 7560 7561 7562 collection_formats = {} 7563 7564 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/html_definitions'.replace('{format}', 'json') 7565 path_params = {} 7566 if 'account_id' in params: 7567 path_params['accountId'] = params['account_id'] 7568 if 'document_id' in params: 7569 path_params['documentId'] = params['document_id'] 7570 if 'envelope_id' in params: 7571 path_params['envelopeId'] = params['envelope_id'] 7572 7573 query_params = {} 7574 7575 header_params = {} 7576 7577 form_params = [] 7578 local_var_files = {} 7579 7580 body_params = None 7581 # HTTP header `Accept` 7582 header_params['Accept'] = self.api_client.\ 7583 select_header_accept(['application/json']) 7584 7585 # Authentication setting 7586 auth_settings = [] 7587 7588 return self.api_client.call_api(resource_path, 'GET', 7589 path_params, 7590 query_params, 7591 header_params, 7592 body=body_params, 7593 post_params=form_params, 7594 files=local_var_files, 7595 response_type='DocumentHtmlDefinitionOriginals', 7596 auth_settings=auth_settings, 7597 callback=params.get('callback'), 7598 _return_http_data_only=params.get('_return_http_data_only'), 7599 _preload_content=params.get('_preload_content', True), 7600 _request_timeout=params.get('_request_timeout'), 7601 collection_formats=collection_formats)
Get the Original HTML Definition used to generate the Responsive HTML for a given document.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_envelope_document_html_definitions_with_http_info(account_id, document_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
DocumentHtmlDefinitionOriginals If the method is called asynchronously, returns the request thread.
def
get_envelope_html_definitions(self, account_id, envelope_id, **kwargs)
7603 def get_envelope_html_definitions(self, account_id, envelope_id, **kwargs): 7604 """ 7605 Get the Original HTML Definition used to generate the Responsive HTML for the envelope. 7606 7607 This method makes a synchronous HTTP request by default. To make an 7608 asynchronous HTTP request, please define a `callback` function 7609 to be invoked when receiving the response. 7610 >>> def callback_function(response): 7611 >>> pprint(response) 7612 >>> 7613 >>> thread = api.get_envelope_html_definitions(account_id, envelope_id, callback=callback_function) 7614 7615 :param callback function: The callback function 7616 for asynchronous request. (optional) 7617 :param str account_id: The external account number (int) or account ID Guid. (required) 7618 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7619 :return: DocumentHtmlDefinitionOriginals 7620 If the method is called asynchronously, 7621 returns the request thread. 7622 """ 7623 kwargs['_return_http_data_only'] = True 7624 if kwargs.get('callback'): 7625 return self.get_envelope_html_definitions_with_http_info(account_id, envelope_id, **kwargs) 7626 else: 7627 (data) = self.get_envelope_html_definitions_with_http_info(account_id, envelope_id, **kwargs) 7628 return data
Get the Original HTML Definition used to generate the Responsive HTML for the envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_envelope_html_definitions(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
DocumentHtmlDefinitionOriginals If the method is called asynchronously, returns the request thread.
def
get_envelope_html_definitions_with_http_info(self, account_id, envelope_id, **kwargs)
7630 def get_envelope_html_definitions_with_http_info(self, account_id, envelope_id, **kwargs): 7631 """ 7632 Get the Original HTML Definition used to generate the Responsive HTML for the envelope. 7633 7634 This method makes a synchronous HTTP request by default. To make an 7635 asynchronous HTTP request, please define a `callback` function 7636 to be invoked when receiving the response. 7637 >>> def callback_function(response): 7638 >>> pprint(response) 7639 >>> 7640 >>> thread = api.get_envelope_html_definitions_with_http_info(account_id, envelope_id, callback=callback_function) 7641 7642 :param callback function: The callback function 7643 for asynchronous request. (optional) 7644 :param str account_id: The external account number (int) or account ID Guid. (required) 7645 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7646 :return: DocumentHtmlDefinitionOriginals 7647 If the method is called asynchronously, 7648 returns the request thread. 7649 """ 7650 7651 all_params = ['account_id', 'envelope_id'] 7652 all_params.append('callback') 7653 all_params.append('_return_http_data_only') 7654 all_params.append('_preload_content') 7655 all_params.append('_request_timeout') 7656 7657 params = locals() 7658 for key, val in iteritems(params['kwargs']): 7659 if key not in all_params: 7660 raise TypeError( 7661 "Got an unexpected keyword argument '%s'" 7662 " to method get_envelope_html_definitions" % key 7663 ) 7664 params[key] = val 7665 del params['kwargs'] 7666 # verify the required parameter 'account_id' is set 7667 if ('account_id' not in params) or (params['account_id'] is None): 7668 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_html_definitions`") 7669 # verify the required parameter 'envelope_id' is set 7670 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7671 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_html_definitions`") 7672 7673 7674 collection_formats = {} 7675 7676 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/html_definitions'.replace('{format}', 'json') 7677 path_params = {} 7678 if 'account_id' in params: 7679 path_params['accountId'] = params['account_id'] 7680 if 'envelope_id' in params: 7681 path_params['envelopeId'] = params['envelope_id'] 7682 7683 query_params = {} 7684 7685 header_params = {} 7686 7687 form_params = [] 7688 local_var_files = {} 7689 7690 body_params = None 7691 # HTTP header `Accept` 7692 header_params['Accept'] = self.api_client.\ 7693 select_header_accept(['application/json']) 7694 7695 # Authentication setting 7696 auth_settings = [] 7697 7698 return self.api_client.call_api(resource_path, 'GET', 7699 path_params, 7700 query_params, 7701 header_params, 7702 body=body_params, 7703 post_params=form_params, 7704 files=local_var_files, 7705 response_type='DocumentHtmlDefinitionOriginals', 7706 auth_settings=auth_settings, 7707 callback=params.get('callback'), 7708 _return_http_data_only=params.get('_return_http_data_only'), 7709 _preload_content=params.get('_preload_content', True), 7710 _request_timeout=params.get('_request_timeout'), 7711 collection_formats=collection_formats)
Get the Original HTML Definition used to generate the Responsive HTML for the envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_envelope_html_definitions_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
DocumentHtmlDefinitionOriginals If the method is called asynchronously, returns the request thread.
def
get_envelope_scheduled_sending_definition(self, account_id, envelope_id, **kwargs)
7713 def get_envelope_scheduled_sending_definition(self, account_id, envelope_id, **kwargs): 7714 """ 7715 Returns the scheduled sending rules for an envelope's workflow definition. 7716 This method makes a synchronous HTTP request by default. To make an 7717 asynchronous HTTP request, please define a `callback` function 7718 to be invoked when receiving the response. 7719 >>> def callback_function(response): 7720 >>> pprint(response) 7721 >>> 7722 >>> thread = api.get_envelope_scheduled_sending_definition(account_id, envelope_id, callback=callback_function) 7723 7724 :param callback function: The callback function 7725 for asynchronous request. (optional) 7726 :param str account_id: The external account number (int) or account ID Guid. (required) 7727 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7728 :return: ScheduledSending 7729 If the method is called asynchronously, 7730 returns the request thread. 7731 """ 7732 kwargs['_return_http_data_only'] = True 7733 if kwargs.get('callback'): 7734 return self.get_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 7735 else: 7736 (data) = self.get_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 7737 return data
Returns the scheduled sending rules for an envelope's workflow definition.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_envelope_scheduled_sending_definition(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
ScheduledSending If the method is called asynchronously, returns the request thread.
def
get_envelope_scheduled_sending_definition_with_http_info(self, account_id, envelope_id, **kwargs)
7739 def get_envelope_scheduled_sending_definition_with_http_info(self, account_id, envelope_id, **kwargs): 7740 """ 7741 Returns the scheduled sending rules for an envelope's workflow definition. 7742 This method makes a synchronous HTTP request by default. To make an 7743 asynchronous HTTP request, please define a `callback` function 7744 to be invoked when receiving the response. 7745 >>> def callback_function(response): 7746 >>> pprint(response) 7747 >>> 7748 >>> thread = api.get_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, callback=callback_function) 7749 7750 :param callback function: The callback function 7751 for asynchronous request. (optional) 7752 :param str account_id: The external account number (int) or account ID Guid. (required) 7753 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7754 :return: ScheduledSending 7755 If the method is called asynchronously, 7756 returns the request thread. 7757 """ 7758 7759 all_params = ['account_id', 'envelope_id'] 7760 all_params.append('callback') 7761 all_params.append('_return_http_data_only') 7762 all_params.append('_preload_content') 7763 all_params.append('_request_timeout') 7764 7765 params = locals() 7766 for key, val in iteritems(params['kwargs']): 7767 if key not in all_params: 7768 raise TypeError( 7769 "Got an unexpected keyword argument '%s'" 7770 " to method get_envelope_scheduled_sending_definition" % key 7771 ) 7772 params[key] = val 7773 del params['kwargs'] 7774 # verify the required parameter 'account_id' is set 7775 if ('account_id' not in params) or (params['account_id'] is None): 7776 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_scheduled_sending_definition`") 7777 # verify the required parameter 'envelope_id' is set 7778 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7779 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_scheduled_sending_definition`") 7780 7781 7782 collection_formats = {} 7783 7784 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/scheduledSending'.replace('{format}', 'json') 7785 path_params = {} 7786 if 'account_id' in params: 7787 path_params['accountId'] = params['account_id'] 7788 if 'envelope_id' in params: 7789 path_params['envelopeId'] = params['envelope_id'] 7790 7791 query_params = {} 7792 7793 header_params = {} 7794 7795 form_params = [] 7796 local_var_files = {} 7797 7798 body_params = None 7799 # HTTP header `Accept` 7800 header_params['Accept'] = self.api_client.\ 7801 select_header_accept(['application/json']) 7802 7803 # Authentication setting 7804 auth_settings = [] 7805 7806 return self.api_client.call_api(resource_path, 'GET', 7807 path_params, 7808 query_params, 7809 header_params, 7810 body=body_params, 7811 post_params=form_params, 7812 files=local_var_files, 7813 response_type='ScheduledSending', 7814 auth_settings=auth_settings, 7815 callback=params.get('callback'), 7816 _return_http_data_only=params.get('_return_http_data_only'), 7817 _preload_content=params.get('_preload_content', True), 7818 _request_timeout=params.get('_request_timeout'), 7819 collection_formats=collection_formats)
Returns the scheduled sending rules for an envelope's workflow definition.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
ScheduledSending If the method is called asynchronously, returns the request thread.
def
get_envelope_transfer_rules(self, account_id, **kwargs)
7821 def get_envelope_transfer_rules(self, account_id, **kwargs): 7822 """ 7823 Returns a list of envelope transfer rules in the specified account. 7824 This method retrieves a list of envelope transfer rules associated with an account. **Note:** Only Administrators can create and use envelope transfer rules. In addition, to use envelope transfer rules, the **Transfer Custody** feature must be enabled for your account. 7825 This method makes a synchronous HTTP request by default. To make an 7826 asynchronous HTTP request, please define a `callback` function 7827 to be invoked when receiving the response. 7828 >>> def callback_function(response): 7829 >>> pprint(response) 7830 >>> 7831 >>> thread = api.get_envelope_transfer_rules(account_id, callback=callback_function) 7832 7833 :param callback function: The callback function 7834 for asynchronous request. (optional) 7835 :param str account_id: The external account number (int) or account ID Guid. (required) 7836 :param str count: 7837 :param str start_position: 7838 :return: EnvelopeTransferRuleInformation 7839 If the method is called asynchronously, 7840 returns the request thread. 7841 """ 7842 kwargs['_return_http_data_only'] = True 7843 if kwargs.get('callback'): 7844 return self.get_envelope_transfer_rules_with_http_info(account_id, **kwargs) 7845 else: 7846 (data) = self.get_envelope_transfer_rules_with_http_info(account_id, **kwargs) 7847 return data
Returns a list of envelope transfer rules in the specified account.
This method retrieves a list of envelope transfer rules associated with an account. Note: Only Administrators can create and use envelope transfer rules. In addition, to use envelope transfer rules, the Transfer Custody feature must be enabled for your account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_envelope_transfer_rules(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str count:
- str start_position:
Returns
EnvelopeTransferRuleInformation If the method is called asynchronously, returns the request thread.
def
get_envelope_transfer_rules_with_http_info(self, account_id, **kwargs)
7849 def get_envelope_transfer_rules_with_http_info(self, account_id, **kwargs): 7850 """ 7851 Returns a list of envelope transfer rules in the specified account. 7852 This method retrieves a list of envelope transfer rules associated with an account. **Note:** Only Administrators can create and use envelope transfer rules. In addition, to use envelope transfer rules, the **Transfer Custody** feature must be enabled for your account. 7853 This method makes a synchronous HTTP request by default. To make an 7854 asynchronous HTTP request, please define a `callback` function 7855 to be invoked when receiving the response. 7856 >>> def callback_function(response): 7857 >>> pprint(response) 7858 >>> 7859 >>> thread = api.get_envelope_transfer_rules_with_http_info(account_id, callback=callback_function) 7860 7861 :param callback function: The callback function 7862 for asynchronous request. (optional) 7863 :param str account_id: The external account number (int) or account ID Guid. (required) 7864 :param str count: 7865 :param str start_position: 7866 :return: EnvelopeTransferRuleInformation 7867 If the method is called asynchronously, 7868 returns the request thread. 7869 """ 7870 7871 all_params = ['account_id', 'count', 'start_position'] 7872 all_params.append('callback') 7873 all_params.append('_return_http_data_only') 7874 all_params.append('_preload_content') 7875 all_params.append('_request_timeout') 7876 7877 params = locals() 7878 for key, val in iteritems(params['kwargs']): 7879 if key not in all_params: 7880 raise TypeError( 7881 "Got an unexpected keyword argument '%s'" 7882 " to method get_envelope_transfer_rules" % key 7883 ) 7884 params[key] = val 7885 del params['kwargs'] 7886 # verify the required parameter 'account_id' is set 7887 if ('account_id' not in params) or (params['account_id'] is None): 7888 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_transfer_rules`") 7889 7890 7891 collection_formats = {} 7892 7893 resource_path = '/v2.1/accounts/{accountId}/envelopes/transfer_rules'.replace('{format}', 'json') 7894 path_params = {} 7895 if 'account_id' in params: 7896 path_params['accountId'] = params['account_id'] 7897 7898 query_params = {} 7899 if 'count' in params: 7900 query_params['count'] = params['count'] 7901 if 'start_position' in params: 7902 query_params['start_position'] = params['start_position'] 7903 7904 header_params = {} 7905 7906 form_params = [] 7907 local_var_files = {} 7908 7909 body_params = None 7910 # HTTP header `Accept` 7911 header_params['Accept'] = self.api_client.\ 7912 select_header_accept(['application/json']) 7913 7914 # Authentication setting 7915 auth_settings = [] 7916 7917 return self.api_client.call_api(resource_path, 'GET', 7918 path_params, 7919 query_params, 7920 header_params, 7921 body=body_params, 7922 post_params=form_params, 7923 files=local_var_files, 7924 response_type='EnvelopeTransferRuleInformation', 7925 auth_settings=auth_settings, 7926 callback=params.get('callback'), 7927 _return_http_data_only=params.get('_return_http_data_only'), 7928 _preload_content=params.get('_preload_content', True), 7929 _request_timeout=params.get('_request_timeout'), 7930 collection_formats=collection_formats)
Returns a list of envelope transfer rules in the specified account.
This method retrieves a list of envelope transfer rules associated with an account. Note: Only Administrators can create and use envelope transfer rules. In addition, to use envelope transfer rules, the Transfer Custody feature must be enabled for your account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_envelope_transfer_rules_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str count:
- str start_position:
Returns
EnvelopeTransferRuleInformation If the method is called asynchronously, returns the request thread.
def
get_envelope_workflow_definition(self, account_id, envelope_id, **kwargs)
7932 def get_envelope_workflow_definition(self, account_id, envelope_id, **kwargs): 7933 """ 7934 Returns the workflow definition for an envelope. 7935 Returns an envelope's workflow definition if the envelope specified by `envelopeId` has one. 7936 This method makes a synchronous HTTP request by default. To make an 7937 asynchronous HTTP request, please define a `callback` function 7938 to be invoked when receiving the response. 7939 >>> def callback_function(response): 7940 >>> pprint(response) 7941 >>> 7942 >>> thread = api.get_envelope_workflow_definition(account_id, envelope_id, callback=callback_function) 7943 7944 :param callback function: The callback function 7945 for asynchronous request. (optional) 7946 :param str account_id: The external account number (int) or account ID Guid. (required) 7947 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7948 :return: Workflow 7949 If the method is called asynchronously, 7950 returns the request thread. 7951 """ 7952 kwargs['_return_http_data_only'] = True 7953 if kwargs.get('callback'): 7954 return self.get_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 7955 else: 7956 (data) = self.get_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 7957 return data
Returns the workflow definition for an envelope.
Returns an envelope's workflow definition if the envelope specified by envelopeId has one.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_envelope_workflow_definition(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
Workflow If the method is called asynchronously, returns the request thread.
def
get_envelope_workflow_definition_with_http_info(self, account_id, envelope_id, **kwargs)
7959 def get_envelope_workflow_definition_with_http_info(self, account_id, envelope_id, **kwargs): 7960 """ 7961 Returns the workflow definition for an envelope. 7962 Returns an envelope's workflow definition if the envelope specified by `envelopeId` has one. 7963 This method makes a synchronous HTTP request by default. To make an 7964 asynchronous HTTP request, please define a `callback` function 7965 to be invoked when receiving the response. 7966 >>> def callback_function(response): 7967 >>> pprint(response) 7968 >>> 7969 >>> thread = api.get_envelope_workflow_definition_with_http_info(account_id, envelope_id, callback=callback_function) 7970 7971 :param callback function: The callback function 7972 for asynchronous request. (optional) 7973 :param str account_id: The external account number (int) or account ID Guid. (required) 7974 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7975 :return: Workflow 7976 If the method is called asynchronously, 7977 returns the request thread. 7978 """ 7979 7980 all_params = ['account_id', 'envelope_id'] 7981 all_params.append('callback') 7982 all_params.append('_return_http_data_only') 7983 all_params.append('_preload_content') 7984 all_params.append('_request_timeout') 7985 7986 params = locals() 7987 for key, val in iteritems(params['kwargs']): 7988 if key not in all_params: 7989 raise TypeError( 7990 "Got an unexpected keyword argument '%s'" 7991 " to method get_envelope_workflow_definition" % key 7992 ) 7993 params[key] = val 7994 del params['kwargs'] 7995 # verify the required parameter 'account_id' is set 7996 if ('account_id' not in params) or (params['account_id'] is None): 7997 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_workflow_definition`") 7998 # verify the required parameter 'envelope_id' is set 7999 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8000 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_workflow_definition`") 8001 8002 8003 collection_formats = {} 8004 8005 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow'.replace('{format}', 'json') 8006 path_params = {} 8007 if 'account_id' in params: 8008 path_params['accountId'] = params['account_id'] 8009 if 'envelope_id' in params: 8010 path_params['envelopeId'] = params['envelope_id'] 8011 8012 query_params = {} 8013 8014 header_params = {} 8015 8016 form_params = [] 8017 local_var_files = {} 8018 8019 body_params = None 8020 # HTTP header `Accept` 8021 header_params['Accept'] = self.api_client.\ 8022 select_header_accept(['application/json']) 8023 8024 # Authentication setting 8025 auth_settings = [] 8026 8027 return self.api_client.call_api(resource_path, 'GET', 8028 path_params, 8029 query_params, 8030 header_params, 8031 body=body_params, 8032 post_params=form_params, 8033 files=local_var_files, 8034 response_type='Workflow', 8035 auth_settings=auth_settings, 8036 callback=params.get('callback'), 8037 _return_http_data_only=params.get('_return_http_data_only'), 8038 _preload_content=params.get('_preload_content', True), 8039 _request_timeout=params.get('_request_timeout'), 8040 collection_formats=collection_formats)
Returns the workflow definition for an envelope.
Returns an envelope's workflow definition if the envelope specified by envelopeId has one.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_envelope_workflow_definition_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
Workflow If the method is called asynchronously, returns the request thread.
def
get_envelope_workflow_step_definition(self, account_id, envelope_id, workflow_step_id, **kwargs)
8042 def get_envelope_workflow_step_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 8043 """ 8044 Returns the workflow step definition for an envelope by step id. 8045 This method makes a synchronous HTTP request by default. To make an 8046 asynchronous HTTP request, please define a `callback` function 8047 to be invoked when receiving the response. 8048 >>> def callback_function(response): 8049 >>> pprint(response) 8050 >>> 8051 >>> thread = api.get_envelope_workflow_step_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 8052 8053 :param callback function: The callback function 8054 for asynchronous request. (optional) 8055 :param str account_id: The external account number (int) or account ID Guid. (required) 8056 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8057 :param str workflow_step_id: (required) 8058 :return: WorkflowStep 8059 If the method is called asynchronously, 8060 returns the request thread. 8061 """ 8062 kwargs['_return_http_data_only'] = True 8063 if kwargs.get('callback'): 8064 return self.get_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 8065 else: 8066 (data) = self.get_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 8067 return data
Returns the workflow step definition for an envelope by step id.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_envelope_workflow_step_definition(account_id, envelope_id, workflow_step_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str workflow_step_id: (required)
Returns
WorkflowStep If the method is called asynchronously, returns the request thread.
def
get_envelope_workflow_step_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs)
8069 def get_envelope_workflow_step_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 8070 """ 8071 Returns the workflow step definition for an envelope by step id. 8072 This method makes a synchronous HTTP request by default. To make an 8073 asynchronous HTTP request, please define a `callback` function 8074 to be invoked when receiving the response. 8075 >>> def callback_function(response): 8076 >>> pprint(response) 8077 >>> 8078 >>> thread = api.get_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 8079 8080 :param callback function: The callback function 8081 for asynchronous request. (optional) 8082 :param str account_id: The external account number (int) or account ID Guid. (required) 8083 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8084 :param str workflow_step_id: (required) 8085 :return: WorkflowStep 8086 If the method is called asynchronously, 8087 returns the request thread. 8088 """ 8089 8090 all_params = ['account_id', 'envelope_id', 'workflow_step_id'] 8091 all_params.append('callback') 8092 all_params.append('_return_http_data_only') 8093 all_params.append('_preload_content') 8094 all_params.append('_request_timeout') 8095 8096 params = locals() 8097 for key, val in iteritems(params['kwargs']): 8098 if key not in all_params: 8099 raise TypeError( 8100 "Got an unexpected keyword argument '%s'" 8101 " to method get_envelope_workflow_step_definition" % key 8102 ) 8103 params[key] = val 8104 del params['kwargs'] 8105 # verify the required parameter 'account_id' is set 8106 if ('account_id' not in params) or (params['account_id'] is None): 8107 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_workflow_step_definition`") 8108 # verify the required parameter 'envelope_id' is set 8109 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8110 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_workflow_step_definition`") 8111 # verify the required parameter 'workflow_step_id' is set 8112 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 8113 raise ValueError("Missing the required parameter `workflow_step_id` when calling `get_envelope_workflow_step_definition`") 8114 8115 8116 collection_formats = {} 8117 8118 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 8119 path_params = {} 8120 if 'account_id' in params: 8121 path_params['accountId'] = params['account_id'] 8122 if 'envelope_id' in params: 8123 path_params['envelopeId'] = params['envelope_id'] 8124 if 'workflow_step_id' in params: 8125 path_params['workflowStepId'] = params['workflow_step_id'] 8126 8127 query_params = {} 8128 8129 header_params = {} 8130 8131 form_params = [] 8132 local_var_files = {} 8133 8134 body_params = None 8135 # HTTP header `Accept` 8136 header_params['Accept'] = self.api_client.\ 8137 select_header_accept(['application/json']) 8138 8139 # Authentication setting 8140 auth_settings = [] 8141 8142 return self.api_client.call_api(resource_path, 'GET', 8143 path_params, 8144 query_params, 8145 header_params, 8146 body=body_params, 8147 post_params=form_params, 8148 files=local_var_files, 8149 response_type='WorkflowStep', 8150 auth_settings=auth_settings, 8151 callback=params.get('callback'), 8152 _return_http_data_only=params.get('_return_http_data_only'), 8153 _preload_content=params.get('_preload_content', True), 8154 _request_timeout=params.get('_request_timeout'), 8155 collection_formats=collection_formats)
Returns the workflow step definition for an envelope by step id.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str workflow_step_id: (required)
Returns
WorkflowStep If the method is called asynchronously, returns the request thread.
def
get_form_data(self, account_id, envelope_id, **kwargs)
8157 def get_form_data(self, account_id, envelope_id, **kwargs): 8158 """ 8159 Returns envelope form data for an existing envelope. 8160 This method downloads the envelope and tab data (also called form data) from any in-process, completed, or canceled envelope that you sent or that is shared with you. Recipients who are also full administrators on an account can view form data for any envelopes that another user on the account has sent to them. **Note:** To use this feature, the Sending Setting \"Allow sender to download form data\" must be enabled for the account. ### Related topics - [How to get envelope tab values](/docs/esign-rest-api/how-to/get-envelope-tab-values/) 8161 This method makes a synchronous HTTP request by default. To make an 8162 asynchronous HTTP request, please define a `callback` function 8163 to be invoked when receiving the response. 8164 >>> def callback_function(response): 8165 >>> pprint(response) 8166 >>> 8167 >>> thread = api.get_form_data(account_id, envelope_id, callback=callback_function) 8168 8169 :param callback function: The callback function 8170 for asynchronous request. (optional) 8171 :param str account_id: The external account number (int) or account ID Guid. (required) 8172 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8173 :return: EnvelopeFormData 8174 If the method is called asynchronously, 8175 returns the request thread. 8176 """ 8177 kwargs['_return_http_data_only'] = True 8178 if kwargs.get('callback'): 8179 return self.get_form_data_with_http_info(account_id, envelope_id, **kwargs) 8180 else: 8181 (data) = self.get_form_data_with_http_info(account_id, envelope_id, **kwargs) 8182 return data
Returns envelope form data for an existing envelope.
This method downloads the envelope and tab data (also called form data) from any in-process, completed, or canceled envelope that you sent or that is shared with you. Recipients who are also full administrators on an account can view form data for any envelopes that another user on the account has sent to them. Note: To use this feature, the Sending Setting "Allow sender to download form data" must be enabled for the account. ### Related topics - How to get envelope tab values
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_form_data(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
EnvelopeFormData If the method is called asynchronously, returns the request thread.
def
get_form_data_with_http_info(self, account_id, envelope_id, **kwargs)
8184 def get_form_data_with_http_info(self, account_id, envelope_id, **kwargs): 8185 """ 8186 Returns envelope form data for an existing envelope. 8187 This method downloads the envelope and tab data (also called form data) from any in-process, completed, or canceled envelope that you sent or that is shared with you. Recipients who are also full administrators on an account can view form data for any envelopes that another user on the account has sent to them. **Note:** To use this feature, the Sending Setting \"Allow sender to download form data\" must be enabled for the account. ### Related topics - [How to get envelope tab values](/docs/esign-rest-api/how-to/get-envelope-tab-values/) 8188 This method makes a synchronous HTTP request by default. To make an 8189 asynchronous HTTP request, please define a `callback` function 8190 to be invoked when receiving the response. 8191 >>> def callback_function(response): 8192 >>> pprint(response) 8193 >>> 8194 >>> thread = api.get_form_data_with_http_info(account_id, envelope_id, callback=callback_function) 8195 8196 :param callback function: The callback function 8197 for asynchronous request. (optional) 8198 :param str account_id: The external account number (int) or account ID Guid. (required) 8199 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8200 :return: EnvelopeFormData 8201 If the method is called asynchronously, 8202 returns the request thread. 8203 """ 8204 8205 all_params = ['account_id', 'envelope_id'] 8206 all_params.append('callback') 8207 all_params.append('_return_http_data_only') 8208 all_params.append('_preload_content') 8209 all_params.append('_request_timeout') 8210 8211 params = locals() 8212 for key, val in iteritems(params['kwargs']): 8213 if key not in all_params: 8214 raise TypeError( 8215 "Got an unexpected keyword argument '%s'" 8216 " to method get_form_data" % key 8217 ) 8218 params[key] = val 8219 del params['kwargs'] 8220 # verify the required parameter 'account_id' is set 8221 if ('account_id' not in params) or (params['account_id'] is None): 8222 raise ValueError("Missing the required parameter `account_id` when calling `get_form_data`") 8223 # verify the required parameter 'envelope_id' is set 8224 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8225 raise ValueError("Missing the required parameter `envelope_id` when calling `get_form_data`") 8226 8227 8228 collection_formats = {} 8229 8230 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/form_data'.replace('{format}', 'json') 8231 path_params = {} 8232 if 'account_id' in params: 8233 path_params['accountId'] = params['account_id'] 8234 if 'envelope_id' in params: 8235 path_params['envelopeId'] = params['envelope_id'] 8236 8237 query_params = {} 8238 8239 header_params = {} 8240 8241 form_params = [] 8242 local_var_files = {} 8243 8244 body_params = None 8245 # HTTP header `Accept` 8246 header_params['Accept'] = self.api_client.\ 8247 select_header_accept(['application/json']) 8248 8249 # Authentication setting 8250 auth_settings = [] 8251 8252 return self.api_client.call_api(resource_path, 'GET', 8253 path_params, 8254 query_params, 8255 header_params, 8256 body=body_params, 8257 post_params=form_params, 8258 files=local_var_files, 8259 response_type='EnvelopeFormData', 8260 auth_settings=auth_settings, 8261 callback=params.get('callback'), 8262 _return_http_data_only=params.get('_return_http_data_only'), 8263 _preload_content=params.get('_preload_content', True), 8264 _request_timeout=params.get('_request_timeout'), 8265 collection_formats=collection_formats)
Returns envelope form data for an existing envelope.
This method downloads the envelope and tab data (also called form data) from any in-process, completed, or canceled envelope that you sent or that is shared with you. Recipients who are also full administrators on an account can view form data for any envelopes that another user on the account has sent to them. Note: To use this feature, the Sending Setting "Allow sender to download form data" must be enabled for the account. ### Related topics - How to get envelope tab values
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_form_data_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
EnvelopeFormData If the method is called asynchronously, returns the request thread.
def
get_lock(self, account_id, envelope_id, **kwargs)
8267 def get_lock(self, account_id, envelope_id, **kwargs): 8268 """ 8269 Gets envelope lock information. 8270 Retrieves general information about the envelope lock. If the call is made by the locked by user and the request has the same integrator key as original, then the `X-DocuSign-Edit` header and additional lock information is included in the response. This allows users to recover a lost editing session token and the `X-DocuSign-Edit` header. 8271 This method makes a synchronous HTTP request by default. To make an 8272 asynchronous HTTP request, please define a `callback` function 8273 to be invoked when receiving the response. 8274 >>> def callback_function(response): 8275 >>> pprint(response) 8276 >>> 8277 >>> thread = api.get_lock(account_id, envelope_id, callback=callback_function) 8278 8279 :param callback function: The callback function 8280 for asynchronous request. (optional) 8281 :param str account_id: The external account number (int) or account ID Guid. (required) 8282 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8283 :return: LockInformation 8284 If the method is called asynchronously, 8285 returns the request thread. 8286 """ 8287 kwargs['_return_http_data_only'] = True 8288 if kwargs.get('callback'): 8289 return self.get_lock_with_http_info(account_id, envelope_id, **kwargs) 8290 else: 8291 (data) = self.get_lock_with_http_info(account_id, envelope_id, **kwargs) 8292 return data
Gets envelope lock information.
Retrieves general information about the envelope lock. If the call is made by the locked by user and the request has the same integrator key as original, then the X-DocuSign-Edit header and additional lock information is included in the response. This allows users to recover a lost editing session token and the X-DocuSign-Edit header.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_lock(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
LockInformation If the method is called asynchronously, returns the request thread.
def
get_lock_with_http_info(self, account_id, envelope_id, **kwargs)
8294 def get_lock_with_http_info(self, account_id, envelope_id, **kwargs): 8295 """ 8296 Gets envelope lock information. 8297 Retrieves general information about the envelope lock. If the call is made by the locked by user and the request has the same integrator key as original, then the `X-DocuSign-Edit` header and additional lock information is included in the response. This allows users to recover a lost editing session token and the `X-DocuSign-Edit` header. 8298 This method makes a synchronous HTTP request by default. To make an 8299 asynchronous HTTP request, please define a `callback` function 8300 to be invoked when receiving the response. 8301 >>> def callback_function(response): 8302 >>> pprint(response) 8303 >>> 8304 >>> thread = api.get_lock_with_http_info(account_id, envelope_id, callback=callback_function) 8305 8306 :param callback function: The callback function 8307 for asynchronous request. (optional) 8308 :param str account_id: The external account number (int) or account ID Guid. (required) 8309 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8310 :return: LockInformation 8311 If the method is called asynchronously, 8312 returns the request thread. 8313 """ 8314 8315 all_params = ['account_id', 'envelope_id'] 8316 all_params.append('callback') 8317 all_params.append('_return_http_data_only') 8318 all_params.append('_preload_content') 8319 all_params.append('_request_timeout') 8320 8321 params = locals() 8322 for key, val in iteritems(params['kwargs']): 8323 if key not in all_params: 8324 raise TypeError( 8325 "Got an unexpected keyword argument '%s'" 8326 " to method get_lock" % key 8327 ) 8328 params[key] = val 8329 del params['kwargs'] 8330 # verify the required parameter 'account_id' is set 8331 if ('account_id' not in params) or (params['account_id'] is None): 8332 raise ValueError("Missing the required parameter `account_id` when calling `get_lock`") 8333 # verify the required parameter 'envelope_id' is set 8334 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8335 raise ValueError("Missing the required parameter `envelope_id` when calling `get_lock`") 8336 8337 8338 collection_formats = {} 8339 8340 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/lock'.replace('{format}', 'json') 8341 path_params = {} 8342 if 'account_id' in params: 8343 path_params['accountId'] = params['account_id'] 8344 if 'envelope_id' in params: 8345 path_params['envelopeId'] = params['envelope_id'] 8346 8347 query_params = {} 8348 8349 header_params = {} 8350 8351 form_params = [] 8352 local_var_files = {} 8353 8354 body_params = None 8355 # HTTP header `Accept` 8356 header_params['Accept'] = self.api_client.\ 8357 select_header_accept(['application/json']) 8358 8359 # Authentication setting 8360 auth_settings = [] 8361 8362 return self.api_client.call_api(resource_path, 'GET', 8363 path_params, 8364 query_params, 8365 header_params, 8366 body=body_params, 8367 post_params=form_params, 8368 files=local_var_files, 8369 response_type='LockInformation', 8370 auth_settings=auth_settings, 8371 callback=params.get('callback'), 8372 _return_http_data_only=params.get('_return_http_data_only'), 8373 _preload_content=params.get('_preload_content', True), 8374 _request_timeout=params.get('_request_timeout'), 8375 collection_formats=collection_formats)
Gets envelope lock information.
Retrieves general information about the envelope lock. If the call is made by the locked by user and the request has the same integrator key as original, then the X-DocuSign-Edit header and additional lock information is included in the response. This allows users to recover a lost editing session token and the X-DocuSign-Edit header.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_lock_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
LockInformation If the method is called asynchronously, returns the request thread.
def
get_notification_settings(self, account_id, envelope_id, **kwargs)
8377 def get_notification_settings(self, account_id, envelope_id, **kwargs): 8378 """ 8379 Gets envelope notification information. 8380 Retrieves the envelope notification, reminders and expirations, information for an existing envelope. 8381 This method makes a synchronous HTTP request by default. To make an 8382 asynchronous HTTP request, please define a `callback` function 8383 to be invoked when receiving the response. 8384 >>> def callback_function(response): 8385 >>> pprint(response) 8386 >>> 8387 >>> thread = api.get_notification_settings(account_id, envelope_id, callback=callback_function) 8388 8389 :param callback function: The callback function 8390 for asynchronous request. (optional) 8391 :param str account_id: The external account number (int) or account ID Guid. (required) 8392 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8393 :return: Notification 8394 If the method is called asynchronously, 8395 returns the request thread. 8396 """ 8397 kwargs['_return_http_data_only'] = True 8398 if kwargs.get('callback'): 8399 return self.get_notification_settings_with_http_info(account_id, envelope_id, **kwargs) 8400 else: 8401 (data) = self.get_notification_settings_with_http_info(account_id, envelope_id, **kwargs) 8402 return data
Gets envelope notification information.
Retrieves the envelope notification, reminders and expirations, information for an existing envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_notification_settings(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
Notification If the method is called asynchronously, returns the request thread.
def
get_notification_settings_with_http_info(self, account_id, envelope_id, **kwargs)
8404 def get_notification_settings_with_http_info(self, account_id, envelope_id, **kwargs): 8405 """ 8406 Gets envelope notification information. 8407 Retrieves the envelope notification, reminders and expirations, information for an existing envelope. 8408 This method makes a synchronous HTTP request by default. To make an 8409 asynchronous HTTP request, please define a `callback` function 8410 to be invoked when receiving the response. 8411 >>> def callback_function(response): 8412 >>> pprint(response) 8413 >>> 8414 >>> thread = api.get_notification_settings_with_http_info(account_id, envelope_id, callback=callback_function) 8415 8416 :param callback function: The callback function 8417 for asynchronous request. (optional) 8418 :param str account_id: The external account number (int) or account ID Guid. (required) 8419 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8420 :return: Notification 8421 If the method is called asynchronously, 8422 returns the request thread. 8423 """ 8424 8425 all_params = ['account_id', 'envelope_id'] 8426 all_params.append('callback') 8427 all_params.append('_return_http_data_only') 8428 all_params.append('_preload_content') 8429 all_params.append('_request_timeout') 8430 8431 params = locals() 8432 for key, val in iteritems(params['kwargs']): 8433 if key not in all_params: 8434 raise TypeError( 8435 "Got an unexpected keyword argument '%s'" 8436 " to method get_notification_settings" % key 8437 ) 8438 params[key] = val 8439 del params['kwargs'] 8440 # verify the required parameter 'account_id' is set 8441 if ('account_id' not in params) or (params['account_id'] is None): 8442 raise ValueError("Missing the required parameter `account_id` when calling `get_notification_settings`") 8443 # verify the required parameter 'envelope_id' is set 8444 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8445 raise ValueError("Missing the required parameter `envelope_id` when calling `get_notification_settings`") 8446 8447 8448 collection_formats = {} 8449 8450 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/notification'.replace('{format}', 'json') 8451 path_params = {} 8452 if 'account_id' in params: 8453 path_params['accountId'] = params['account_id'] 8454 if 'envelope_id' in params: 8455 path_params['envelopeId'] = params['envelope_id'] 8456 8457 query_params = {} 8458 8459 header_params = {} 8460 8461 form_params = [] 8462 local_var_files = {} 8463 8464 body_params = None 8465 # HTTP header `Accept` 8466 header_params['Accept'] = self.api_client.\ 8467 select_header_accept(['application/json']) 8468 8469 # Authentication setting 8470 auth_settings = [] 8471 8472 return self.api_client.call_api(resource_path, 'GET', 8473 path_params, 8474 query_params, 8475 header_params, 8476 body=body_params, 8477 post_params=form_params, 8478 files=local_var_files, 8479 response_type='Notification', 8480 auth_settings=auth_settings, 8481 callback=params.get('callback'), 8482 _return_http_data_only=params.get('_return_http_data_only'), 8483 _preload_content=params.get('_preload_content', True), 8484 _request_timeout=params.get('_request_timeout'), 8485 collection_formats=collection_formats)
Gets envelope notification information.
Retrieves the envelope notification, reminders and expirations, information for an existing envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_notification_settings_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
Notification If the method is called asynchronously, returns the request thread.
def
get_page_tabs(self, account_id, document_id, envelope_id, page_number, **kwargs)
8487 def get_page_tabs(self, account_id, document_id, envelope_id, page_number, **kwargs): 8488 """ 8489 Returns tabs on the specified page. 8490 Returns the tabs from the page specified by `pageNumber` of the document specified by `documentId` in the envelope specified by `envelopeId`. 8491 This method makes a synchronous HTTP request by default. To make an 8492 asynchronous HTTP request, please define a `callback` function 8493 to be invoked when receiving the response. 8494 >>> def callback_function(response): 8495 >>> pprint(response) 8496 >>> 8497 >>> thread = api.get_page_tabs(account_id, document_id, envelope_id, page_number, callback=callback_function) 8498 8499 :param callback function: The callback function 8500 for asynchronous request. (optional) 8501 :param str account_id: The external account number (int) or account ID Guid. (required) 8502 :param str document_id: The ID of the document being accessed. (required) 8503 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8504 :param str page_number: The page number being accessed. (required) 8505 :return: Tabs 8506 If the method is called asynchronously, 8507 returns the request thread. 8508 """ 8509 kwargs['_return_http_data_only'] = True 8510 if kwargs.get('callback'): 8511 return self.get_page_tabs_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 8512 else: 8513 (data) = self.get_page_tabs_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 8514 return data
Returns tabs on the specified page.
Returns the tabs from the page specified by pageNumber of the document specified by documentId in the envelope specified by envelopeId.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_page_tabs(account_id, document_id, envelope_id, page_number, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str page_number: The page number being accessed. (required)
Returns
Tabs If the method is called asynchronously, returns the request thread.
def
get_page_tabs_with_http_info(self, account_id, document_id, envelope_id, page_number, **kwargs)
8516 def get_page_tabs_with_http_info(self, account_id, document_id, envelope_id, page_number, **kwargs): 8517 """ 8518 Returns tabs on the specified page. 8519 Returns the tabs from the page specified by `pageNumber` of the document specified by `documentId` in the envelope specified by `envelopeId`. 8520 This method makes a synchronous HTTP request by default. To make an 8521 asynchronous HTTP request, please define a `callback` function 8522 to be invoked when receiving the response. 8523 >>> def callback_function(response): 8524 >>> pprint(response) 8525 >>> 8526 >>> thread = api.get_page_tabs_with_http_info(account_id, document_id, envelope_id, page_number, callback=callback_function) 8527 8528 :param callback function: The callback function 8529 for asynchronous request. (optional) 8530 :param str account_id: The external account number (int) or account ID Guid. (required) 8531 :param str document_id: The ID of the document being accessed. (required) 8532 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8533 :param str page_number: The page number being accessed. (required) 8534 :return: Tabs 8535 If the method is called asynchronously, 8536 returns the request thread. 8537 """ 8538 8539 all_params = ['account_id', 'document_id', 'envelope_id', 'page_number'] 8540 all_params.append('callback') 8541 all_params.append('_return_http_data_only') 8542 all_params.append('_preload_content') 8543 all_params.append('_request_timeout') 8544 8545 params = locals() 8546 for key, val in iteritems(params['kwargs']): 8547 if key not in all_params: 8548 raise TypeError( 8549 "Got an unexpected keyword argument '%s'" 8550 " to method get_page_tabs" % key 8551 ) 8552 params[key] = val 8553 del params['kwargs'] 8554 # verify the required parameter 'account_id' is set 8555 if ('account_id' not in params) or (params['account_id'] is None): 8556 raise ValueError("Missing the required parameter `account_id` when calling `get_page_tabs`") 8557 # verify the required parameter 'document_id' is set 8558 if ('document_id' not in params) or (params['document_id'] is None): 8559 raise ValueError("Missing the required parameter `document_id` when calling `get_page_tabs`") 8560 # verify the required parameter 'envelope_id' is set 8561 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8562 raise ValueError("Missing the required parameter `envelope_id` when calling `get_page_tabs`") 8563 # verify the required parameter 'page_number' is set 8564 if ('page_number' not in params) or (params['page_number'] is None): 8565 raise ValueError("Missing the required parameter `page_number` when calling `get_page_tabs`") 8566 8567 8568 collection_formats = {} 8569 8570 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/pages/{pageNumber}/tabs'.replace('{format}', 'json') 8571 path_params = {} 8572 if 'account_id' in params: 8573 path_params['accountId'] = params['account_id'] 8574 if 'document_id' in params: 8575 path_params['documentId'] = params['document_id'] 8576 if 'envelope_id' in params: 8577 path_params['envelopeId'] = params['envelope_id'] 8578 if 'page_number' in params: 8579 path_params['pageNumber'] = params['page_number'] 8580 8581 query_params = {} 8582 8583 header_params = {} 8584 8585 form_params = [] 8586 local_var_files = {} 8587 8588 body_params = None 8589 # HTTP header `Accept` 8590 header_params['Accept'] = self.api_client.\ 8591 select_header_accept(['application/json']) 8592 8593 # Authentication setting 8594 auth_settings = [] 8595 8596 return self.api_client.call_api(resource_path, 'GET', 8597 path_params, 8598 query_params, 8599 header_params, 8600 body=body_params, 8601 post_params=form_params, 8602 files=local_var_files, 8603 response_type='Tabs', 8604 auth_settings=auth_settings, 8605 callback=params.get('callback'), 8606 _return_http_data_only=params.get('_return_http_data_only'), 8607 _preload_content=params.get('_preload_content', True), 8608 _request_timeout=params.get('_request_timeout'), 8609 collection_formats=collection_formats)
Returns tabs on the specified page.
Returns the tabs from the page specified by pageNumber of the document specified by documentId in the envelope specified by envelopeId.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_page_tabs_with_http_info(account_id, document_id, envelope_id, page_number, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str page_number: The page number being accessed. (required)
Returns
Tabs If the method is called asynchronously, returns the request thread.
def
get_pages(self, account_id, document_id, envelope_id, **kwargs)
8611 def get_pages(self, account_id, document_id, envelope_id, **kwargs): 8612 """ 8613 Returns document page image(s) based on input. 8614 Returns images of the pages in a document for display based on the parameters that you specify. 8615 This method makes a synchronous HTTP request by default. To make an 8616 asynchronous HTTP request, please define a `callback` function 8617 to be invoked when receiving the response. 8618 >>> def callback_function(response): 8619 >>> pprint(response) 8620 >>> 8621 >>> thread = api.get_pages(account_id, document_id, envelope_id, callback=callback_function) 8622 8623 :param callback function: The callback function 8624 for asynchronous request. (optional) 8625 :param str account_id: The external account number (int) or account ID Guid. (required) 8626 :param str document_id: The ID of the document being accessed. (required) 8627 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8628 :param str count: 8629 :param str dpi: 8630 :param str max_height: 8631 :param str max_width: 8632 :param str nocache: 8633 :param str show_changes: 8634 :param str start_position: 8635 :return: PageImages 8636 If the method is called asynchronously, 8637 returns the request thread. 8638 """ 8639 kwargs['_return_http_data_only'] = True 8640 if kwargs.get('callback'): 8641 return self.get_pages_with_http_info(account_id, document_id, envelope_id, **kwargs) 8642 else: 8643 (data) = self.get_pages_with_http_info(account_id, document_id, envelope_id, **kwargs) 8644 return data
Returns document page image(s) based on input.
Returns images of the pages in a document for display based on the parameters that you specify.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_pages(account_id, document_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str count:
- str dpi:
- str max_height:
- str max_width:
- str nocache:
- str show_changes:
- str start_position:
Returns
PageImages If the method is called asynchronously, returns the request thread.
def
get_pages_with_http_info(self, account_id, document_id, envelope_id, **kwargs)
8646 def get_pages_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 8647 """ 8648 Returns document page image(s) based on input. 8649 Returns images of the pages in a document for display based on the parameters that you specify. 8650 This method makes a synchronous HTTP request by default. To make an 8651 asynchronous HTTP request, please define a `callback` function 8652 to be invoked when receiving the response. 8653 >>> def callback_function(response): 8654 >>> pprint(response) 8655 >>> 8656 >>> thread = api.get_pages_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 8657 8658 :param callback function: The callback function 8659 for asynchronous request. (optional) 8660 :param str account_id: The external account number (int) or account ID Guid. (required) 8661 :param str document_id: The ID of the document being accessed. (required) 8662 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8663 :param str count: 8664 :param str dpi: 8665 :param str max_height: 8666 :param str max_width: 8667 :param str nocache: 8668 :param str show_changes: 8669 :param str start_position: 8670 :return: PageImages 8671 If the method is called asynchronously, 8672 returns the request thread. 8673 """ 8674 8675 all_params = ['account_id', 'document_id', 'envelope_id', 'count', 'dpi', 'max_height', 'max_width', 'nocache', 'show_changes', 'start_position'] 8676 all_params.append('callback') 8677 all_params.append('_return_http_data_only') 8678 all_params.append('_preload_content') 8679 all_params.append('_request_timeout') 8680 8681 params = locals() 8682 for key, val in iteritems(params['kwargs']): 8683 if key not in all_params: 8684 raise TypeError( 8685 "Got an unexpected keyword argument '%s'" 8686 " to method get_pages" % key 8687 ) 8688 params[key] = val 8689 del params['kwargs'] 8690 # verify the required parameter 'account_id' is set 8691 if ('account_id' not in params) or (params['account_id'] is None): 8692 raise ValueError("Missing the required parameter `account_id` when calling `get_pages`") 8693 # verify the required parameter 'document_id' is set 8694 if ('document_id' not in params) or (params['document_id'] is None): 8695 raise ValueError("Missing the required parameter `document_id` when calling `get_pages`") 8696 # verify the required parameter 'envelope_id' is set 8697 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8698 raise ValueError("Missing the required parameter `envelope_id` when calling `get_pages`") 8699 8700 8701 collection_formats = {} 8702 8703 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/pages'.replace('{format}', 'json') 8704 path_params = {} 8705 if 'account_id' in params: 8706 path_params['accountId'] = params['account_id'] 8707 if 'document_id' in params: 8708 path_params['documentId'] = params['document_id'] 8709 if 'envelope_id' in params: 8710 path_params['envelopeId'] = params['envelope_id'] 8711 8712 query_params = {} 8713 if 'count' in params: 8714 query_params['count'] = params['count'] 8715 if 'dpi' in params: 8716 query_params['dpi'] = params['dpi'] 8717 if 'max_height' in params: 8718 query_params['max_height'] = params['max_height'] 8719 if 'max_width' in params: 8720 query_params['max_width'] = params['max_width'] 8721 if 'nocache' in params: 8722 query_params['nocache'] = params['nocache'] 8723 if 'show_changes' in params: 8724 query_params['show_changes'] = params['show_changes'] 8725 if 'start_position' in params: 8726 query_params['start_position'] = params['start_position'] 8727 8728 header_params = {} 8729 8730 form_params = [] 8731 local_var_files = {} 8732 8733 body_params = None 8734 # HTTP header `Accept` 8735 header_params['Accept'] = self.api_client.\ 8736 select_header_accept(['application/json']) 8737 8738 # Authentication setting 8739 auth_settings = [] 8740 8741 return self.api_client.call_api(resource_path, 'GET', 8742 path_params, 8743 query_params, 8744 header_params, 8745 body=body_params, 8746 post_params=form_params, 8747 files=local_var_files, 8748 response_type='PageImages', 8749 auth_settings=auth_settings, 8750 callback=params.get('callback'), 8751 _return_http_data_only=params.get('_return_http_data_only'), 8752 _preload_content=params.get('_preload_content', True), 8753 _request_timeout=params.get('_request_timeout'), 8754 collection_formats=collection_formats)
Returns document page image(s) based on input.
Returns images of the pages in a document for display based on the parameters that you specify.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_pages_with_http_info(account_id, document_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str count:
- str dpi:
- str max_height:
- str max_width:
- str nocache:
- str show_changes:
- str start_position:
Returns
PageImages If the method is called asynchronously, returns the request thread.
def
get_recipient_document_visibility(self, account_id, envelope_id, recipient_id, **kwargs)
8756 def get_recipient_document_visibility(self, account_id, envelope_id, recipient_id, **kwargs): 8757 """ 8758 Returns document visibility for the recipients 8759 This method returns information about document visibility for a recipient. 8760 This method makes a synchronous HTTP request by default. To make an 8761 asynchronous HTTP request, please define a `callback` function 8762 to be invoked when receiving the response. 8763 >>> def callback_function(response): 8764 >>> pprint(response) 8765 >>> 8766 >>> thread = api.get_recipient_document_visibility(account_id, envelope_id, recipient_id, callback=callback_function) 8767 8768 :param callback function: The callback function 8769 for asynchronous request. (optional) 8770 :param str account_id: The external account number (int) or account ID Guid. (required) 8771 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8772 :param str recipient_id: The ID of the recipient being accessed. (required) 8773 :return: DocumentVisibilityList 8774 If the method is called asynchronously, 8775 returns the request thread. 8776 """ 8777 kwargs['_return_http_data_only'] = True 8778 if kwargs.get('callback'): 8779 return self.get_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 8780 else: 8781 (data) = self.get_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 8782 return data
Returns document visibility for the recipients
This method returns information about document visibility for a recipient.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_recipient_document_visibility(account_id, envelope_id, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
Returns
DocumentVisibilityList If the method is called asynchronously, returns the request thread.
def
get_recipient_document_visibility_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs)
8784 def get_recipient_document_visibility_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 8785 """ 8786 Returns document visibility for the recipients 8787 This method returns information about document visibility for a recipient. 8788 This method makes a synchronous HTTP request by default. To make an 8789 asynchronous HTTP request, please define a `callback` function 8790 to be invoked when receiving the response. 8791 >>> def callback_function(response): 8792 >>> pprint(response) 8793 >>> 8794 >>> thread = api.get_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 8795 8796 :param callback function: The callback function 8797 for asynchronous request. (optional) 8798 :param str account_id: The external account number (int) or account ID Guid. (required) 8799 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8800 :param str recipient_id: The ID of the recipient being accessed. (required) 8801 :return: DocumentVisibilityList 8802 If the method is called asynchronously, 8803 returns the request thread. 8804 """ 8805 8806 all_params = ['account_id', 'envelope_id', 'recipient_id'] 8807 all_params.append('callback') 8808 all_params.append('_return_http_data_only') 8809 all_params.append('_preload_content') 8810 all_params.append('_request_timeout') 8811 8812 params = locals() 8813 for key, val in iteritems(params['kwargs']): 8814 if key not in all_params: 8815 raise TypeError( 8816 "Got an unexpected keyword argument '%s'" 8817 " to method get_recipient_document_visibility" % key 8818 ) 8819 params[key] = val 8820 del params['kwargs'] 8821 # verify the required parameter 'account_id' is set 8822 if ('account_id' not in params) or (params['account_id'] is None): 8823 raise ValueError("Missing the required parameter `account_id` when calling `get_recipient_document_visibility`") 8824 # verify the required parameter 'envelope_id' is set 8825 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8826 raise ValueError("Missing the required parameter `envelope_id` when calling `get_recipient_document_visibility`") 8827 # verify the required parameter 'recipient_id' is set 8828 if ('recipient_id' not in params) or (params['recipient_id'] is None): 8829 raise ValueError("Missing the required parameter `recipient_id` when calling `get_recipient_document_visibility`") 8830 8831 8832 collection_formats = {} 8833 8834 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/document_visibility'.replace('{format}', 'json') 8835 path_params = {} 8836 if 'account_id' in params: 8837 path_params['accountId'] = params['account_id'] 8838 if 'envelope_id' in params: 8839 path_params['envelopeId'] = params['envelope_id'] 8840 if 'recipient_id' in params: 8841 path_params['recipientId'] = params['recipient_id'] 8842 8843 query_params = {} 8844 8845 header_params = {} 8846 8847 form_params = [] 8848 local_var_files = {} 8849 8850 body_params = None 8851 # HTTP header `Accept` 8852 header_params['Accept'] = self.api_client.\ 8853 select_header_accept(['application/json']) 8854 8855 # Authentication setting 8856 auth_settings = [] 8857 8858 return self.api_client.call_api(resource_path, 'GET', 8859 path_params, 8860 query_params, 8861 header_params, 8862 body=body_params, 8863 post_params=form_params, 8864 files=local_var_files, 8865 response_type='DocumentVisibilityList', 8866 auth_settings=auth_settings, 8867 callback=params.get('callback'), 8868 _return_http_data_only=params.get('_return_http_data_only'), 8869 _preload_content=params.get('_preload_content', True), 8870 _request_timeout=params.get('_request_timeout'), 8871 collection_formats=collection_formats)
Returns document visibility for the recipients
This method returns information about document visibility for a recipient.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
Returns
DocumentVisibilityList If the method is called asynchronously, returns the request thread.
def
get_recipient_initials_image(self, account_id, envelope_id, recipient_id, **kwargs)
8873 def get_recipient_initials_image(self, account_id, envelope_id, recipient_id, **kwargs): 8874 """ 8875 Gets the initials image for a user. 8876 Retrieves the initials image for the specified user. The image is returned in the same format as it was uploaded. In the request you can specify if the chrome (the added line and identifier around the initial image) is returned with the image. The userId specified in the endpoint must match the authenticated user's user id and the user must be a member of the account. The `signatureIdOrName` paramter accepts signature ID or signature name. DocuSign recommends you use signature ID (`signatureId`), since some names contain characters that do not properly URL encode. If you use the user name, it is likely that the name includes spaces and you might need to URL encode the name before using it in the endpoint. For example: \"Bob Smith\" to \"Bob%20Smith\" Older envelopes might only contain chromed images. If getting the non-chromed image fails, try getting the chromed image. 8877 This method makes a synchronous HTTP request by default. To make an 8878 asynchronous HTTP request, please define a `callback` function 8879 to be invoked when receiving the response. 8880 >>> def callback_function(response): 8881 >>> pprint(response) 8882 >>> 8883 >>> thread = api.get_recipient_initials_image(account_id, envelope_id, recipient_id, callback=callback_function) 8884 8885 :param callback function: The callback function 8886 for asynchronous request. (optional) 8887 :param str account_id: The external account number (int) or account ID Guid. (required) 8888 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8889 :param str recipient_id: The ID of the recipient being accessed. (required) 8890 :param str include_chrome: The added line and identifier around the initial image. Note: Older envelopes might only have chromed images. If getting the non-chromed image fails, try getting the chromed image. 8891 :return: file 8892 If the method is called asynchronously, 8893 returns the request thread. 8894 """ 8895 kwargs['_return_http_data_only'] = True 8896 if kwargs.get('callback'): 8897 return self.get_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 8898 else: 8899 (data) = self.get_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 8900 return data
Gets the initials image for a user.
Retrieves the initials image for the specified user. The image is returned in the same format as it was uploaded. In the request you can specify if the chrome (the added line and identifier around the initial image) is returned with the image. The userId specified in the endpoint must match the authenticated user's user id and the user must be a member of the account. The signatureIdOrName paramter accepts signature ID or signature name. DocuSign recommends you use signature ID (signatureId), since some names contain characters that do not properly URL encode. If you use the user name, it is likely that the name includes spaces and you might need to URL encode the name before using it in the endpoint. For example: "Bob Smith" to "Bob%20Smith" Older envelopes might only contain chromed images. If getting the non-chromed image fails, try getting the chromed image.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_recipient_initials_image(account_id, envelope_id, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
- str include_chrome: The added line and identifier around the initial image. Note: Older envelopes might only have chromed images. If getting the non-chromed image fails, try getting the chromed image.
Returns
file If the method is called asynchronously, returns the request thread.
def
get_recipient_initials_image_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs)
8902 def get_recipient_initials_image_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 8903 """ 8904 Gets the initials image for a user. 8905 Retrieves the initials image for the specified user. The image is returned in the same format as it was uploaded. In the request you can specify if the chrome (the added line and identifier around the initial image) is returned with the image. The userId specified in the endpoint must match the authenticated user's user id and the user must be a member of the account. The `signatureIdOrName` paramter accepts signature ID or signature name. DocuSign recommends you use signature ID (`signatureId`), since some names contain characters that do not properly URL encode. If you use the user name, it is likely that the name includes spaces and you might need to URL encode the name before using it in the endpoint. For example: \"Bob Smith\" to \"Bob%20Smith\" Older envelopes might only contain chromed images. If getting the non-chromed image fails, try getting the chromed image. 8906 This method makes a synchronous HTTP request by default. To make an 8907 asynchronous HTTP request, please define a `callback` function 8908 to be invoked when receiving the response. 8909 >>> def callback_function(response): 8910 >>> pprint(response) 8911 >>> 8912 >>> thread = api.get_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 8913 8914 :param callback function: The callback function 8915 for asynchronous request. (optional) 8916 :param str account_id: The external account number (int) or account ID Guid. (required) 8917 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8918 :param str recipient_id: The ID of the recipient being accessed. (required) 8919 :param str include_chrome: The added line and identifier around the initial image. Note: Older envelopes might only have chromed images. If getting the non-chromed image fails, try getting the chromed image. 8920 :return: file 8921 If the method is called asynchronously, 8922 returns the request thread. 8923 """ 8924 8925 all_params = ['account_id', 'envelope_id', 'recipient_id', 'include_chrome'] 8926 all_params.append('callback') 8927 all_params.append('_return_http_data_only') 8928 all_params.append('_preload_content') 8929 all_params.append('_request_timeout') 8930 8931 params = locals() 8932 for key, val in iteritems(params['kwargs']): 8933 if key not in all_params: 8934 raise TypeError( 8935 "Got an unexpected keyword argument '%s'" 8936 " to method get_recipient_initials_image" % key 8937 ) 8938 params[key] = val 8939 del params['kwargs'] 8940 # verify the required parameter 'account_id' is set 8941 if ('account_id' not in params) or (params['account_id'] is None): 8942 raise ValueError("Missing the required parameter `account_id` when calling `get_recipient_initials_image`") 8943 # verify the required parameter 'envelope_id' is set 8944 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8945 raise ValueError("Missing the required parameter `envelope_id` when calling `get_recipient_initials_image`") 8946 # verify the required parameter 'recipient_id' is set 8947 if ('recipient_id' not in params) or (params['recipient_id'] is None): 8948 raise ValueError("Missing the required parameter `recipient_id` when calling `get_recipient_initials_image`") 8949 8950 8951 collection_formats = {} 8952 8953 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/initials_image'.replace('{format}', 'json') 8954 path_params = {} 8955 if 'account_id' in params: 8956 path_params['accountId'] = params['account_id'] 8957 if 'envelope_id' in params: 8958 path_params['envelopeId'] = params['envelope_id'] 8959 if 'recipient_id' in params: 8960 path_params['recipientId'] = params['recipient_id'] 8961 8962 query_params = {} 8963 if 'include_chrome' in params: 8964 query_params['include_chrome'] = params['include_chrome'] 8965 8966 header_params = {} 8967 8968 form_params = [] 8969 local_var_files = {} 8970 8971 body_params = None 8972 # HTTP header `Accept` 8973 header_params['Accept'] = self.api_client.\ 8974 select_header_accept(['image/gif']) 8975 8976 # Authentication setting 8977 auth_settings = [] 8978 8979 return self.api_client.call_api(resource_path, 'GET', 8980 path_params, 8981 query_params, 8982 header_params, 8983 body=body_params, 8984 post_params=form_params, 8985 files=local_var_files, 8986 response_type='file', 8987 auth_settings=auth_settings, 8988 callback=params.get('callback'), 8989 _return_http_data_only=params.get('_return_http_data_only'), 8990 _preload_content=params.get('_preload_content', True), 8991 _request_timeout=params.get('_request_timeout'), 8992 collection_formats=collection_formats)
Gets the initials image for a user.
Retrieves the initials image for the specified user. The image is returned in the same format as it was uploaded. In the request you can specify if the chrome (the added line and identifier around the initial image) is returned with the image. The userId specified in the endpoint must match the authenticated user's user id and the user must be a member of the account. The signatureIdOrName paramter accepts signature ID or signature name. DocuSign recommends you use signature ID (signatureId), since some names contain characters that do not properly URL encode. If you use the user name, it is likely that the name includes spaces and you might need to URL encode the name before using it in the endpoint. For example: "Bob Smith" to "Bob%20Smith" Older envelopes might only contain chromed images. If getting the non-chromed image fails, try getting the chromed image.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
- str include_chrome: The added line and identifier around the initial image. Note: Older envelopes might only have chromed images. If getting the non-chromed image fails, try getting the chromed image.
Returns
file If the method is called asynchronously, returns the request thread.
def
get_recipient_signature(self, account_id, envelope_id, recipient_id, **kwargs)
8994 def get_recipient_signature(self, account_id, envelope_id, recipient_id, **kwargs): 8995 """ 8996 Gets signature information for a signer or sign-in-person recipient. 8997 Retrieves signature information for a signer or sign-in-person recipient. 8998 This method makes a synchronous HTTP request by default. To make an 8999 asynchronous HTTP request, please define a `callback` function 9000 to be invoked when receiving the response. 9001 >>> def callback_function(response): 9002 >>> pprint(response) 9003 >>> 9004 >>> thread = api.get_recipient_signature(account_id, envelope_id, recipient_id, callback=callback_function) 9005 9006 :param callback function: The callback function 9007 for asynchronous request. (optional) 9008 :param str account_id: The external account number (int) or account ID Guid. (required) 9009 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9010 :param str recipient_id: The ID of the recipient being accessed. (required) 9011 :return: UserSignature 9012 If the method is called asynchronously, 9013 returns the request thread. 9014 """ 9015 kwargs['_return_http_data_only'] = True 9016 if kwargs.get('callback'): 9017 return self.get_recipient_signature_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 9018 else: 9019 (data) = self.get_recipient_signature_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 9020 return data
Gets signature information for a signer or sign-in-person recipient.
Retrieves signature information for a signer or sign-in-person recipient.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_recipient_signature(account_id, envelope_id, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
Returns
UserSignature If the method is called asynchronously, returns the request thread.
def
get_recipient_signature_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs)
9022 def get_recipient_signature_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 9023 """ 9024 Gets signature information for a signer or sign-in-person recipient. 9025 Retrieves signature information for a signer or sign-in-person recipient. 9026 This method makes a synchronous HTTP request by default. To make an 9027 asynchronous HTTP request, please define a `callback` function 9028 to be invoked when receiving the response. 9029 >>> def callback_function(response): 9030 >>> pprint(response) 9031 >>> 9032 >>> thread = api.get_recipient_signature_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 9033 9034 :param callback function: The callback function 9035 for asynchronous request. (optional) 9036 :param str account_id: The external account number (int) or account ID Guid. (required) 9037 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9038 :param str recipient_id: The ID of the recipient being accessed. (required) 9039 :return: UserSignature 9040 If the method is called asynchronously, 9041 returns the request thread. 9042 """ 9043 9044 all_params = ['account_id', 'envelope_id', 'recipient_id'] 9045 all_params.append('callback') 9046 all_params.append('_return_http_data_only') 9047 all_params.append('_preload_content') 9048 all_params.append('_request_timeout') 9049 9050 params = locals() 9051 for key, val in iteritems(params['kwargs']): 9052 if key not in all_params: 9053 raise TypeError( 9054 "Got an unexpected keyword argument '%s'" 9055 " to method get_recipient_signature" % key 9056 ) 9057 params[key] = val 9058 del params['kwargs'] 9059 # verify the required parameter 'account_id' is set 9060 if ('account_id' not in params) or (params['account_id'] is None): 9061 raise ValueError("Missing the required parameter `account_id` when calling `get_recipient_signature`") 9062 # verify the required parameter 'envelope_id' is set 9063 if ('envelope_id' not in params) or (params['envelope_id'] is None): 9064 raise ValueError("Missing the required parameter `envelope_id` when calling `get_recipient_signature`") 9065 # verify the required parameter 'recipient_id' is set 9066 if ('recipient_id' not in params) or (params['recipient_id'] is None): 9067 raise ValueError("Missing the required parameter `recipient_id` when calling `get_recipient_signature`") 9068 9069 9070 collection_formats = {} 9071 9072 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/signature'.replace('{format}', 'json') 9073 path_params = {} 9074 if 'account_id' in params: 9075 path_params['accountId'] = params['account_id'] 9076 if 'envelope_id' in params: 9077 path_params['envelopeId'] = params['envelope_id'] 9078 if 'recipient_id' in params: 9079 path_params['recipientId'] = params['recipient_id'] 9080 9081 query_params = {} 9082 9083 header_params = {} 9084 9085 form_params = [] 9086 local_var_files = {} 9087 9088 body_params = None 9089 # HTTP header `Accept` 9090 header_params['Accept'] = self.api_client.\ 9091 select_header_accept(['application/json']) 9092 9093 # Authentication setting 9094 auth_settings = [] 9095 9096 return self.api_client.call_api(resource_path, 'GET', 9097 path_params, 9098 query_params, 9099 header_params, 9100 body=body_params, 9101 post_params=form_params, 9102 files=local_var_files, 9103 response_type='UserSignature', 9104 auth_settings=auth_settings, 9105 callback=params.get('callback'), 9106 _return_http_data_only=params.get('_return_http_data_only'), 9107 _preload_content=params.get('_preload_content', True), 9108 _request_timeout=params.get('_request_timeout'), 9109 collection_formats=collection_formats)
Gets signature information for a signer or sign-in-person recipient.
Retrieves signature information for a signer or sign-in-person recipient.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_recipient_signature_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
Returns
UserSignature If the method is called asynchronously, returns the request thread.
def
get_recipient_signature_image(self, account_id, envelope_id, recipient_id, **kwargs)
9111 def get_recipient_signature_image(self, account_id, envelope_id, recipient_id, **kwargs): 9112 """ 9113 Retrieve signature image information for a signer/sign-in-person recipient. 9114 Retrieves the specified user signature image. The image is returned in the same format as uploaded. In the request you can specify if the chrome (the added line and identifier around the initial image) is returned with the image. The userId specified in the endpoint must match the authenticated user's user ID and the user must be a member of the account. The `signatureIdOrName` parameter accepts signature ID or signature name. DocuSign recommends you use signature ID (`signatureId`), since some names contain characters that don't properly URL encode. If you use the user name, it is likely that the name includes spaces and you might need to URL encode the name before using it in the endpoint. For example: \"Bob Smith\" to \"Bob%20Smith\" Older envelopes might only have chromed images. If getting the non-chromed image fails, try getting the chromed image. 9115 This method makes a synchronous HTTP request by default. To make an 9116 asynchronous HTTP request, please define a `callback` function 9117 to be invoked when receiving the response. 9118 >>> def callback_function(response): 9119 >>> pprint(response) 9120 >>> 9121 >>> thread = api.get_recipient_signature_image(account_id, envelope_id, recipient_id, callback=callback_function) 9122 9123 :param callback function: The callback function 9124 for asynchronous request. (optional) 9125 :param str account_id: The external account number (int) or account ID Guid. (required) 9126 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9127 :param str recipient_id: The ID of the recipient being accessed. (required) 9128 :param str include_chrome: When set to **true**, indicates the chromed version of the signature image should be retrieved. 9129 :return: file 9130 If the method is called asynchronously, 9131 returns the request thread. 9132 """ 9133 kwargs['_return_http_data_only'] = True 9134 if kwargs.get('callback'): 9135 return self.get_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 9136 else: 9137 (data) = self.get_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 9138 return data
Retrieve signature image information for a signer/sign-in-person recipient.
Retrieves the specified user signature image. The image is returned in the same format as uploaded. In the request you can specify if the chrome (the added line and identifier around the initial image) is returned with the image. The userId specified in the endpoint must match the authenticated user's user ID and the user must be a member of the account. The signatureIdOrName parameter accepts signature ID or signature name. DocuSign recommends you use signature ID (signatureId), since some names contain characters that don't properly URL encode. If you use the user name, it is likely that the name includes spaces and you might need to URL encode the name before using it in the endpoint. For example: "Bob Smith" to "Bob%20Smith" Older envelopes might only have chromed images. If getting the non-chromed image fails, try getting the chromed image.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_recipient_signature_image(account_id, envelope_id, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
- str include_chrome: When set to true, indicates the chromed version of the signature image should be retrieved.
Returns
file If the method is called asynchronously, returns the request thread.
def
get_recipient_signature_image_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs)
9140 def get_recipient_signature_image_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 9141 """ 9142 Retrieve signature image information for a signer/sign-in-person recipient. 9143 Retrieves the specified user signature image. The image is returned in the same format as uploaded. In the request you can specify if the chrome (the added line and identifier around the initial image) is returned with the image. The userId specified in the endpoint must match the authenticated user's user ID and the user must be a member of the account. The `signatureIdOrName` parameter accepts signature ID or signature name. DocuSign recommends you use signature ID (`signatureId`), since some names contain characters that don't properly URL encode. If you use the user name, it is likely that the name includes spaces and you might need to URL encode the name before using it in the endpoint. For example: \"Bob Smith\" to \"Bob%20Smith\" Older envelopes might only have chromed images. If getting the non-chromed image fails, try getting the chromed image. 9144 This method makes a synchronous HTTP request by default. To make an 9145 asynchronous HTTP request, please define a `callback` function 9146 to be invoked when receiving the response. 9147 >>> def callback_function(response): 9148 >>> pprint(response) 9149 >>> 9150 >>> thread = api.get_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 9151 9152 :param callback function: The callback function 9153 for asynchronous request. (optional) 9154 :param str account_id: The external account number (int) or account ID Guid. (required) 9155 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9156 :param str recipient_id: The ID of the recipient being accessed. (required) 9157 :param str include_chrome: When set to **true**, indicates the chromed version of the signature image should be retrieved. 9158 :return: file 9159 If the method is called asynchronously, 9160 returns the request thread. 9161 """ 9162 9163 all_params = ['account_id', 'envelope_id', 'recipient_id', 'include_chrome'] 9164 all_params.append('callback') 9165 all_params.append('_return_http_data_only') 9166 all_params.append('_preload_content') 9167 all_params.append('_request_timeout') 9168 9169 params = locals() 9170 for key, val in iteritems(params['kwargs']): 9171 if key not in all_params: 9172 raise TypeError( 9173 "Got an unexpected keyword argument '%s'" 9174 " to method get_recipient_signature_image" % key 9175 ) 9176 params[key] = val 9177 del params['kwargs'] 9178 # verify the required parameter 'account_id' is set 9179 if ('account_id' not in params) or (params['account_id'] is None): 9180 raise ValueError("Missing the required parameter `account_id` when calling `get_recipient_signature_image`") 9181 # verify the required parameter 'envelope_id' is set 9182 if ('envelope_id' not in params) or (params['envelope_id'] is None): 9183 raise ValueError("Missing the required parameter `envelope_id` when calling `get_recipient_signature_image`") 9184 # verify the required parameter 'recipient_id' is set 9185 if ('recipient_id' not in params) or (params['recipient_id'] is None): 9186 raise ValueError("Missing the required parameter `recipient_id` when calling `get_recipient_signature_image`") 9187 9188 9189 collection_formats = {} 9190 9191 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/signature_image'.replace('{format}', 'json') 9192 path_params = {} 9193 if 'account_id' in params: 9194 path_params['accountId'] = params['account_id'] 9195 if 'envelope_id' in params: 9196 path_params['envelopeId'] = params['envelope_id'] 9197 if 'recipient_id' in params: 9198 path_params['recipientId'] = params['recipient_id'] 9199 9200 query_params = {} 9201 if 'include_chrome' in params: 9202 query_params['include_chrome'] = params['include_chrome'] 9203 9204 header_params = {} 9205 9206 form_params = [] 9207 local_var_files = {} 9208 9209 body_params = None 9210 # HTTP header `Accept` 9211 header_params['Accept'] = self.api_client.\ 9212 select_header_accept(['image/gif']) 9213 9214 # Authentication setting 9215 auth_settings = [] 9216 9217 return self.api_client.call_api(resource_path, 'GET', 9218 path_params, 9219 query_params, 9220 header_params, 9221 body=body_params, 9222 post_params=form_params, 9223 files=local_var_files, 9224 response_type='file', 9225 auth_settings=auth_settings, 9226 callback=params.get('callback'), 9227 _return_http_data_only=params.get('_return_http_data_only'), 9228 _preload_content=params.get('_preload_content', True), 9229 _request_timeout=params.get('_request_timeout'), 9230 collection_formats=collection_formats)
Retrieve signature image information for a signer/sign-in-person recipient.
Retrieves the specified user signature image. The image is returned in the same format as uploaded. In the request you can specify if the chrome (the added line and identifier around the initial image) is returned with the image. The userId specified in the endpoint must match the authenticated user's user ID and the user must be a member of the account. The signatureIdOrName parameter accepts signature ID or signature name. DocuSign recommends you use signature ID (signatureId), since some names contain characters that don't properly URL encode. If you use the user name, it is likely that the name includes spaces and you might need to URL encode the name before using it in the endpoint. For example: "Bob Smith" to "Bob%20Smith" Older envelopes might only have chromed images. If getting the non-chromed image fails, try getting the chromed image.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
- str include_chrome: When set to true, indicates the chromed version of the signature image should be retrieved.
Returns
file If the method is called asynchronously, returns the request thread.
def
get_tabs_blob(self, account_id, envelope_id, **kwargs)
9232 def get_tabs_blob(self, account_id, envelope_id, **kwargs): 9233 """ 9234 Get encrypted tabs for envelope. 9235 9236 This method makes a synchronous HTTP request by default. To make an 9237 asynchronous HTTP request, please define a `callback` function 9238 to be invoked when receiving the response. 9239 >>> def callback_function(response): 9240 >>> pprint(response) 9241 >>> 9242 >>> thread = api.get_tabs_blob(account_id, envelope_id, callback=callback_function) 9243 9244 :param callback function: The callback function 9245 for asynchronous request. (optional) 9246 :param str account_id: The external account number (int) or account ID Guid. (required) 9247 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9248 :return: None 9249 If the method is called asynchronously, 9250 returns the request thread. 9251 """ 9252 kwargs['_return_http_data_only'] = True 9253 if kwargs.get('callback'): 9254 return self.get_tabs_blob_with_http_info(account_id, envelope_id, **kwargs) 9255 else: 9256 (data) = self.get_tabs_blob_with_http_info(account_id, envelope_id, **kwargs) 9257 return data
Get encrypted tabs for envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_tabs_blob(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
get_tabs_blob_with_http_info(self, account_id, envelope_id, **kwargs)
9259 def get_tabs_blob_with_http_info(self, account_id, envelope_id, **kwargs): 9260 """ 9261 Get encrypted tabs for envelope. 9262 9263 This method makes a synchronous HTTP request by default. To make an 9264 asynchronous HTTP request, please define a `callback` function 9265 to be invoked when receiving the response. 9266 >>> def callback_function(response): 9267 >>> pprint(response) 9268 >>> 9269 >>> thread = api.get_tabs_blob_with_http_info(account_id, envelope_id, callback=callback_function) 9270 9271 :param callback function: The callback function 9272 for asynchronous request. (optional) 9273 :param str account_id: The external account number (int) or account ID Guid. (required) 9274 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9275 :return: None 9276 If the method is called asynchronously, 9277 returns the request thread. 9278 """ 9279 9280 all_params = ['account_id', 'envelope_id'] 9281 all_params.append('callback') 9282 all_params.append('_return_http_data_only') 9283 all_params.append('_preload_content') 9284 all_params.append('_request_timeout') 9285 9286 params = locals() 9287 for key, val in iteritems(params['kwargs']): 9288 if key not in all_params: 9289 raise TypeError( 9290 "Got an unexpected keyword argument '%s'" 9291 " to method get_tabs_blob" % key 9292 ) 9293 params[key] = val 9294 del params['kwargs'] 9295 # verify the required parameter 'account_id' is set 9296 if ('account_id' not in params) or (params['account_id'] is None): 9297 raise ValueError("Missing the required parameter `account_id` when calling `get_tabs_blob`") 9298 # verify the required parameter 'envelope_id' is set 9299 if ('envelope_id' not in params) or (params['envelope_id'] is None): 9300 raise ValueError("Missing the required parameter `envelope_id` when calling `get_tabs_blob`") 9301 9302 9303 collection_formats = {} 9304 9305 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/tabs_blob'.replace('{format}', 'json') 9306 path_params = {} 9307 if 'account_id' in params: 9308 path_params['accountId'] = params['account_id'] 9309 if 'envelope_id' in params: 9310 path_params['envelopeId'] = params['envelope_id'] 9311 9312 query_params = {} 9313 9314 header_params = {} 9315 9316 form_params = [] 9317 local_var_files = {} 9318 9319 body_params = None 9320 # HTTP header `Accept` 9321 header_params['Accept'] = self.api_client.\ 9322 select_header_accept(['application/json']) 9323 9324 # Authentication setting 9325 auth_settings = [] 9326 9327 return self.api_client.call_api(resource_path, 'GET', 9328 path_params, 9329 query_params, 9330 header_params, 9331 body=body_params, 9332 post_params=form_params, 9333 files=local_var_files, 9334 response_type=None, 9335 auth_settings=auth_settings, 9336 callback=params.get('callback'), 9337 _return_http_data_only=params.get('_return_http_data_only'), 9338 _preload_content=params.get('_preload_content', True), 9339 _request_timeout=params.get('_request_timeout'), 9340 collection_formats=collection_formats)
Get encrypted tabs for envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_tabs_blob_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
get_template_delayed_routing_definition(self, account_id, template_id, workflow_step_id, **kwargs)
9342 def get_template_delayed_routing_definition(self, account_id, template_id, workflow_step_id, **kwargs): 9343 """ 9344 Returns the delayed routing rules for a template's workflow step definition. 9345 This method makes a synchronous HTTP request by default. To make an 9346 asynchronous HTTP request, please define a `callback` function 9347 to be invoked when receiving the response. 9348 >>> def callback_function(response): 9349 >>> pprint(response) 9350 >>> 9351 >>> thread = api.get_template_delayed_routing_definition(account_id, template_id, workflow_step_id, callback=callback_function) 9352 9353 :param callback function: The callback function 9354 for asynchronous request. (optional) 9355 :param str account_id: The external account number (int) or account ID Guid. (required) 9356 :param str template_id: The ID of the template being accessed. (required) 9357 :param str workflow_step_id: (required) 9358 :return: DelayedRouting 9359 If the method is called asynchronously, 9360 returns the request thread. 9361 """ 9362 kwargs['_return_http_data_only'] = True 9363 if kwargs.get('callback'): 9364 return self.get_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 9365 else: 9366 (data) = self.get_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 9367 return data
Returns the delayed routing rules for a template's workflow step definition.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_template_delayed_routing_definition(account_id, template_id, workflow_step_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str template_id: The ID of the template being accessed. (required)
- str workflow_step_id: (required)
Returns
DelayedRouting If the method is called asynchronously, returns the request thread.
def
get_template_delayed_routing_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs)
9369 def get_template_delayed_routing_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 9370 """ 9371 Returns the delayed routing rules for a template's workflow step definition. 9372 This method makes a synchronous HTTP request by default. To make an 9373 asynchronous HTTP request, please define a `callback` function 9374 to be invoked when receiving the response. 9375 >>> def callback_function(response): 9376 >>> pprint(response) 9377 >>> 9378 >>> thread = api.get_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 9379 9380 :param callback function: The callback function 9381 for asynchronous request. (optional) 9382 :param str account_id: The external account number (int) or account ID Guid. (required) 9383 :param str template_id: The ID of the template being accessed. (required) 9384 :param str workflow_step_id: (required) 9385 :return: DelayedRouting 9386 If the method is called asynchronously, 9387 returns the request thread. 9388 """ 9389 9390 all_params = ['account_id', 'template_id', 'workflow_step_id'] 9391 all_params.append('callback') 9392 all_params.append('_return_http_data_only') 9393 all_params.append('_preload_content') 9394 all_params.append('_request_timeout') 9395 9396 params = locals() 9397 for key, val in iteritems(params['kwargs']): 9398 if key not in all_params: 9399 raise TypeError( 9400 "Got an unexpected keyword argument '%s'" 9401 " to method get_template_delayed_routing_definition" % key 9402 ) 9403 params[key] = val 9404 del params['kwargs'] 9405 # verify the required parameter 'account_id' is set 9406 if ('account_id' not in params) or (params['account_id'] is None): 9407 raise ValueError("Missing the required parameter `account_id` when calling `get_template_delayed_routing_definition`") 9408 # verify the required parameter 'template_id' is set 9409 if ('template_id' not in params) or (params['template_id'] is None): 9410 raise ValueError("Missing the required parameter `template_id` when calling `get_template_delayed_routing_definition`") 9411 # verify the required parameter 'workflow_step_id' is set 9412 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 9413 raise ValueError("Missing the required parameter `workflow_step_id` when calling `get_template_delayed_routing_definition`") 9414 9415 9416 collection_formats = {} 9417 9418 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 9419 path_params = {} 9420 if 'account_id' in params: 9421 path_params['accountId'] = params['account_id'] 9422 if 'template_id' in params: 9423 path_params['templateId'] = params['template_id'] 9424 if 'workflow_step_id' in params: 9425 path_params['workflowStepId'] = params['workflow_step_id'] 9426 9427 query_params = {} 9428 9429 header_params = {} 9430 9431 form_params = [] 9432 local_var_files = {} 9433 9434 body_params = None 9435 # HTTP header `Accept` 9436 header_params['Accept'] = self.api_client.\ 9437 select_header_accept(['application/json']) 9438 9439 # Authentication setting 9440 auth_settings = [] 9441 9442 return self.api_client.call_api(resource_path, 'GET', 9443 path_params, 9444 query_params, 9445 header_params, 9446 body=body_params, 9447 post_params=form_params, 9448 files=local_var_files, 9449 response_type='DelayedRouting', 9450 auth_settings=auth_settings, 9451 callback=params.get('callback'), 9452 _return_http_data_only=params.get('_return_http_data_only'), 9453 _preload_content=params.get('_preload_content', True), 9454 _request_timeout=params.get('_request_timeout'), 9455 collection_formats=collection_formats)
Returns the delayed routing rules for a template's workflow step definition.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str template_id: The ID of the template being accessed. (required)
- str workflow_step_id: (required)
Returns
DelayedRouting If the method is called asynchronously, returns the request thread.
def
get_template_recipient_document_visibility(self, account_id, recipient_id, template_id, **kwargs)
9457 def get_template_recipient_document_visibility(self, account_id, recipient_id, template_id, **kwargs): 9458 """ 9459 Returns document visibility for the recipients 9460 This method returns information about document visibility for a template recipient. 9461 This method makes a synchronous HTTP request by default. To make an 9462 asynchronous HTTP request, please define a `callback` function 9463 to be invoked when receiving the response. 9464 >>> def callback_function(response): 9465 >>> pprint(response) 9466 >>> 9467 >>> thread = api.get_template_recipient_document_visibility(account_id, recipient_id, template_id, callback=callback_function) 9468 9469 :param callback function: The callback function 9470 for asynchronous request. (optional) 9471 :param str account_id: The external account number (int) or account ID Guid. (required) 9472 :param str recipient_id: The ID of the recipient being accessed. (required) 9473 :param str template_id: The ID of the template being accessed. (required) 9474 :return: DocumentVisibilityList 9475 If the method is called asynchronously, 9476 returns the request thread. 9477 """ 9478 kwargs['_return_http_data_only'] = True 9479 if kwargs.get('callback'): 9480 return self.get_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, **kwargs) 9481 else: 9482 (data) = self.get_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, **kwargs) 9483 return data
Returns document visibility for the recipients
This method returns information about document visibility for a template recipient.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_template_recipient_document_visibility(account_id, recipient_id, template_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
- str template_id: The ID of the template being accessed. (required)
Returns
DocumentVisibilityList If the method is called asynchronously, returns the request thread.
def
get_template_recipient_document_visibility_with_http_info(self, account_id, recipient_id, template_id, **kwargs)
9485 def get_template_recipient_document_visibility_with_http_info(self, account_id, recipient_id, template_id, **kwargs): 9486 """ 9487 Returns document visibility for the recipients 9488 This method returns information about document visibility for a template recipient. 9489 This method makes a synchronous HTTP request by default. To make an 9490 asynchronous HTTP request, please define a `callback` function 9491 to be invoked when receiving the response. 9492 >>> def callback_function(response): 9493 >>> pprint(response) 9494 >>> 9495 >>> thread = api.get_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, callback=callback_function) 9496 9497 :param callback function: The callback function 9498 for asynchronous request. (optional) 9499 :param str account_id: The external account number (int) or account ID Guid. (required) 9500 :param str recipient_id: The ID of the recipient being accessed. (required) 9501 :param str template_id: The ID of the template being accessed. (required) 9502 :return: DocumentVisibilityList 9503 If the method is called asynchronously, 9504 returns the request thread. 9505 """ 9506 9507 all_params = ['account_id', 'recipient_id', 'template_id'] 9508 all_params.append('callback') 9509 all_params.append('_return_http_data_only') 9510 all_params.append('_preload_content') 9511 all_params.append('_request_timeout') 9512 9513 params = locals() 9514 for key, val in iteritems(params['kwargs']): 9515 if key not in all_params: 9516 raise TypeError( 9517 "Got an unexpected keyword argument '%s'" 9518 " to method get_template_recipient_document_visibility" % key 9519 ) 9520 params[key] = val 9521 del params['kwargs'] 9522 # verify the required parameter 'account_id' is set 9523 if ('account_id' not in params) or (params['account_id'] is None): 9524 raise ValueError("Missing the required parameter `account_id` when calling `get_template_recipient_document_visibility`") 9525 # verify the required parameter 'recipient_id' is set 9526 if ('recipient_id' not in params) or (params['recipient_id'] is None): 9527 raise ValueError("Missing the required parameter `recipient_id` when calling `get_template_recipient_document_visibility`") 9528 # verify the required parameter 'template_id' is set 9529 if ('template_id' not in params) or (params['template_id'] is None): 9530 raise ValueError("Missing the required parameter `template_id` when calling `get_template_recipient_document_visibility`") 9531 9532 9533 collection_formats = {} 9534 9535 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/recipients/{recipientId}/document_visibility'.replace('{format}', 'json') 9536 path_params = {} 9537 if 'account_id' in params: 9538 path_params['accountId'] = params['account_id'] 9539 if 'recipient_id' in params: 9540 path_params['recipientId'] = params['recipient_id'] 9541 if 'template_id' in params: 9542 path_params['templateId'] = params['template_id'] 9543 9544 query_params = {} 9545 9546 header_params = {} 9547 9548 form_params = [] 9549 local_var_files = {} 9550 9551 body_params = None 9552 # HTTP header `Accept` 9553 header_params['Accept'] = self.api_client.\ 9554 select_header_accept(['application/json']) 9555 9556 # Authentication setting 9557 auth_settings = [] 9558 9559 return self.api_client.call_api(resource_path, 'GET', 9560 path_params, 9561 query_params, 9562 header_params, 9563 body=body_params, 9564 post_params=form_params, 9565 files=local_var_files, 9566 response_type='DocumentVisibilityList', 9567 auth_settings=auth_settings, 9568 callback=params.get('callback'), 9569 _return_http_data_only=params.get('_return_http_data_only'), 9570 _preload_content=params.get('_preload_content', True), 9571 _request_timeout=params.get('_request_timeout'), 9572 collection_formats=collection_formats)
Returns document visibility for the recipients
This method returns information about document visibility for a template recipient.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
- str template_id: The ID of the template being accessed. (required)
Returns
DocumentVisibilityList If the method is called asynchronously, returns the request thread.
def
get_template_scheduled_sending_definition(self, account_id, template_id, **kwargs)
9574 def get_template_scheduled_sending_definition(self, account_id, template_id, **kwargs): 9575 """ 9576 Returns the scheduled sending rules for a template's workflow definition. 9577 This method makes a synchronous HTTP request by default. To make an 9578 asynchronous HTTP request, please define a `callback` function 9579 to be invoked when receiving the response. 9580 >>> def callback_function(response): 9581 >>> pprint(response) 9582 >>> 9583 >>> thread = api.get_template_scheduled_sending_definition(account_id, template_id, callback=callback_function) 9584 9585 :param callback function: The callback function 9586 for asynchronous request. (optional) 9587 :param str account_id: The external account number (int) or account ID Guid. (required) 9588 :param str template_id: The ID of the template being accessed. (required) 9589 :return: ScheduledSending 9590 If the method is called asynchronously, 9591 returns the request thread. 9592 """ 9593 kwargs['_return_http_data_only'] = True 9594 if kwargs.get('callback'): 9595 return self.get_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 9596 else: 9597 (data) = self.get_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 9598 return data
Returns the scheduled sending rules for a template's workflow definition.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_template_scheduled_sending_definition(account_id, template_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str template_id: The ID of the template being accessed. (required)
Returns
ScheduledSending If the method is called asynchronously, returns the request thread.
def
get_template_scheduled_sending_definition_with_http_info(self, account_id, template_id, **kwargs)
9600 def get_template_scheduled_sending_definition_with_http_info(self, account_id, template_id, **kwargs): 9601 """ 9602 Returns the scheduled sending rules for a template's workflow definition. 9603 This method makes a synchronous HTTP request by default. To make an 9604 asynchronous HTTP request, please define a `callback` function 9605 to be invoked when receiving the response. 9606 >>> def callback_function(response): 9607 >>> pprint(response) 9608 >>> 9609 >>> thread = api.get_template_scheduled_sending_definition_with_http_info(account_id, template_id, callback=callback_function) 9610 9611 :param callback function: The callback function 9612 for asynchronous request. (optional) 9613 :param str account_id: The external account number (int) or account ID Guid. (required) 9614 :param str template_id: The ID of the template being accessed. (required) 9615 :return: ScheduledSending 9616 If the method is called asynchronously, 9617 returns the request thread. 9618 """ 9619 9620 all_params = ['account_id', 'template_id'] 9621 all_params.append('callback') 9622 all_params.append('_return_http_data_only') 9623 all_params.append('_preload_content') 9624 all_params.append('_request_timeout') 9625 9626 params = locals() 9627 for key, val in iteritems(params['kwargs']): 9628 if key not in all_params: 9629 raise TypeError( 9630 "Got an unexpected keyword argument '%s'" 9631 " to method get_template_scheduled_sending_definition" % key 9632 ) 9633 params[key] = val 9634 del params['kwargs'] 9635 # verify the required parameter 'account_id' is set 9636 if ('account_id' not in params) or (params['account_id'] is None): 9637 raise ValueError("Missing the required parameter `account_id` when calling `get_template_scheduled_sending_definition`") 9638 # verify the required parameter 'template_id' is set 9639 if ('template_id' not in params) or (params['template_id'] is None): 9640 raise ValueError("Missing the required parameter `template_id` when calling `get_template_scheduled_sending_definition`") 9641 9642 9643 collection_formats = {} 9644 9645 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/scheduledSending'.replace('{format}', 'json') 9646 path_params = {} 9647 if 'account_id' in params: 9648 path_params['accountId'] = params['account_id'] 9649 if 'template_id' in params: 9650 path_params['templateId'] = params['template_id'] 9651 9652 query_params = {} 9653 9654 header_params = {} 9655 9656 form_params = [] 9657 local_var_files = {} 9658 9659 body_params = None 9660 # HTTP header `Accept` 9661 header_params['Accept'] = self.api_client.\ 9662 select_header_accept(['application/json']) 9663 9664 # Authentication setting 9665 auth_settings = [] 9666 9667 return self.api_client.call_api(resource_path, 'GET', 9668 path_params, 9669 query_params, 9670 header_params, 9671 body=body_params, 9672 post_params=form_params, 9673 files=local_var_files, 9674 response_type='ScheduledSending', 9675 auth_settings=auth_settings, 9676 callback=params.get('callback'), 9677 _return_http_data_only=params.get('_return_http_data_only'), 9678 _preload_content=params.get('_preload_content', True), 9679 _request_timeout=params.get('_request_timeout'), 9680 collection_formats=collection_formats)
Returns the scheduled sending rules for a template's workflow definition.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_template_scheduled_sending_definition_with_http_info(account_id, template_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str template_id: The ID of the template being accessed. (required)
Returns
ScheduledSending If the method is called asynchronously, returns the request thread.
def
get_template_workflow_definition(self, account_id, template_id, **kwargs)
9682 def get_template_workflow_definition(self, account_id, template_id, **kwargs): 9683 """ 9684 Returns the workflow definition for a template. 9685 Returns template's workflow definition if the template specified by `templateId` has one. 9686 This method makes a synchronous HTTP request by default. To make an 9687 asynchronous HTTP request, please define a `callback` function 9688 to be invoked when receiving the response. 9689 >>> def callback_function(response): 9690 >>> pprint(response) 9691 >>> 9692 >>> thread = api.get_template_workflow_definition(account_id, template_id, callback=callback_function) 9693 9694 :param callback function: The callback function 9695 for asynchronous request. (optional) 9696 :param str account_id: The external account number (int) or account ID Guid. (required) 9697 :param str template_id: The ID of the template being accessed. (required) 9698 :return: Workflow 9699 If the method is called asynchronously, 9700 returns the request thread. 9701 """ 9702 kwargs['_return_http_data_only'] = True 9703 if kwargs.get('callback'): 9704 return self.get_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 9705 else: 9706 (data) = self.get_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 9707 return data
Returns the workflow definition for a template.
Returns template's workflow definition if the template specified by templateId has one.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_template_workflow_definition(account_id, template_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str template_id: The ID of the template being accessed. (required)
Returns
Workflow If the method is called asynchronously, returns the request thread.
def
get_template_workflow_definition_with_http_info(self, account_id, template_id, **kwargs)
9709 def get_template_workflow_definition_with_http_info(self, account_id, template_id, **kwargs): 9710 """ 9711 Returns the workflow definition for a template. 9712 Returns template's workflow definition if the template specified by `templateId` has one. 9713 This method makes a synchronous HTTP request by default. To make an 9714 asynchronous HTTP request, please define a `callback` function 9715 to be invoked when receiving the response. 9716 >>> def callback_function(response): 9717 >>> pprint(response) 9718 >>> 9719 >>> thread = api.get_template_workflow_definition_with_http_info(account_id, template_id, callback=callback_function) 9720 9721 :param callback function: The callback function 9722 for asynchronous request. (optional) 9723 :param str account_id: The external account number (int) or account ID Guid. (required) 9724 :param str template_id: The ID of the template being accessed. (required) 9725 :return: Workflow 9726 If the method is called asynchronously, 9727 returns the request thread. 9728 """ 9729 9730 all_params = ['account_id', 'template_id'] 9731 all_params.append('callback') 9732 all_params.append('_return_http_data_only') 9733 all_params.append('_preload_content') 9734 all_params.append('_request_timeout') 9735 9736 params = locals() 9737 for key, val in iteritems(params['kwargs']): 9738 if key not in all_params: 9739 raise TypeError( 9740 "Got an unexpected keyword argument '%s'" 9741 " to method get_template_workflow_definition" % key 9742 ) 9743 params[key] = val 9744 del params['kwargs'] 9745 # verify the required parameter 'account_id' is set 9746 if ('account_id' not in params) or (params['account_id'] is None): 9747 raise ValueError("Missing the required parameter `account_id` when calling `get_template_workflow_definition`") 9748 # verify the required parameter 'template_id' is set 9749 if ('template_id' not in params) or (params['template_id'] is None): 9750 raise ValueError("Missing the required parameter `template_id` when calling `get_template_workflow_definition`") 9751 9752 9753 collection_formats = {} 9754 9755 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow'.replace('{format}', 'json') 9756 path_params = {} 9757 if 'account_id' in params: 9758 path_params['accountId'] = params['account_id'] 9759 if 'template_id' in params: 9760 path_params['templateId'] = params['template_id'] 9761 9762 query_params = {} 9763 9764 header_params = {} 9765 9766 form_params = [] 9767 local_var_files = {} 9768 9769 body_params = None 9770 # HTTP header `Accept` 9771 header_params['Accept'] = self.api_client.\ 9772 select_header_accept(['application/json']) 9773 9774 # Authentication setting 9775 auth_settings = [] 9776 9777 return self.api_client.call_api(resource_path, 'GET', 9778 path_params, 9779 query_params, 9780 header_params, 9781 body=body_params, 9782 post_params=form_params, 9783 files=local_var_files, 9784 response_type='Workflow', 9785 auth_settings=auth_settings, 9786 callback=params.get('callback'), 9787 _return_http_data_only=params.get('_return_http_data_only'), 9788 _preload_content=params.get('_preload_content', True), 9789 _request_timeout=params.get('_request_timeout'), 9790 collection_formats=collection_formats)
Returns the workflow definition for a template.
Returns template's workflow definition if the template specified by templateId has one.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_template_workflow_definition_with_http_info(account_id, template_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str template_id: The ID of the template being accessed. (required)
Returns
Workflow If the method is called asynchronously, returns the request thread.
def
get_template_workflow_step_definition(self, account_id, template_id, workflow_step_id, **kwargs)
9792 def get_template_workflow_step_definition(self, account_id, template_id, workflow_step_id, **kwargs): 9793 """ 9794 Returns the workflow step definition for a template by step id. 9795 This method makes a synchronous HTTP request by default. To make an 9796 asynchronous HTTP request, please define a `callback` function 9797 to be invoked when receiving the response. 9798 >>> def callback_function(response): 9799 >>> pprint(response) 9800 >>> 9801 >>> thread = api.get_template_workflow_step_definition(account_id, template_id, workflow_step_id, callback=callback_function) 9802 9803 :param callback function: The callback function 9804 for asynchronous request. (optional) 9805 :param str account_id: The external account number (int) or account ID Guid. (required) 9806 :param str template_id: The ID of the template being accessed. (required) 9807 :param str workflow_step_id: (required) 9808 :return: WorkflowStep 9809 If the method is called asynchronously, 9810 returns the request thread. 9811 """ 9812 kwargs['_return_http_data_only'] = True 9813 if kwargs.get('callback'): 9814 return self.get_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 9815 else: 9816 (data) = self.get_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 9817 return data
Returns the workflow step definition for a template by step id.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_template_workflow_step_definition(account_id, template_id, workflow_step_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str template_id: The ID of the template being accessed. (required)
- str workflow_step_id: (required)
Returns
WorkflowStep If the method is called asynchronously, returns the request thread.
def
get_template_workflow_step_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs)
9819 def get_template_workflow_step_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 9820 """ 9821 Returns the workflow step definition for a template by step id. 9822 This method makes a synchronous HTTP request by default. To make an 9823 asynchronous HTTP request, please define a `callback` function 9824 to be invoked when receiving the response. 9825 >>> def callback_function(response): 9826 >>> pprint(response) 9827 >>> 9828 >>> thread = api.get_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 9829 9830 :param callback function: The callback function 9831 for asynchronous request. (optional) 9832 :param str account_id: The external account number (int) or account ID Guid. (required) 9833 :param str template_id: The ID of the template being accessed. (required) 9834 :param str workflow_step_id: (required) 9835 :return: WorkflowStep 9836 If the method is called asynchronously, 9837 returns the request thread. 9838 """ 9839 9840 all_params = ['account_id', 'template_id', 'workflow_step_id'] 9841 all_params.append('callback') 9842 all_params.append('_return_http_data_only') 9843 all_params.append('_preload_content') 9844 all_params.append('_request_timeout') 9845 9846 params = locals() 9847 for key, val in iteritems(params['kwargs']): 9848 if key not in all_params: 9849 raise TypeError( 9850 "Got an unexpected keyword argument '%s'" 9851 " to method get_template_workflow_step_definition" % key 9852 ) 9853 params[key] = val 9854 del params['kwargs'] 9855 # verify the required parameter 'account_id' is set 9856 if ('account_id' not in params) or (params['account_id'] is None): 9857 raise ValueError("Missing the required parameter `account_id` when calling `get_template_workflow_step_definition`") 9858 # verify the required parameter 'template_id' is set 9859 if ('template_id' not in params) or (params['template_id'] is None): 9860 raise ValueError("Missing the required parameter `template_id` when calling `get_template_workflow_step_definition`") 9861 # verify the required parameter 'workflow_step_id' is set 9862 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 9863 raise ValueError("Missing the required parameter `workflow_step_id` when calling `get_template_workflow_step_definition`") 9864 9865 9866 collection_formats = {} 9867 9868 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 9869 path_params = {} 9870 if 'account_id' in params: 9871 path_params['accountId'] = params['account_id'] 9872 if 'template_id' in params: 9873 path_params['templateId'] = params['template_id'] 9874 if 'workflow_step_id' in params: 9875 path_params['workflowStepId'] = params['workflow_step_id'] 9876 9877 query_params = {} 9878 9879 header_params = {} 9880 9881 form_params = [] 9882 local_var_files = {} 9883 9884 body_params = None 9885 # HTTP header `Accept` 9886 header_params['Accept'] = self.api_client.\ 9887 select_header_accept(['application/json']) 9888 9889 # Authentication setting 9890 auth_settings = [] 9891 9892 return self.api_client.call_api(resource_path, 'GET', 9893 path_params, 9894 query_params, 9895 header_params, 9896 body=body_params, 9897 post_params=form_params, 9898 files=local_var_files, 9899 response_type='WorkflowStep', 9900 auth_settings=auth_settings, 9901 callback=params.get('callback'), 9902 _return_http_data_only=params.get('_return_http_data_only'), 9903 _preload_content=params.get('_preload_content', True), 9904 _request_timeout=params.get('_request_timeout'), 9905 collection_formats=collection_formats)
Returns the workflow step definition for a template by step id.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str template_id: The ID of the template being accessed. (required)
- str workflow_step_id: (required)
Returns
WorkflowStep If the method is called asynchronously, returns the request thread.
def
list_audit_events(self, account_id, envelope_id, **kwargs)
9907 def list_audit_events(self, account_id, envelope_id, **kwargs): 9908 """ 9909 Gets the envelope audit events for an envelope. 9910 Gets the envelope audit events for the specified envelope. 9911 This method makes a synchronous HTTP request by default. To make an 9912 asynchronous HTTP request, please define a `callback` function 9913 to be invoked when receiving the response. 9914 >>> def callback_function(response): 9915 >>> pprint(response) 9916 >>> 9917 >>> thread = api.list_audit_events(account_id, envelope_id, callback=callback_function) 9918 9919 :param callback function: The callback function 9920 for asynchronous request. (optional) 9921 :param str account_id: The external account number (int) or account ID Guid. (required) 9922 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9923 :return: EnvelopeAuditEventResponse 9924 If the method is called asynchronously, 9925 returns the request thread. 9926 """ 9927 kwargs['_return_http_data_only'] = True 9928 if kwargs.get('callback'): 9929 return self.list_audit_events_with_http_info(account_id, envelope_id, **kwargs) 9930 else: 9931 (data) = self.list_audit_events_with_http_info(account_id, envelope_id, **kwargs) 9932 return data
Gets the envelope audit events for an envelope.
Gets the envelope audit events for the specified envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_audit_events(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
EnvelopeAuditEventResponse If the method is called asynchronously, returns the request thread.
def
list_audit_events_with_http_info(self, account_id, envelope_id, **kwargs)
9934 def list_audit_events_with_http_info(self, account_id, envelope_id, **kwargs): 9935 """ 9936 Gets the envelope audit events for an envelope. 9937 Gets the envelope audit events for the specified envelope. 9938 This method makes a synchronous HTTP request by default. To make an 9939 asynchronous HTTP request, please define a `callback` function 9940 to be invoked when receiving the response. 9941 >>> def callback_function(response): 9942 >>> pprint(response) 9943 >>> 9944 >>> thread = api.list_audit_events_with_http_info(account_id, envelope_id, callback=callback_function) 9945 9946 :param callback function: The callback function 9947 for asynchronous request. (optional) 9948 :param str account_id: The external account number (int) or account ID Guid. (required) 9949 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9950 :return: EnvelopeAuditEventResponse 9951 If the method is called asynchronously, 9952 returns the request thread. 9953 """ 9954 9955 all_params = ['account_id', 'envelope_id'] 9956 all_params.append('callback') 9957 all_params.append('_return_http_data_only') 9958 all_params.append('_preload_content') 9959 all_params.append('_request_timeout') 9960 9961 params = locals() 9962 for key, val in iteritems(params['kwargs']): 9963 if key not in all_params: 9964 raise TypeError( 9965 "Got an unexpected keyword argument '%s'" 9966 " to method list_audit_events" % key 9967 ) 9968 params[key] = val 9969 del params['kwargs'] 9970 # verify the required parameter 'account_id' is set 9971 if ('account_id' not in params) or (params['account_id'] is None): 9972 raise ValueError("Missing the required parameter `account_id` when calling `list_audit_events`") 9973 # verify the required parameter 'envelope_id' is set 9974 if ('envelope_id' not in params) or (params['envelope_id'] is None): 9975 raise ValueError("Missing the required parameter `envelope_id` when calling `list_audit_events`") 9976 9977 9978 collection_formats = {} 9979 9980 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/audit_events'.replace('{format}', 'json') 9981 path_params = {} 9982 if 'account_id' in params: 9983 path_params['accountId'] = params['account_id'] 9984 if 'envelope_id' in params: 9985 path_params['envelopeId'] = params['envelope_id'] 9986 9987 query_params = {} 9988 9989 header_params = {} 9990 9991 form_params = [] 9992 local_var_files = {} 9993 9994 body_params = None 9995 # HTTP header `Accept` 9996 header_params['Accept'] = self.api_client.\ 9997 select_header_accept(['application/json']) 9998 9999 # Authentication setting 10000 auth_settings = [] 10001 10002 return self.api_client.call_api(resource_path, 'GET', 10003 path_params, 10004 query_params, 10005 header_params, 10006 body=body_params, 10007 post_params=form_params, 10008 files=local_var_files, 10009 response_type='EnvelopeAuditEventResponse', 10010 auth_settings=auth_settings, 10011 callback=params.get('callback'), 10012 _return_http_data_only=params.get('_return_http_data_only'), 10013 _preload_content=params.get('_preload_content', True), 10014 _request_timeout=params.get('_request_timeout'), 10015 collection_formats=collection_formats)
Gets the envelope audit events for an envelope.
Gets the envelope audit events for the specified envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_audit_events_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
EnvelopeAuditEventResponse If the method is called asynchronously, returns the request thread.
def
list_custom_fields(self, account_id, envelope_id, **kwargs)
10017 def list_custom_fields(self, account_id, envelope_id, **kwargs): 10018 """ 10019 Gets the custom field information for the specified envelope. 10020 Retrieves the custom field information for the specified envelope. You can use these fields in the envelopes for your account to record information about the envelope, help search for envelopes, and track information. The envelope custom fields are shown in the Envelope Settings section when a user is creating an envelope in the DocuSign member console. The envelope custom fields are not seen by the envelope recipients. There are two types of envelope custom fields, text, and list. A text custom field lets the sender enter the value for the field. With a list custom field, the sender selects the value of the field from a pre-made list. 10021 This method makes a synchronous HTTP request by default. To make an 10022 asynchronous HTTP request, please define a `callback` function 10023 to be invoked when receiving the response. 10024 >>> def callback_function(response): 10025 >>> pprint(response) 10026 >>> 10027 >>> thread = api.list_custom_fields(account_id, envelope_id, callback=callback_function) 10028 10029 :param callback function: The callback function 10030 for asynchronous request. (optional) 10031 :param str account_id: The external account number (int) or account ID Guid. (required) 10032 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10033 :return: CustomFieldsEnvelope 10034 If the method is called asynchronously, 10035 returns the request thread. 10036 """ 10037 kwargs['_return_http_data_only'] = True 10038 if kwargs.get('callback'): 10039 return self.list_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 10040 else: 10041 (data) = self.list_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 10042 return data
Gets the custom field information for the specified envelope.
Retrieves the custom field information for the specified envelope. You can use these fields in the envelopes for your account to record information about the envelope, help search for envelopes, and track information. The envelope custom fields are shown in the Envelope Settings section when a user is creating an envelope in the DocuSign member console. The envelope custom fields are not seen by the envelope recipients. There are two types of envelope custom fields, text, and list. A text custom field lets the sender enter the value for the field. With a list custom field, the sender selects the value of the field from a pre-made list.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_custom_fields(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
CustomFieldsEnvelope If the method is called asynchronously, returns the request thread.
def
list_custom_fields_with_http_info(self, account_id, envelope_id, **kwargs)
10044 def list_custom_fields_with_http_info(self, account_id, envelope_id, **kwargs): 10045 """ 10046 Gets the custom field information for the specified envelope. 10047 Retrieves the custom field information for the specified envelope. You can use these fields in the envelopes for your account to record information about the envelope, help search for envelopes, and track information. The envelope custom fields are shown in the Envelope Settings section when a user is creating an envelope in the DocuSign member console. The envelope custom fields are not seen by the envelope recipients. There are two types of envelope custom fields, text, and list. A text custom field lets the sender enter the value for the field. With a list custom field, the sender selects the value of the field from a pre-made list. 10048 This method makes a synchronous HTTP request by default. To make an 10049 asynchronous HTTP request, please define a `callback` function 10050 to be invoked when receiving the response. 10051 >>> def callback_function(response): 10052 >>> pprint(response) 10053 >>> 10054 >>> thread = api.list_custom_fields_with_http_info(account_id, envelope_id, callback=callback_function) 10055 10056 :param callback function: The callback function 10057 for asynchronous request. (optional) 10058 :param str account_id: The external account number (int) or account ID Guid. (required) 10059 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10060 :return: CustomFieldsEnvelope 10061 If the method is called asynchronously, 10062 returns the request thread. 10063 """ 10064 10065 all_params = ['account_id', 'envelope_id'] 10066 all_params.append('callback') 10067 all_params.append('_return_http_data_only') 10068 all_params.append('_preload_content') 10069 all_params.append('_request_timeout') 10070 10071 params = locals() 10072 for key, val in iteritems(params['kwargs']): 10073 if key not in all_params: 10074 raise TypeError( 10075 "Got an unexpected keyword argument '%s'" 10076 " to method list_custom_fields" % key 10077 ) 10078 params[key] = val 10079 del params['kwargs'] 10080 # verify the required parameter 'account_id' is set 10081 if ('account_id' not in params) or (params['account_id'] is None): 10082 raise ValueError("Missing the required parameter `account_id` when calling `list_custom_fields`") 10083 # verify the required parameter 'envelope_id' is set 10084 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10085 raise ValueError("Missing the required parameter `envelope_id` when calling `list_custom_fields`") 10086 10087 10088 collection_formats = {} 10089 10090 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/custom_fields'.replace('{format}', 'json') 10091 path_params = {} 10092 if 'account_id' in params: 10093 path_params['accountId'] = params['account_id'] 10094 if 'envelope_id' in params: 10095 path_params['envelopeId'] = params['envelope_id'] 10096 10097 query_params = {} 10098 10099 header_params = {} 10100 10101 form_params = [] 10102 local_var_files = {} 10103 10104 body_params = None 10105 # HTTP header `Accept` 10106 header_params['Accept'] = self.api_client.\ 10107 select_header_accept(['application/json']) 10108 10109 # Authentication setting 10110 auth_settings = [] 10111 10112 return self.api_client.call_api(resource_path, 'GET', 10113 path_params, 10114 query_params, 10115 header_params, 10116 body=body_params, 10117 post_params=form_params, 10118 files=local_var_files, 10119 response_type='CustomFieldsEnvelope', 10120 auth_settings=auth_settings, 10121 callback=params.get('callback'), 10122 _return_http_data_only=params.get('_return_http_data_only'), 10123 _preload_content=params.get('_preload_content', True), 10124 _request_timeout=params.get('_request_timeout'), 10125 collection_formats=collection_formats)
Gets the custom field information for the specified envelope.
Retrieves the custom field information for the specified envelope. You can use these fields in the envelopes for your account to record information about the envelope, help search for envelopes, and track information. The envelope custom fields are shown in the Envelope Settings section when a user is creating an envelope in the DocuSign member console. The envelope custom fields are not seen by the envelope recipients. There are two types of envelope custom fields, text, and list. A text custom field lets the sender enter the value for the field. With a list custom field, the sender selects the value of the field from a pre-made list.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_custom_fields_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
CustomFieldsEnvelope If the method is called asynchronously, returns the request thread.
def
list_document_fields(self, account_id, document_id, envelope_id, **kwargs)
10127 def list_document_fields(self, account_id, document_id, envelope_id, **kwargs): 10128 """ 10129 Gets the custom document fields from an existing envelope document. 10130 Retrieves the custom document field information from an existing envelope document. 10131 This method makes a synchronous HTTP request by default. To make an 10132 asynchronous HTTP request, please define a `callback` function 10133 to be invoked when receiving the response. 10134 >>> def callback_function(response): 10135 >>> pprint(response) 10136 >>> 10137 >>> thread = api.list_document_fields(account_id, document_id, envelope_id, callback=callback_function) 10138 10139 :param callback function: The callback function 10140 for asynchronous request. (optional) 10141 :param str account_id: The external account number (int) or account ID Guid. (required) 10142 :param str document_id: The ID of the document being accessed. (required) 10143 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10144 :return: DocumentFieldsInformation 10145 If the method is called asynchronously, 10146 returns the request thread. 10147 """ 10148 kwargs['_return_http_data_only'] = True 10149 if kwargs.get('callback'): 10150 return self.list_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 10151 else: 10152 (data) = self.list_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 10153 return data
Gets the custom document fields from an existing envelope document.
Retrieves the custom document field information from an existing envelope document.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_document_fields(account_id, document_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
DocumentFieldsInformation If the method is called asynchronously, returns the request thread.
def
list_document_fields_with_http_info(self, account_id, document_id, envelope_id, **kwargs)
10155 def list_document_fields_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 10156 """ 10157 Gets the custom document fields from an existing envelope document. 10158 Retrieves the custom document field information from an existing envelope document. 10159 This method makes a synchronous HTTP request by default. To make an 10160 asynchronous HTTP request, please define a `callback` function 10161 to be invoked when receiving the response. 10162 >>> def callback_function(response): 10163 >>> pprint(response) 10164 >>> 10165 >>> thread = api.list_document_fields_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 10166 10167 :param callback function: The callback function 10168 for asynchronous request. (optional) 10169 :param str account_id: The external account number (int) or account ID Guid. (required) 10170 :param str document_id: The ID of the document being accessed. (required) 10171 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10172 :return: DocumentFieldsInformation 10173 If the method is called asynchronously, 10174 returns the request thread. 10175 """ 10176 10177 all_params = ['account_id', 'document_id', 'envelope_id'] 10178 all_params.append('callback') 10179 all_params.append('_return_http_data_only') 10180 all_params.append('_preload_content') 10181 all_params.append('_request_timeout') 10182 10183 params = locals() 10184 for key, val in iteritems(params['kwargs']): 10185 if key not in all_params: 10186 raise TypeError( 10187 "Got an unexpected keyword argument '%s'" 10188 " to method list_document_fields" % key 10189 ) 10190 params[key] = val 10191 del params['kwargs'] 10192 # verify the required parameter 'account_id' is set 10193 if ('account_id' not in params) or (params['account_id'] is None): 10194 raise ValueError("Missing the required parameter `account_id` when calling `list_document_fields`") 10195 # verify the required parameter 'document_id' is set 10196 if ('document_id' not in params) or (params['document_id'] is None): 10197 raise ValueError("Missing the required parameter `document_id` when calling `list_document_fields`") 10198 # verify the required parameter 'envelope_id' is set 10199 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10200 raise ValueError("Missing the required parameter `envelope_id` when calling `list_document_fields`") 10201 10202 10203 collection_formats = {} 10204 10205 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/fields'.replace('{format}', 'json') 10206 path_params = {} 10207 if 'account_id' in params: 10208 path_params['accountId'] = params['account_id'] 10209 if 'document_id' in params: 10210 path_params['documentId'] = params['document_id'] 10211 if 'envelope_id' in params: 10212 path_params['envelopeId'] = params['envelope_id'] 10213 10214 query_params = {} 10215 10216 header_params = {} 10217 10218 form_params = [] 10219 local_var_files = {} 10220 10221 body_params = None 10222 # HTTP header `Accept` 10223 header_params['Accept'] = self.api_client.\ 10224 select_header_accept(['application/json']) 10225 10226 # Authentication setting 10227 auth_settings = [] 10228 10229 return self.api_client.call_api(resource_path, 'GET', 10230 path_params, 10231 query_params, 10232 header_params, 10233 body=body_params, 10234 post_params=form_params, 10235 files=local_var_files, 10236 response_type='DocumentFieldsInformation', 10237 auth_settings=auth_settings, 10238 callback=params.get('callback'), 10239 _return_http_data_only=params.get('_return_http_data_only'), 10240 _preload_content=params.get('_preload_content', True), 10241 _request_timeout=params.get('_request_timeout'), 10242 collection_formats=collection_formats)
Gets the custom document fields from an existing envelope document.
Retrieves the custom document field information from an existing envelope document.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_document_fields_with_http_info(account_id, document_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
DocumentFieldsInformation If the method is called asynchronously, returns the request thread.
def
list_documents(self, account_id, envelope_id, **kwargs)
10244 def list_documents(self, account_id, envelope_id, **kwargs): 10245 """ 10246 Gets a list of envelope documents. 10247 Retrieves a list of documents associated with the specified envelope. 10248 This method makes a synchronous HTTP request by default. To make an 10249 asynchronous HTTP request, please define a `callback` function 10250 to be invoked when receiving the response. 10251 >>> def callback_function(response): 10252 >>> pprint(response) 10253 >>> 10254 >>> thread = api.list_documents(account_id, envelope_id, callback=callback_function) 10255 10256 :param callback function: The callback function 10257 for asynchronous request. (optional) 10258 :param str account_id: The external account number (int) or account ID Guid. (required) 10259 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10260 :param str documents_by_userid: 10261 :param str include_docgen_formfields: 10262 :param str include_document_size: 10263 :param str include_metadata: 10264 :param str include_tabs: 10265 :param str recipient_id: 10266 :param str shared_user_id: 10267 :return: EnvelopeDocumentsResult 10268 If the method is called asynchronously, 10269 returns the request thread. 10270 """ 10271 kwargs['_return_http_data_only'] = True 10272 if kwargs.get('callback'): 10273 return self.list_documents_with_http_info(account_id, envelope_id, **kwargs) 10274 else: 10275 (data) = self.list_documents_with_http_info(account_id, envelope_id, **kwargs) 10276 return data
Gets a list of envelope documents.
Retrieves a list of documents associated with the specified envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_documents(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str documents_by_userid:
- str include_docgen_formfields:
- str include_document_size:
- str include_metadata:
- str include_tabs:
- str recipient_id:
- str shared_user_id:
Returns
EnvelopeDocumentsResult If the method is called asynchronously, returns the request thread.
def
list_documents_with_http_info(self, account_id, envelope_id, **kwargs)
10278 def list_documents_with_http_info(self, account_id, envelope_id, **kwargs): 10279 """ 10280 Gets a list of envelope documents. 10281 Retrieves a list of documents associated with the specified envelope. 10282 This method makes a synchronous HTTP request by default. To make an 10283 asynchronous HTTP request, please define a `callback` function 10284 to be invoked when receiving the response. 10285 >>> def callback_function(response): 10286 >>> pprint(response) 10287 >>> 10288 >>> thread = api.list_documents_with_http_info(account_id, envelope_id, callback=callback_function) 10289 10290 :param callback function: The callback function 10291 for asynchronous request. (optional) 10292 :param str account_id: The external account number (int) or account ID Guid. (required) 10293 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10294 :param str documents_by_userid: 10295 :param str include_docgen_formfields: 10296 :param str include_document_size: 10297 :param str include_metadata: 10298 :param str include_tabs: 10299 :param str recipient_id: 10300 :param str shared_user_id: 10301 :return: EnvelopeDocumentsResult 10302 If the method is called asynchronously, 10303 returns the request thread. 10304 """ 10305 10306 all_params = ['account_id', 'envelope_id', 'documents_by_userid', 'include_docgen_formfields', 'include_document_size', 'include_metadata', 'include_tabs', 'recipient_id', 'shared_user_id'] 10307 all_params.append('callback') 10308 all_params.append('_return_http_data_only') 10309 all_params.append('_preload_content') 10310 all_params.append('_request_timeout') 10311 10312 params = locals() 10313 for key, val in iteritems(params['kwargs']): 10314 if key not in all_params: 10315 raise TypeError( 10316 "Got an unexpected keyword argument '%s'" 10317 " to method list_documents" % key 10318 ) 10319 params[key] = val 10320 del params['kwargs'] 10321 # verify the required parameter 'account_id' is set 10322 if ('account_id' not in params) or (params['account_id'] is None): 10323 raise ValueError("Missing the required parameter `account_id` when calling `list_documents`") 10324 # verify the required parameter 'envelope_id' is set 10325 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10326 raise ValueError("Missing the required parameter `envelope_id` when calling `list_documents`") 10327 10328 10329 collection_formats = {} 10330 10331 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents'.replace('{format}', 'json') 10332 path_params = {} 10333 if 'account_id' in params: 10334 path_params['accountId'] = params['account_id'] 10335 if 'envelope_id' in params: 10336 path_params['envelopeId'] = params['envelope_id'] 10337 10338 query_params = {} 10339 if 'documents_by_userid' in params: 10340 query_params['documents_by_userid'] = params['documents_by_userid'] 10341 if 'include_docgen_formfields' in params: 10342 query_params['include_docgen_formfields'] = params['include_docgen_formfields'] 10343 if 'include_document_size' in params: 10344 query_params['include_document_size'] = params['include_document_size'] 10345 if 'include_metadata' in params: 10346 query_params['include_metadata'] = params['include_metadata'] 10347 if 'include_tabs' in params: 10348 query_params['include_tabs'] = params['include_tabs'] 10349 if 'recipient_id' in params: 10350 query_params['recipient_id'] = params['recipient_id'] 10351 if 'shared_user_id' in params: 10352 query_params['shared_user_id'] = params['shared_user_id'] 10353 10354 header_params = {} 10355 10356 form_params = [] 10357 local_var_files = {} 10358 10359 body_params = None 10360 # HTTP header `Accept` 10361 header_params['Accept'] = self.api_client.\ 10362 select_header_accept(['application/json']) 10363 10364 # Authentication setting 10365 auth_settings = [] 10366 10367 return self.api_client.call_api(resource_path, 'GET', 10368 path_params, 10369 query_params, 10370 header_params, 10371 body=body_params, 10372 post_params=form_params, 10373 files=local_var_files, 10374 response_type='EnvelopeDocumentsResult', 10375 auth_settings=auth_settings, 10376 callback=params.get('callback'), 10377 _return_http_data_only=params.get('_return_http_data_only'), 10378 _preload_content=params.get('_preload_content', True), 10379 _request_timeout=params.get('_request_timeout'), 10380 collection_formats=collection_formats)
Gets a list of envelope documents.
Retrieves a list of documents associated with the specified envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_documents_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str documents_by_userid:
- str include_docgen_formfields:
- str include_document_size:
- str include_metadata:
- str include_tabs:
- str recipient_id:
- str shared_user_id:
Returns
EnvelopeDocumentsResult If the method is called asynchronously, returns the request thread.
def
list_recipients(self, account_id, envelope_id, **kwargs)
10382 def list_recipients(self, account_id, envelope_id, **kwargs): 10383 """ 10384 Gets the status of recipients for an envelope. 10385 Retrieves the status of all recipients in a single envelope and identifies the current recipient in the routing list. The `currentRoutingOrder` property of the response contains the `routingOrder` value of the current recipient indicating that the envelope has been sent to the recipient, but the recipient has not completed their actions. 10386 This method makes a synchronous HTTP request by default. To make an 10387 asynchronous HTTP request, please define a `callback` function 10388 to be invoked when receiving the response. 10389 >>> def callback_function(response): 10390 >>> pprint(response) 10391 >>> 10392 >>> thread = api.list_recipients(account_id, envelope_id, callback=callback_function) 10393 10394 :param callback function: The callback function 10395 for asynchronous request. (optional) 10396 :param str account_id: The external account number (int) or account ID Guid. (required) 10397 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10398 :param str include_anchor_tab_locations: When set to **true** and `include_tabs` is set to **true**, all tabs with anchor tab properties are included in the response. 10399 :param str include_extended: When set to **true**, the extended properties are included in the response. 10400 :param str include_metadata: 10401 :param str include_tabs: When set to **true**, the tab information associated with the recipient is included in the response. 10402 :return: Recipients 10403 If the method is called asynchronously, 10404 returns the request thread. 10405 """ 10406 kwargs['_return_http_data_only'] = True 10407 if kwargs.get('callback'): 10408 return self.list_recipients_with_http_info(account_id, envelope_id, **kwargs) 10409 else: 10410 (data) = self.list_recipients_with_http_info(account_id, envelope_id, **kwargs) 10411 return data
Gets the status of recipients for an envelope.
Retrieves the status of all recipients in a single envelope and identifies the current recipient in the routing list. The currentRoutingOrder property of the response contains the routingOrder value of the current recipient indicating that the envelope has been sent to the recipient, but the recipient has not completed their actions.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_recipients(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str include_anchor_tab_locations: When set to true and
include_tabsis set to true, all tabs with anchor tab properties are included in the response. - str include_extended: When set to true, the extended properties are included in the response.
- str include_metadata:
- str include_tabs: When set to true, the tab information associated with the recipient is included in the response.
Returns
Recipients If the method is called asynchronously, returns the request thread.
def
list_recipients_with_http_info(self, account_id, envelope_id, **kwargs)
10413 def list_recipients_with_http_info(self, account_id, envelope_id, **kwargs): 10414 """ 10415 Gets the status of recipients for an envelope. 10416 Retrieves the status of all recipients in a single envelope and identifies the current recipient in the routing list. The `currentRoutingOrder` property of the response contains the `routingOrder` value of the current recipient indicating that the envelope has been sent to the recipient, but the recipient has not completed their actions. 10417 This method makes a synchronous HTTP request by default. To make an 10418 asynchronous HTTP request, please define a `callback` function 10419 to be invoked when receiving the response. 10420 >>> def callback_function(response): 10421 >>> pprint(response) 10422 >>> 10423 >>> thread = api.list_recipients_with_http_info(account_id, envelope_id, callback=callback_function) 10424 10425 :param callback function: The callback function 10426 for asynchronous request. (optional) 10427 :param str account_id: The external account number (int) or account ID Guid. (required) 10428 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10429 :param str include_anchor_tab_locations: When set to **true** and `include_tabs` is set to **true**, all tabs with anchor tab properties are included in the response. 10430 :param str include_extended: When set to **true**, the extended properties are included in the response. 10431 :param str include_metadata: 10432 :param str include_tabs: When set to **true**, the tab information associated with the recipient is included in the response. 10433 :return: Recipients 10434 If the method is called asynchronously, 10435 returns the request thread. 10436 """ 10437 10438 all_params = ['account_id', 'envelope_id', 'include_anchor_tab_locations', 'include_extended', 'include_metadata', 'include_tabs'] 10439 all_params.append('callback') 10440 all_params.append('_return_http_data_only') 10441 all_params.append('_preload_content') 10442 all_params.append('_request_timeout') 10443 10444 params = locals() 10445 for key, val in iteritems(params['kwargs']): 10446 if key not in all_params: 10447 raise TypeError( 10448 "Got an unexpected keyword argument '%s'" 10449 " to method list_recipients" % key 10450 ) 10451 params[key] = val 10452 del params['kwargs'] 10453 # verify the required parameter 'account_id' is set 10454 if ('account_id' not in params) or (params['account_id'] is None): 10455 raise ValueError("Missing the required parameter `account_id` when calling `list_recipients`") 10456 # verify the required parameter 'envelope_id' is set 10457 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10458 raise ValueError("Missing the required parameter `envelope_id` when calling `list_recipients`") 10459 10460 10461 collection_formats = {} 10462 10463 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients'.replace('{format}', 'json') 10464 path_params = {} 10465 if 'account_id' in params: 10466 path_params['accountId'] = params['account_id'] 10467 if 'envelope_id' in params: 10468 path_params['envelopeId'] = params['envelope_id'] 10469 10470 query_params = {} 10471 if 'include_anchor_tab_locations' in params: 10472 query_params['include_anchor_tab_locations'] = params['include_anchor_tab_locations'] 10473 if 'include_extended' in params: 10474 query_params['include_extended'] = params['include_extended'] 10475 if 'include_metadata' in params: 10476 query_params['include_metadata'] = params['include_metadata'] 10477 if 'include_tabs' in params: 10478 query_params['include_tabs'] = params['include_tabs'] 10479 10480 header_params = {} 10481 10482 form_params = [] 10483 local_var_files = {} 10484 10485 body_params = None 10486 # HTTP header `Accept` 10487 header_params['Accept'] = self.api_client.\ 10488 select_header_accept(['application/json']) 10489 10490 # Authentication setting 10491 auth_settings = [] 10492 10493 return self.api_client.call_api(resource_path, 'GET', 10494 path_params, 10495 query_params, 10496 header_params, 10497 body=body_params, 10498 post_params=form_params, 10499 files=local_var_files, 10500 response_type='Recipients', 10501 auth_settings=auth_settings, 10502 callback=params.get('callback'), 10503 _return_http_data_only=params.get('_return_http_data_only'), 10504 _preload_content=params.get('_preload_content', True), 10505 _request_timeout=params.get('_request_timeout'), 10506 collection_formats=collection_formats)
Gets the status of recipients for an envelope.
Retrieves the status of all recipients in a single envelope and identifies the current recipient in the routing list. The currentRoutingOrder property of the response contains the routingOrder value of the current recipient indicating that the envelope has been sent to the recipient, but the recipient has not completed their actions.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_recipients_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str include_anchor_tab_locations: When set to true and
include_tabsis set to true, all tabs with anchor tab properties are included in the response. - str include_extended: When set to true, the extended properties are included in the response.
- str include_metadata:
- str include_tabs: When set to true, the tab information associated with the recipient is included in the response.
Returns
Recipients If the method is called asynchronously, returns the request thread.
def
list_status(self, account_id, **kwargs)
10508 def list_status(self, account_id, **kwargs): 10509 """ 10510 Gets the envelope status for the specified envelopes. 10511 Retrieves the envelope status for the specified envelopes. 10512 This method makes a synchronous HTTP request by default. To make an 10513 asynchronous HTTP request, please define a `callback` function 10514 to be invoked when receiving the response. 10515 >>> def callback_function(response): 10516 >>> pprint(response) 10517 >>> 10518 >>> thread = api.list_status(account_id, callback=callback_function) 10519 10520 :param callback function: The callback function 10521 for asynchronous request. (optional) 10522 :param str account_id: The external account number (int) or account ID Guid. (required) 10523 :param str ac_status: 10524 :param str block: 10525 :param str count: 10526 :param str email: 10527 :param str envelope_ids: 10528 :param str from_date: 10529 :param str from_to_status: 10530 :param str start_position: 10531 :param str status: 10532 :param str to_date: 10533 :param str transaction_ids: 10534 :param str user_name: 10535 :param EnvelopeIdsRequest envelope_ids_request: 10536 :return: EnvelopesInformation 10537 If the method is called asynchronously, 10538 returns the request thread. 10539 """ 10540 kwargs['_return_http_data_only'] = True 10541 if kwargs.get('callback'): 10542 return self.list_status_with_http_info(account_id, **kwargs) 10543 else: 10544 (data) = self.list_status_with_http_info(account_id, **kwargs) 10545 return data
Gets the envelope status for the specified envelopes.
Retrieves the envelope status for the specified envelopes.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_status(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str ac_status:
- str block:
- str count:
- str email:
- str envelope_ids:
- str from_date:
- str from_to_status:
- str start_position:
- str status:
- str to_date:
- str transaction_ids:
- str user_name:
- EnvelopeIdsRequest envelope_ids_request:
Returns
EnvelopesInformation If the method is called asynchronously, returns the request thread.
def
list_status_with_http_info(self, account_id, **kwargs)
10547 def list_status_with_http_info(self, account_id, **kwargs): 10548 """ 10549 Gets the envelope status for the specified envelopes. 10550 Retrieves the envelope status for the specified envelopes. 10551 This method makes a synchronous HTTP request by default. To make an 10552 asynchronous HTTP request, please define a `callback` function 10553 to be invoked when receiving the response. 10554 >>> def callback_function(response): 10555 >>> pprint(response) 10556 >>> 10557 >>> thread = api.list_status_with_http_info(account_id, callback=callback_function) 10558 10559 :param callback function: The callback function 10560 for asynchronous request. (optional) 10561 :param str account_id: The external account number (int) or account ID Guid. (required) 10562 :param str ac_status: 10563 :param str block: 10564 :param str count: 10565 :param str email: 10566 :param str envelope_ids: 10567 :param str from_date: 10568 :param str from_to_status: 10569 :param str start_position: 10570 :param str status: 10571 :param str to_date: 10572 :param str transaction_ids: 10573 :param str user_name: 10574 :param EnvelopeIdsRequest envelope_ids_request: 10575 :return: EnvelopesInformation 10576 If the method is called asynchronously, 10577 returns the request thread. 10578 """ 10579 10580 all_params = ['account_id', 'ac_status', 'block', 'count', 'email', 'envelope_ids', 'from_date', 'from_to_status', 'start_position', 'status', 'to_date', 'transaction_ids', 'user_name', 'envelope_ids_request'] 10581 all_params.append('callback') 10582 all_params.append('_return_http_data_only') 10583 all_params.append('_preload_content') 10584 all_params.append('_request_timeout') 10585 10586 params = locals() 10587 for key, val in iteritems(params['kwargs']): 10588 if key not in all_params: 10589 raise TypeError( 10590 "Got an unexpected keyword argument '%s'" 10591 " to method list_status" % key 10592 ) 10593 params[key] = val 10594 del params['kwargs'] 10595 # verify the required parameter 'account_id' is set 10596 if ('account_id' not in params) or (params['account_id'] is None): 10597 raise ValueError("Missing the required parameter `account_id` when calling `list_status`") 10598 10599 10600 collection_formats = {} 10601 10602 resource_path = '/v2.1/accounts/{accountId}/envelopes/status'.replace('{format}', 'json') 10603 path_params = {} 10604 if 'account_id' in params: 10605 path_params['accountId'] = params['account_id'] 10606 10607 query_params = {} 10608 if 'ac_status' in params: 10609 query_params['ac_status'] = params['ac_status'] 10610 if 'block' in params: 10611 query_params['block'] = params['block'] 10612 if 'count' in params: 10613 query_params['count'] = params['count'] 10614 if 'email' in params: 10615 query_params['email'] = params['email'] 10616 if 'envelope_ids' in params: 10617 query_params['envelope_ids'] = params['envelope_ids'] 10618 if 'from_date' in params: 10619 query_params['from_date'] = params['from_date'] 10620 if 'from_to_status' in params: 10621 query_params['from_to_status'] = params['from_to_status'] 10622 if 'start_position' in params: 10623 query_params['start_position'] = params['start_position'] 10624 if 'status' in params: 10625 query_params['status'] = params['status'] 10626 if 'to_date' in params: 10627 query_params['to_date'] = params['to_date'] 10628 if 'transaction_ids' in params: 10629 query_params['transaction_ids'] = params['transaction_ids'] 10630 if 'user_name' in params: 10631 query_params['user_name'] = params['user_name'] 10632 10633 header_params = {} 10634 10635 form_params = [] 10636 local_var_files = {} 10637 10638 body_params = None 10639 if 'envelope_ids_request' in params: 10640 body_params = params['envelope_ids_request'] 10641 # HTTP header `Accept` 10642 header_params['Accept'] = self.api_client.\ 10643 select_header_accept(['application/json']) 10644 10645 # Authentication setting 10646 auth_settings = [] 10647 10648 return self.api_client.call_api(resource_path, 'PUT', 10649 path_params, 10650 query_params, 10651 header_params, 10652 body=body_params, 10653 post_params=form_params, 10654 files=local_var_files, 10655 response_type='EnvelopesInformation', 10656 auth_settings=auth_settings, 10657 callback=params.get('callback'), 10658 _return_http_data_only=params.get('_return_http_data_only'), 10659 _preload_content=params.get('_preload_content', True), 10660 _request_timeout=params.get('_request_timeout'), 10661 collection_formats=collection_formats)
Gets the envelope status for the specified envelopes.
Retrieves the envelope status for the specified envelopes.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_status_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str ac_status:
- str block:
- str count:
- str email:
- str envelope_ids:
- str from_date:
- str from_to_status:
- str start_position:
- str status:
- str to_date:
- str transaction_ids:
- str user_name:
- EnvelopeIdsRequest envelope_ids_request:
Returns
EnvelopesInformation If the method is called asynchronously, returns the request thread.
def
list_status_changes(self, account_id, **kwargs)
10663 def list_status_changes(self, account_id, **kwargs): 10664 """ 10665 Gets status changes for one or more envelopes. 10666 Retrieves envelope status changes for all envelopes. You can modify the information returned by adding query strings to limit the request to check between certain dates and times, or for certain envelopes, or for certain status codes. It is recommended that you use one or more of the query strings in order to limit the size of the response. ### Important: Unless you are requesting the status for specific envelopes (using the `envelopeIds` or `transactionIds` properties), you must add a set the `from_date` property in the request. Getting envelope status using `transactionIds` is useful for offline signing situations where it can be used determine if an envelope was created or not, for the cases where a network connection was lost, before the envelope status could be returned. ### Request Envelope Status Notes ### The REST API GET /envelopes call uses certain filters to find results. In some cases requests are check for \"any status change\" instead of the just the single status requested. In these cases, more envelopes might be returned by the request than otherwise would be. For example, for a request with the begin date is set to Jan 1st, an end date set to Jan 7th and the status qualifier (`from_to_status`) set to `Delivered` — the response set might contain envelopes that were created during that time period, but not delivered during the time period. To avoid unnecessary database queries, the DocuSign system checks requests to ensure that the added filters will not result in a zero-size response before acting on the request. The following table shows the valid envelope statuses (in the Valid Current Statuses column) for the status qualifiers in the request. If the status and status qualifiers in the API request do not contain any of the values shown in the valid current statuses column, then an empty list is returned. For example, a request with a status qualifier (from_to_status) of `Delivered` and a status of \"`Created`,`Sent`\", DocuSign will always return an empty list. This is because the request essentially translates to: find the envelopes that were delivered between the begin and end dates that have a current status of `Created` or `Sent`, and since an envelope that has been delivered can never have a status of `Created` or `Sent`, a zero-size response would be generated. In this case, DocuSign does not run the request, but just returns the empty list. Client applications should check that the statuses they are requesting make sense for a given status qualifier. 10667 This method makes a synchronous HTTP request by default. To make an 10668 asynchronous HTTP request, please define a `callback` function 10669 to be invoked when receiving the response. 10670 >>> def callback_function(response): 10671 >>> pprint(response) 10672 >>> 10673 >>> thread = api.list_status_changes(account_id, callback=callback_function) 10674 10675 :param callback function: The callback function 10676 for asynchronous request. (optional) 10677 :param str account_id: The external account number (int) or account ID Guid. (required) 10678 :param str ac_status: Specifies the Authoritative Copy Status for the envelopes. The possible values are: Unknown, Original, Transferred, AuthoritativeCopy, AuthoritativeCopyExportPending, AuthoritativeCopyExported, DepositPending, Deposited, DepositedEO, or DepositFailed. 10679 :param str block: 10680 :param str cdse_mode: 10681 :param str continuation_token: 10682 :param str count: 10683 :param str custom_field: This specifies the envelope custom field name and value searched for in the envelope information. The value portion of the query can use partial strings by adding '%' (percent sign) around the custom field query value. Example 1: If you have an envelope custom field called \"Region\" and you want to search for all envelopes where the value is \"West\" you would use the query: `?custom_field=Region=West`. Example 2: To search for envelopes where the `ApplicationID` custom field has the value or partial value of \"DocuSign\" in field, the query would be: `?custom_field=ApplicationId=%DocuSign%` This would find envelopes where the custom field value is \"DocuSign for Salesforce\" or \"DocuSign envelope.\" 10684 :param str email: 10685 :param str envelope_ids: 10686 :param str exclude: 10687 :param str folder_ids: 10688 :param str folder_types: 10689 :param str from_date: The date/time setting that specifies the date/time when the request begins checking for status changes for envelopes in the account. This is required unless 'envelopeId's are used. 10690 :param str from_to_status: This is the status type checked for in the `from_date`/`to_date` period. If `changed` is specified, then envelopes that changed status during the period are found. If for example, `created` is specified, then envelopes created during the period are found. Default is `changed`. Possible values are: Voided, Changed, Created, Deleted, Sent, Delivered, Signed, Completed, Declined, TimedOut and Processing. 10691 :param str include: 10692 :param str include_purge_information: 10693 :param str intersecting_folder_ids: 10694 :param str last_queried_date: 10695 :param str order: 10696 :param str order_by: 10697 :param str powerformids: 10698 :param str query_budget: 10699 :param str requester_date_format: 10700 :param str search_mode: 10701 :param str search_text: 10702 :param str start_position: 10703 :param str status: The list of current statuses to include in the response. By default, all envelopes found are returned. If values are specified, then of the envelopes found, only those with the current status specified are returned in the results. Possible values are: Voided, Created, Deleted, Sent, Delivered, Signed, Completed, Declined, TimedOut and Processing. 10704 :param str to_date: Optional date/time setting that specifies the date/time when the request stops for status changes for envelopes in the account. If no entry, the system uses the time of the call as the `to_date`. 10705 :param str transaction_ids: If included in the query string, this is a comma separated list of envelope `transactionId`s. If included in the `request_body`, this is a list of envelope `transactionId`s. ###### Note: `transactionId`s are only valid in the DocuSign system for seven days. 10706 :param str user_filter: 10707 :param str user_id: 10708 :param str user_name: 10709 :return: EnvelopesInformation 10710 If the method is called asynchronously, 10711 returns the request thread. 10712 """ 10713 kwargs['_return_http_data_only'] = True 10714 if kwargs.get('callback'): 10715 return self.list_status_changes_with_http_info(account_id, **kwargs) 10716 else: 10717 (data) = self.list_status_changes_with_http_info(account_id, **kwargs) 10718 return data
Gets status changes for one or more envelopes.
Retrieves envelope status changes for all envelopes. You can modify the information returned by adding query strings to limit the request to check between certain dates and times, or for certain envelopes, or for certain status codes. It is recommended that you use one or more of the query strings in order to limit the size of the response. ### Important: Unless you are requesting the status for specific envelopes (using the envelopeIds or transactionIds properties), you must add a set the from_date property in the request. Getting envelope status using transactionIds is useful for offline signing situations where it can be used determine if an envelope was created or not, for the cases where a network connection was lost, before the envelope status could be returned. ### Request Envelope Status Notes ### The REST API GET /envelopes call uses certain filters to find results. In some cases requests are check for "any status change" instead of the just the single status requested. In these cases, more envelopes might be returned by the request than otherwise would be. For example, for a request with the begin date is set to Jan 1st, an end date set to Jan 7th and the status qualifier (from_to_status) set to Delivered — the response set might contain envelopes that were created during that time period, but not delivered during the time period. To avoid unnecessary database queries, the DocuSign system checks requests to ensure that the added filters will not result in a zero-size response before acting on the request. The following table shows the valid envelope statuses (in the Valid Current Statuses column) for the status qualifiers in the request. If the status and status qualifiers in the API request do not contain any of the values shown in the valid current statuses column, then an empty list is returned. For example, a request with a status qualifier (from_to_status) of Delivered and a status of "Created,Sent", DocuSign will always return an empty list. This is because the request essentially translates to: find the envelopes that were delivered between the begin and end dates that have a current status of Created or Sent, and since an envelope that has been delivered can never have a status of Created or Sent, a zero-size response would be generated. In this case, DocuSign does not run the request, but just returns the empty list. Client applications should check that the statuses they are requesting make sense for a given status qualifier.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_status_changes(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str ac_status: Specifies the Authoritative Copy Status for the envelopes. The possible values are: Unknown, Original, Transferred, AuthoritativeCopy, AuthoritativeCopyExportPending, AuthoritativeCopyExported, DepositPending, Deposited, DepositedEO, or DepositFailed.
- str block:
- str cdse_mode:
- str continuation_token:
- str count:
- str custom_field: This specifies the envelope custom field name and value searched for in the envelope information. The value portion of the query can use partial strings by adding '%' (percent sign) around the custom field query value. Example 1: If you have an envelope custom field called "Region" and you want to search for all envelopes where the value is "West" you would use the query:
?custom_field=Region=West. Example 2: To search for envelopes where theApplicationIDcustom field has the value or partial value of "DocuSign" in field, the query would be:?custom_field=ApplicationId=%DocuSign%This would find envelopes where the custom field value is "DocuSign for Salesforce" or "DocuSign envelope." - str email:
- str envelope_ids:
- str exclude:
- str folder_ids:
- str folder_types:
- str from_date: The date/time setting that specifies the date/time when the request begins checking for status changes for envelopes in the account. This is required unless 'envelopeId's are used.
- str from_to_status: This is the status type checked for in the
from_date/to_dateperiod. Ifchangedis specified, then envelopes that changed status during the period are found. If for example,createdis specified, then envelopes created during the period are found. Default ischanged. Possible values are: Voided, Changed, Created, Deleted, Sent, Delivered, Signed, Completed, Declined, TimedOut and Processing. - str include:
- str include_purge_information:
- str intersecting_folder_ids:
- str last_queried_date:
- str order:
- str order_by:
- str powerformids:
- str query_budget:
- str requester_date_format:
- str search_mode:
- str search_text:
- str start_position:
- str status: The list of current statuses to include in the response. By default, all envelopes found are returned. If values are specified, then of the envelopes found, only those with the current status specified are returned in the results. Possible values are: Voided, Created, Deleted, Sent, Delivered, Signed, Completed, Declined, TimedOut and Processing.
- str to_date: Optional date/time setting that specifies the date/time when the request stops for status changes for envelopes in the account. If no entry, the system uses the time of the call as the
to_date. - str transaction_ids: If included in the query string, this is a comma separated list of envelope
transactionIds. If included in therequest_body, this is a list of envelopetransactionIds. ###### Note:transactionIds are only valid in the DocuSign system for seven days. - str user_filter:
- str user_id:
- str user_name:
Returns
EnvelopesInformation If the method is called asynchronously, returns the request thread.
def
list_status_changes_with_http_info(self, account_id, **kwargs)
10720 def list_status_changes_with_http_info(self, account_id, **kwargs): 10721 """ 10722 Gets status changes for one or more envelopes. 10723 Retrieves envelope status changes for all envelopes. You can modify the information returned by adding query strings to limit the request to check between certain dates and times, or for certain envelopes, or for certain status codes. It is recommended that you use one or more of the query strings in order to limit the size of the response. ### Important: Unless you are requesting the status for specific envelopes (using the `envelopeIds` or `transactionIds` properties), you must add a set the `from_date` property in the request. Getting envelope status using `transactionIds` is useful for offline signing situations where it can be used determine if an envelope was created or not, for the cases where a network connection was lost, before the envelope status could be returned. ### Request Envelope Status Notes ### The REST API GET /envelopes call uses certain filters to find results. In some cases requests are check for \"any status change\" instead of the just the single status requested. In these cases, more envelopes might be returned by the request than otherwise would be. For example, for a request with the begin date is set to Jan 1st, an end date set to Jan 7th and the status qualifier (`from_to_status`) set to `Delivered` — the response set might contain envelopes that were created during that time period, but not delivered during the time period. To avoid unnecessary database queries, the DocuSign system checks requests to ensure that the added filters will not result in a zero-size response before acting on the request. The following table shows the valid envelope statuses (in the Valid Current Statuses column) for the status qualifiers in the request. If the status and status qualifiers in the API request do not contain any of the values shown in the valid current statuses column, then an empty list is returned. For example, a request with a status qualifier (from_to_status) of `Delivered` and a status of \"`Created`,`Sent`\", DocuSign will always return an empty list. This is because the request essentially translates to: find the envelopes that were delivered between the begin and end dates that have a current status of `Created` or `Sent`, and since an envelope that has been delivered can never have a status of `Created` or `Sent`, a zero-size response would be generated. In this case, DocuSign does not run the request, but just returns the empty list. Client applications should check that the statuses they are requesting make sense for a given status qualifier. 10724 This method makes a synchronous HTTP request by default. To make an 10725 asynchronous HTTP request, please define a `callback` function 10726 to be invoked when receiving the response. 10727 >>> def callback_function(response): 10728 >>> pprint(response) 10729 >>> 10730 >>> thread = api.list_status_changes_with_http_info(account_id, callback=callback_function) 10731 10732 :param callback function: The callback function 10733 for asynchronous request. (optional) 10734 :param str account_id: The external account number (int) or account ID Guid. (required) 10735 :param str ac_status: Specifies the Authoritative Copy Status for the envelopes. The possible values are: Unknown, Original, Transferred, AuthoritativeCopy, AuthoritativeCopyExportPending, AuthoritativeCopyExported, DepositPending, Deposited, DepositedEO, or DepositFailed. 10736 :param str block: 10737 :param str cdse_mode: 10738 :param str continuation_token: 10739 :param str count: 10740 :param str custom_field: This specifies the envelope custom field name and value searched for in the envelope information. The value portion of the query can use partial strings by adding '%' (percent sign) around the custom field query value. Example 1: If you have an envelope custom field called \"Region\" and you want to search for all envelopes where the value is \"West\" you would use the query: `?custom_field=Region=West`. Example 2: To search for envelopes where the `ApplicationID` custom field has the value or partial value of \"DocuSign\" in field, the query would be: `?custom_field=ApplicationId=%DocuSign%` This would find envelopes where the custom field value is \"DocuSign for Salesforce\" or \"DocuSign envelope.\" 10741 :param str email: 10742 :param str envelope_ids: 10743 :param str exclude: 10744 :param str folder_ids: 10745 :param str folder_types: 10746 :param str from_date: The date/time setting that specifies the date/time when the request begins checking for status changes for envelopes in the account. This is required unless 'envelopeId's are used. 10747 :param str from_to_status: This is the status type checked for in the `from_date`/`to_date` period. If `changed` is specified, then envelopes that changed status during the period are found. If for example, `created` is specified, then envelopes created during the period are found. Default is `changed`. Possible values are: Voided, Changed, Created, Deleted, Sent, Delivered, Signed, Completed, Declined, TimedOut and Processing. 10748 :param str include: 10749 :param str include_purge_information: 10750 :param str intersecting_folder_ids: 10751 :param str last_queried_date: 10752 :param str order: 10753 :param str order_by: 10754 :param str powerformids: 10755 :param str query_budget: 10756 :param str requester_date_format: 10757 :param str search_mode: 10758 :param str search_text: 10759 :param str start_position: 10760 :param str status: The list of current statuses to include in the response. By default, all envelopes found are returned. If values are specified, then of the envelopes found, only those with the current status specified are returned in the results. Possible values are: Voided, Created, Deleted, Sent, Delivered, Signed, Completed, Declined, TimedOut and Processing. 10761 :param str to_date: Optional date/time setting that specifies the date/time when the request stops for status changes for envelopes in the account. If no entry, the system uses the time of the call as the `to_date`. 10762 :param str transaction_ids: If included in the query string, this is a comma separated list of envelope `transactionId`s. If included in the `request_body`, this is a list of envelope `transactionId`s. ###### Note: `transactionId`s are only valid in the DocuSign system for seven days. 10763 :param str user_filter: 10764 :param str user_id: 10765 :param str user_name: 10766 :return: EnvelopesInformation 10767 If the method is called asynchronously, 10768 returns the request thread. 10769 """ 10770 10771 all_params = ['account_id', 'ac_status', 'block', 'cdse_mode', 'continuation_token', 'count', 'custom_field', 'email', 'envelope_ids', 'exclude', 'folder_ids', 'folder_types', 'from_date', 'from_to_status', 'include', 'include_purge_information', 'intersecting_folder_ids', 'last_queried_date', 'order', 'order_by', 'powerformids', 'query_budget', 'requester_date_format', 'search_mode', 'search_text', 'start_position', 'status', 'to_date', 'transaction_ids', 'user_filter', 'user_id', 'user_name'] 10772 all_params.append('callback') 10773 all_params.append('_return_http_data_only') 10774 all_params.append('_preload_content') 10775 all_params.append('_request_timeout') 10776 10777 params = locals() 10778 for key, val in iteritems(params['kwargs']): 10779 if key not in all_params: 10780 raise TypeError( 10781 "Got an unexpected keyword argument '%s'" 10782 " to method list_status_changes" % key 10783 ) 10784 params[key] = val 10785 del params['kwargs'] 10786 # verify the required parameter 'account_id' is set 10787 if ('account_id' not in params) or (params['account_id'] is None): 10788 raise ValueError("Missing the required parameter `account_id` when calling `list_status_changes`") 10789 10790 10791 collection_formats = {} 10792 10793 resource_path = '/v2.1/accounts/{accountId}/envelopes'.replace('{format}', 'json') 10794 path_params = {} 10795 if 'account_id' in params: 10796 path_params['accountId'] = params['account_id'] 10797 10798 query_params = {} 10799 if 'ac_status' in params: 10800 query_params['ac_status'] = params['ac_status'] 10801 if 'block' in params: 10802 query_params['block'] = params['block'] 10803 if 'cdse_mode' in params: 10804 query_params['cdse_mode'] = params['cdse_mode'] 10805 if 'continuation_token' in params: 10806 query_params['continuation_token'] = params['continuation_token'] 10807 if 'count' in params: 10808 query_params['count'] = params['count'] 10809 if 'custom_field' in params: 10810 query_params['custom_field'] = params['custom_field'] 10811 if 'email' in params: 10812 query_params['email'] = params['email'] 10813 if 'envelope_ids' in params: 10814 query_params['envelope_ids'] = params['envelope_ids'] 10815 if 'exclude' in params: 10816 query_params['exclude'] = params['exclude'] 10817 if 'folder_ids' in params: 10818 query_params['folder_ids'] = params['folder_ids'] 10819 if 'folder_types' in params: 10820 query_params['folder_types'] = params['folder_types'] 10821 if 'from_date' in params: 10822 query_params['from_date'] = params['from_date'] 10823 if 'from_to_status' in params: 10824 query_params['from_to_status'] = params['from_to_status'] 10825 if 'include' in params: 10826 query_params['include'] = params['include'] 10827 if 'include_purge_information' in params: 10828 query_params['include_purge_information'] = params['include_purge_information'] 10829 if 'intersecting_folder_ids' in params: 10830 query_params['intersecting_folder_ids'] = params['intersecting_folder_ids'] 10831 if 'last_queried_date' in params: 10832 query_params['last_queried_date'] = params['last_queried_date'] 10833 if 'order' in params: 10834 query_params['order'] = params['order'] 10835 if 'order_by' in params: 10836 query_params['order_by'] = params['order_by'] 10837 if 'powerformids' in params: 10838 query_params['powerformids'] = params['powerformids'] 10839 if 'query_budget' in params: 10840 query_params['query_budget'] = params['query_budget'] 10841 if 'requester_date_format' in params: 10842 query_params['requester_date_format'] = params['requester_date_format'] 10843 if 'search_mode' in params: 10844 query_params['search_mode'] = params['search_mode'] 10845 if 'search_text' in params: 10846 query_params['search_text'] = params['search_text'] 10847 if 'start_position' in params: 10848 query_params['start_position'] = params['start_position'] 10849 if 'status' in params: 10850 query_params['status'] = params['status'] 10851 if 'to_date' in params: 10852 query_params['to_date'] = params['to_date'] 10853 if 'transaction_ids' in params: 10854 query_params['transaction_ids'] = params['transaction_ids'] 10855 if 'user_filter' in params: 10856 query_params['user_filter'] = params['user_filter'] 10857 if 'user_id' in params: 10858 query_params['user_id'] = params['user_id'] 10859 if 'user_name' in params: 10860 query_params['user_name'] = params['user_name'] 10861 10862 header_params = {} 10863 10864 form_params = [] 10865 local_var_files = {} 10866 10867 body_params = None 10868 # HTTP header `Accept` 10869 header_params['Accept'] = self.api_client.\ 10870 select_header_accept(['application/json']) 10871 10872 # Authentication setting 10873 auth_settings = [] 10874 10875 return self.api_client.call_api(resource_path, 'GET', 10876 path_params, 10877 query_params, 10878 header_params, 10879 body=body_params, 10880 post_params=form_params, 10881 files=local_var_files, 10882 response_type='EnvelopesInformation', 10883 auth_settings=auth_settings, 10884 callback=params.get('callback'), 10885 _return_http_data_only=params.get('_return_http_data_only'), 10886 _preload_content=params.get('_preload_content', True), 10887 _request_timeout=params.get('_request_timeout'), 10888 collection_formats=collection_formats)
Gets status changes for one or more envelopes.
Retrieves envelope status changes for all envelopes. You can modify the information returned by adding query strings to limit the request to check between certain dates and times, or for certain envelopes, or for certain status codes. It is recommended that you use one or more of the query strings in order to limit the size of the response. ### Important: Unless you are requesting the status for specific envelopes (using the envelopeIds or transactionIds properties), you must add a set the from_date property in the request. Getting envelope status using transactionIds is useful for offline signing situations where it can be used determine if an envelope was created or not, for the cases where a network connection was lost, before the envelope status could be returned. ### Request Envelope Status Notes ### The REST API GET /envelopes call uses certain filters to find results. In some cases requests are check for "any status change" instead of the just the single status requested. In these cases, more envelopes might be returned by the request than otherwise would be. For example, for a request with the begin date is set to Jan 1st, an end date set to Jan 7th and the status qualifier (from_to_status) set to Delivered — the response set might contain envelopes that were created during that time period, but not delivered during the time period. To avoid unnecessary database queries, the DocuSign system checks requests to ensure that the added filters will not result in a zero-size response before acting on the request. The following table shows the valid envelope statuses (in the Valid Current Statuses column) for the status qualifiers in the request. If the status and status qualifiers in the API request do not contain any of the values shown in the valid current statuses column, then an empty list is returned. For example, a request with a status qualifier (from_to_status) of Delivered and a status of "Created,Sent", DocuSign will always return an empty list. This is because the request essentially translates to: find the envelopes that were delivered between the begin and end dates that have a current status of Created or Sent, and since an envelope that has been delivered can never have a status of Created or Sent, a zero-size response would be generated. In this case, DocuSign does not run the request, but just returns the empty list. Client applications should check that the statuses they are requesting make sense for a given status qualifier.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_status_changes_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str ac_status: Specifies the Authoritative Copy Status for the envelopes. The possible values are: Unknown, Original, Transferred, AuthoritativeCopy, AuthoritativeCopyExportPending, AuthoritativeCopyExported, DepositPending, Deposited, DepositedEO, or DepositFailed.
- str block:
- str cdse_mode:
- str continuation_token:
- str count:
- str custom_field: This specifies the envelope custom field name and value searched for in the envelope information. The value portion of the query can use partial strings by adding '%' (percent sign) around the custom field query value. Example 1: If you have an envelope custom field called "Region" and you want to search for all envelopes where the value is "West" you would use the query:
?custom_field=Region=West. Example 2: To search for envelopes where theApplicationIDcustom field has the value or partial value of "DocuSign" in field, the query would be:?custom_field=ApplicationId=%DocuSign%This would find envelopes where the custom field value is "DocuSign for Salesforce" or "DocuSign envelope." - str email:
- str envelope_ids:
- str exclude:
- str folder_ids:
- str folder_types:
- str from_date: The date/time setting that specifies the date/time when the request begins checking for status changes for envelopes in the account. This is required unless 'envelopeId's are used.
- str from_to_status: This is the status type checked for in the
from_date/to_dateperiod. Ifchangedis specified, then envelopes that changed status during the period are found. If for example,createdis specified, then envelopes created during the period are found. Default ischanged. Possible values are: Voided, Changed, Created, Deleted, Sent, Delivered, Signed, Completed, Declined, TimedOut and Processing. - str include:
- str include_purge_information:
- str intersecting_folder_ids:
- str last_queried_date:
- str order:
- str order_by:
- str powerformids:
- str query_budget:
- str requester_date_format:
- str search_mode:
- str search_text:
- str start_position:
- str status: The list of current statuses to include in the response. By default, all envelopes found are returned. If values are specified, then of the envelopes found, only those with the current status specified are returned in the results. Possible values are: Voided, Created, Deleted, Sent, Delivered, Signed, Completed, Declined, TimedOut and Processing.
- str to_date: Optional date/time setting that specifies the date/time when the request stops for status changes for envelopes in the account. If no entry, the system uses the time of the call as the
to_date. - str transaction_ids: If included in the query string, this is a comma separated list of envelope
transactionIds. If included in therequest_body, this is a list of envelopetransactionIds. ###### Note:transactionIds are only valid in the DocuSign system for seven days. - str user_filter:
- str user_id:
- str user_name:
Returns
EnvelopesInformation If the method is called asynchronously, returns the request thread.
def
list_tabs(self, account_id, envelope_id, recipient_id, **kwargs)
10890 def list_tabs(self, account_id, envelope_id, recipient_id, **kwargs): 10891 """ 10892 Gets the tabs information for a signer or sign-in-person recipient in an envelope. 10893 Retrieves information about the tabs associated with a recipient in a draft envelope. 10894 This method makes a synchronous HTTP request by default. To make an 10895 asynchronous HTTP request, please define a `callback` function 10896 to be invoked when receiving the response. 10897 >>> def callback_function(response): 10898 >>> pprint(response) 10899 >>> 10900 >>> thread = api.list_tabs(account_id, envelope_id, recipient_id, callback=callback_function) 10901 10902 :param callback function: The callback function 10903 for asynchronous request. (optional) 10904 :param str account_id: The external account number (int) or account ID Guid. (required) 10905 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10906 :param str recipient_id: The ID of the recipient being accessed. (required) 10907 :param str include_anchor_tab_locations: When set to **true**, all tabs with anchor tab properties are included in the response. 10908 :param str include_metadata: 10909 :return: Tabs 10910 If the method is called asynchronously, 10911 returns the request thread. 10912 """ 10913 kwargs['_return_http_data_only'] = True 10914 if kwargs.get('callback'): 10915 return self.list_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 10916 else: 10917 (data) = self.list_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 10918 return data
Gets the tabs information for a signer or sign-in-person recipient in an envelope.
Retrieves information about the tabs associated with a recipient in a draft envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_tabs(account_id, envelope_id, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
- str include_anchor_tab_locations: When set to true, all tabs with anchor tab properties are included in the response.
- str include_metadata:
Returns
Tabs If the method is called asynchronously, returns the request thread.
def
list_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs)
10920 def list_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 10921 """ 10922 Gets the tabs information for a signer or sign-in-person recipient in an envelope. 10923 Retrieves information about the tabs associated with a recipient in a draft envelope. 10924 This method makes a synchronous HTTP request by default. To make an 10925 asynchronous HTTP request, please define a `callback` function 10926 to be invoked when receiving the response. 10927 >>> def callback_function(response): 10928 >>> pprint(response) 10929 >>> 10930 >>> thread = api.list_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 10931 10932 :param callback function: The callback function 10933 for asynchronous request. (optional) 10934 :param str account_id: The external account number (int) or account ID Guid. (required) 10935 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10936 :param str recipient_id: The ID of the recipient being accessed. (required) 10937 :param str include_anchor_tab_locations: When set to **true**, all tabs with anchor tab properties are included in the response. 10938 :param str include_metadata: 10939 :return: Tabs 10940 If the method is called asynchronously, 10941 returns the request thread. 10942 """ 10943 10944 all_params = ['account_id', 'envelope_id', 'recipient_id', 'include_anchor_tab_locations', 'include_metadata'] 10945 all_params.append('callback') 10946 all_params.append('_return_http_data_only') 10947 all_params.append('_preload_content') 10948 all_params.append('_request_timeout') 10949 10950 params = locals() 10951 for key, val in iteritems(params['kwargs']): 10952 if key not in all_params: 10953 raise TypeError( 10954 "Got an unexpected keyword argument '%s'" 10955 " to method list_tabs" % key 10956 ) 10957 params[key] = val 10958 del params['kwargs'] 10959 # verify the required parameter 'account_id' is set 10960 if ('account_id' not in params) or (params['account_id'] is None): 10961 raise ValueError("Missing the required parameter `account_id` when calling `list_tabs`") 10962 # verify the required parameter 'envelope_id' is set 10963 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10964 raise ValueError("Missing the required parameter `envelope_id` when calling `list_tabs`") 10965 # verify the required parameter 'recipient_id' is set 10966 if ('recipient_id' not in params) or (params['recipient_id'] is None): 10967 raise ValueError("Missing the required parameter `recipient_id` when calling `list_tabs`") 10968 10969 10970 collection_formats = {} 10971 10972 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/tabs'.replace('{format}', 'json') 10973 path_params = {} 10974 if 'account_id' in params: 10975 path_params['accountId'] = params['account_id'] 10976 if 'envelope_id' in params: 10977 path_params['envelopeId'] = params['envelope_id'] 10978 if 'recipient_id' in params: 10979 path_params['recipientId'] = params['recipient_id'] 10980 10981 query_params = {} 10982 if 'include_anchor_tab_locations' in params: 10983 query_params['include_anchor_tab_locations'] = params['include_anchor_tab_locations'] 10984 if 'include_metadata' in params: 10985 query_params['include_metadata'] = params['include_metadata'] 10986 10987 header_params = {} 10988 10989 form_params = [] 10990 local_var_files = {} 10991 10992 body_params = None 10993 # HTTP header `Accept` 10994 header_params['Accept'] = self.api_client.\ 10995 select_header_accept(['application/json']) 10996 10997 # Authentication setting 10998 auth_settings = [] 10999 11000 return self.api_client.call_api(resource_path, 'GET', 11001 path_params, 11002 query_params, 11003 header_params, 11004 body=body_params, 11005 post_params=form_params, 11006 files=local_var_files, 11007 response_type='Tabs', 11008 auth_settings=auth_settings, 11009 callback=params.get('callback'), 11010 _return_http_data_only=params.get('_return_http_data_only'), 11011 _preload_content=params.get('_preload_content', True), 11012 _request_timeout=params.get('_request_timeout'), 11013 collection_formats=collection_formats)
Gets the tabs information for a signer or sign-in-person recipient in an envelope.
Retrieves information about the tabs associated with a recipient in a draft envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
- str include_anchor_tab_locations: When set to true, all tabs with anchor tab properties are included in the response.
- str include_metadata:
Returns
Tabs If the method is called asynchronously, returns the request thread.
def
list_templates(self, account_id, envelope_id, **kwargs)
11015 def list_templates(self, account_id, envelope_id, **kwargs): 11016 """ 11017 Get List of Templates used in an Envelope 11018 This returns a list of the server-side templates, their name and ID, used in an envelope. 11019 This method makes a synchronous HTTP request by default. To make an 11020 asynchronous HTTP request, please define a `callback` function 11021 to be invoked when receiving the response. 11022 >>> def callback_function(response): 11023 >>> pprint(response) 11024 >>> 11025 >>> thread = api.list_templates(account_id, envelope_id, callback=callback_function) 11026 11027 :param callback function: The callback function 11028 for asynchronous request. (optional) 11029 :param str account_id: The external account number (int) or account ID Guid. (required) 11030 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11031 :param str include: The possible values are: matching_applied - This returns template matching information for the template. 11032 :return: TemplateInformation 11033 If the method is called asynchronously, 11034 returns the request thread. 11035 """ 11036 kwargs['_return_http_data_only'] = True 11037 if kwargs.get('callback'): 11038 return self.list_templates_with_http_info(account_id, envelope_id, **kwargs) 11039 else: 11040 (data) = self.list_templates_with_http_info(account_id, envelope_id, **kwargs) 11041 return data
Get List of Templates used in an Envelope
This returns a list of the server-side templates, their name and ID, used in an envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_templates(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str include: The possible values are: matching_applied - This returns template matching information for the template.
Returns
TemplateInformation If the method is called asynchronously, returns the request thread.
def
list_templates_with_http_info(self, account_id, envelope_id, **kwargs)
11043 def list_templates_with_http_info(self, account_id, envelope_id, **kwargs): 11044 """ 11045 Get List of Templates used in an Envelope 11046 This returns a list of the server-side templates, their name and ID, used in an envelope. 11047 This method makes a synchronous HTTP request by default. To make an 11048 asynchronous HTTP request, please define a `callback` function 11049 to be invoked when receiving the response. 11050 >>> def callback_function(response): 11051 >>> pprint(response) 11052 >>> 11053 >>> thread = api.list_templates_with_http_info(account_id, envelope_id, callback=callback_function) 11054 11055 :param callback function: The callback function 11056 for asynchronous request. (optional) 11057 :param str account_id: The external account number (int) or account ID Guid. (required) 11058 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11059 :param str include: The possible values are: matching_applied - This returns template matching information for the template. 11060 :return: TemplateInformation 11061 If the method is called asynchronously, 11062 returns the request thread. 11063 """ 11064 11065 all_params = ['account_id', 'envelope_id', 'include'] 11066 all_params.append('callback') 11067 all_params.append('_return_http_data_only') 11068 all_params.append('_preload_content') 11069 all_params.append('_request_timeout') 11070 11071 params = locals() 11072 for key, val in iteritems(params['kwargs']): 11073 if key not in all_params: 11074 raise TypeError( 11075 "Got an unexpected keyword argument '%s'" 11076 " to method list_templates" % key 11077 ) 11078 params[key] = val 11079 del params['kwargs'] 11080 # verify the required parameter 'account_id' is set 11081 if ('account_id' not in params) or (params['account_id'] is None): 11082 raise ValueError("Missing the required parameter `account_id` when calling `list_templates`") 11083 # verify the required parameter 'envelope_id' is set 11084 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11085 raise ValueError("Missing the required parameter `envelope_id` when calling `list_templates`") 11086 11087 11088 collection_formats = {} 11089 11090 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/templates'.replace('{format}', 'json') 11091 path_params = {} 11092 if 'account_id' in params: 11093 path_params['accountId'] = params['account_id'] 11094 if 'envelope_id' in params: 11095 path_params['envelopeId'] = params['envelope_id'] 11096 11097 query_params = {} 11098 if 'include' in params: 11099 query_params['include'] = params['include'] 11100 11101 header_params = {} 11102 11103 form_params = [] 11104 local_var_files = {} 11105 11106 body_params = None 11107 # HTTP header `Accept` 11108 header_params['Accept'] = self.api_client.\ 11109 select_header_accept(['application/json']) 11110 11111 # Authentication setting 11112 auth_settings = [] 11113 11114 return self.api_client.call_api(resource_path, 'GET', 11115 path_params, 11116 query_params, 11117 header_params, 11118 body=body_params, 11119 post_params=form_params, 11120 files=local_var_files, 11121 response_type='TemplateInformation', 11122 auth_settings=auth_settings, 11123 callback=params.get('callback'), 11124 _return_http_data_only=params.get('_return_http_data_only'), 11125 _preload_content=params.get('_preload_content', True), 11126 _request_timeout=params.get('_request_timeout'), 11127 collection_formats=collection_formats)
Get List of Templates used in an Envelope
This returns a list of the server-side templates, their name and ID, used in an envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_templates_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str include: The possible values are: matching_applied - This returns template matching information for the template.
Returns
TemplateInformation If the method is called asynchronously, returns the request thread.
def
list_templates_for_document(self, account_id, document_id, envelope_id, **kwargs)
11129 def list_templates_for_document(self, account_id, document_id, envelope_id, **kwargs): 11130 """ 11131 Gets the templates associated with a document in an existing envelope. 11132 Retrieves the templates associated with a document in the specified envelope. 11133 This method makes a synchronous HTTP request by default. To make an 11134 asynchronous HTTP request, please define a `callback` function 11135 to be invoked when receiving the response. 11136 >>> def callback_function(response): 11137 >>> pprint(response) 11138 >>> 11139 >>> thread = api.list_templates_for_document(account_id, document_id, envelope_id, callback=callback_function) 11140 11141 :param callback function: The callback function 11142 for asynchronous request. (optional) 11143 :param str account_id: The external account number (int) or account ID Guid. (required) 11144 :param str document_id: The ID of the document being accessed. (required) 11145 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11146 :param str include: 11147 :return: TemplateInformation 11148 If the method is called asynchronously, 11149 returns the request thread. 11150 """ 11151 kwargs['_return_http_data_only'] = True 11152 if kwargs.get('callback'): 11153 return self.list_templates_for_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 11154 else: 11155 (data) = self.list_templates_for_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 11156 return data
Gets the templates associated with a document in an existing envelope.
Retrieves the templates associated with a document in the specified envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_templates_for_document(account_id, document_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str include:
Returns
TemplateInformation If the method is called asynchronously, returns the request thread.
def
list_templates_for_document_with_http_info(self, account_id, document_id, envelope_id, **kwargs)
11158 def list_templates_for_document_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 11159 """ 11160 Gets the templates associated with a document in an existing envelope. 11161 Retrieves the templates associated with a document in the specified envelope. 11162 This method makes a synchronous HTTP request by default. To make an 11163 asynchronous HTTP request, please define a `callback` function 11164 to be invoked when receiving the response. 11165 >>> def callback_function(response): 11166 >>> pprint(response) 11167 >>> 11168 >>> thread = api.list_templates_for_document_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 11169 11170 :param callback function: The callback function 11171 for asynchronous request. (optional) 11172 :param str account_id: The external account number (int) or account ID Guid. (required) 11173 :param str document_id: The ID of the document being accessed. (required) 11174 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11175 :param str include: 11176 :return: TemplateInformation 11177 If the method is called asynchronously, 11178 returns the request thread. 11179 """ 11180 11181 all_params = ['account_id', 'document_id', 'envelope_id', 'include'] 11182 all_params.append('callback') 11183 all_params.append('_return_http_data_only') 11184 all_params.append('_preload_content') 11185 all_params.append('_request_timeout') 11186 11187 params = locals() 11188 for key, val in iteritems(params['kwargs']): 11189 if key not in all_params: 11190 raise TypeError( 11191 "Got an unexpected keyword argument '%s'" 11192 " to method list_templates_for_document" % key 11193 ) 11194 params[key] = val 11195 del params['kwargs'] 11196 # verify the required parameter 'account_id' is set 11197 if ('account_id' not in params) or (params['account_id'] is None): 11198 raise ValueError("Missing the required parameter `account_id` when calling `list_templates_for_document`") 11199 # verify the required parameter 'document_id' is set 11200 if ('document_id' not in params) or (params['document_id'] is None): 11201 raise ValueError("Missing the required parameter `document_id` when calling `list_templates_for_document`") 11202 # verify the required parameter 'envelope_id' is set 11203 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11204 raise ValueError("Missing the required parameter `envelope_id` when calling `list_templates_for_document`") 11205 11206 11207 collection_formats = {} 11208 11209 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/templates'.replace('{format}', 'json') 11210 path_params = {} 11211 if 'account_id' in params: 11212 path_params['accountId'] = params['account_id'] 11213 if 'document_id' in params: 11214 path_params['documentId'] = params['document_id'] 11215 if 'envelope_id' in params: 11216 path_params['envelopeId'] = params['envelope_id'] 11217 11218 query_params = {} 11219 if 'include' in params: 11220 query_params['include'] = params['include'] 11221 11222 header_params = {} 11223 11224 form_params = [] 11225 local_var_files = {} 11226 11227 body_params = None 11228 # HTTP header `Accept` 11229 header_params['Accept'] = self.api_client.\ 11230 select_header_accept(['application/json']) 11231 11232 # Authentication setting 11233 auth_settings = [] 11234 11235 return self.api_client.call_api(resource_path, 'GET', 11236 path_params, 11237 query_params, 11238 header_params, 11239 body=body_params, 11240 post_params=form_params, 11241 files=local_var_files, 11242 response_type='TemplateInformation', 11243 auth_settings=auth_settings, 11244 callback=params.get('callback'), 11245 _return_http_data_only=params.get('_return_http_data_only'), 11246 _preload_content=params.get('_preload_content', True), 11247 _request_timeout=params.get('_request_timeout'), 11248 collection_formats=collection_formats)
Gets the templates associated with a document in an existing envelope.
Retrieves the templates associated with a document in the specified envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_templates_for_document_with_http_info(account_id, document_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str include:
Returns
TemplateInformation If the method is called asynchronously, returns the request thread.
def
put_attachment(self, account_id, attachment_id, envelope_id, **kwargs)
11250 def put_attachment(self, account_id, attachment_id, envelope_id, **kwargs): 11251 """ 11252 Add an attachment to a DRAFT or IN-PROCESS envelope. 11253 Adds an attachment to a draft or in-process envelope. 11254 This method makes a synchronous HTTP request by default. To make an 11255 asynchronous HTTP request, please define a `callback` function 11256 to be invoked when receiving the response. 11257 >>> def callback_function(response): 11258 >>> pprint(response) 11259 >>> 11260 >>> thread = api.put_attachment(account_id, attachment_id, envelope_id, callback=callback_function) 11261 11262 :param callback function: The callback function 11263 for asynchronous request. (optional) 11264 :param str account_id: The external account number (int) or account ID Guid. (required) 11265 :param str attachment_id: (required) 11266 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11267 :param Attachment attachment: 11268 :return: EnvelopeAttachmentsResult 11269 If the method is called asynchronously, 11270 returns the request thread. 11271 """ 11272 kwargs['_return_http_data_only'] = True 11273 if kwargs.get('callback'): 11274 return self.put_attachment_with_http_info(account_id, attachment_id, envelope_id, **kwargs) 11275 else: 11276 (data) = self.put_attachment_with_http_info(account_id, attachment_id, envelope_id, **kwargs) 11277 return data
Add an attachment to a DRAFT or IN-PROCESS envelope.
Adds an attachment to a draft or in-process envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.put_attachment(account_id, attachment_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str attachment_id: (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- Attachment attachment:
Returns
EnvelopeAttachmentsResult If the method is called asynchronously, returns the request thread.
def
put_attachment_with_http_info(self, account_id, attachment_id, envelope_id, **kwargs)
11279 def put_attachment_with_http_info(self, account_id, attachment_id, envelope_id, **kwargs): 11280 """ 11281 Add an attachment to a DRAFT or IN-PROCESS envelope. 11282 Adds an attachment to a draft or in-process envelope. 11283 This method makes a synchronous HTTP request by default. To make an 11284 asynchronous HTTP request, please define a `callback` function 11285 to be invoked when receiving the response. 11286 >>> def callback_function(response): 11287 >>> pprint(response) 11288 >>> 11289 >>> thread = api.put_attachment_with_http_info(account_id, attachment_id, envelope_id, callback=callback_function) 11290 11291 :param callback function: The callback function 11292 for asynchronous request. (optional) 11293 :param str account_id: The external account number (int) or account ID Guid. (required) 11294 :param str attachment_id: (required) 11295 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11296 :param Attachment attachment: 11297 :return: EnvelopeAttachmentsResult 11298 If the method is called asynchronously, 11299 returns the request thread. 11300 """ 11301 11302 all_params = ['account_id', 'attachment_id', 'envelope_id', 'attachment'] 11303 all_params.append('callback') 11304 all_params.append('_return_http_data_only') 11305 all_params.append('_preload_content') 11306 all_params.append('_request_timeout') 11307 11308 params = locals() 11309 for key, val in iteritems(params['kwargs']): 11310 if key not in all_params: 11311 raise TypeError( 11312 "Got an unexpected keyword argument '%s'" 11313 " to method put_attachment" % key 11314 ) 11315 params[key] = val 11316 del params['kwargs'] 11317 # verify the required parameter 'account_id' is set 11318 if ('account_id' not in params) or (params['account_id'] is None): 11319 raise ValueError("Missing the required parameter `account_id` when calling `put_attachment`") 11320 # verify the required parameter 'attachment_id' is set 11321 if ('attachment_id' not in params) or (params['attachment_id'] is None): 11322 raise ValueError("Missing the required parameter `attachment_id` when calling `put_attachment`") 11323 # verify the required parameter 'envelope_id' is set 11324 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11325 raise ValueError("Missing the required parameter `envelope_id` when calling `put_attachment`") 11326 11327 11328 collection_formats = {} 11329 11330 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments/{attachmentId}'.replace('{format}', 'json') 11331 path_params = {} 11332 if 'account_id' in params: 11333 path_params['accountId'] = params['account_id'] 11334 if 'attachment_id' in params: 11335 path_params['attachmentId'] = params['attachment_id'] 11336 if 'envelope_id' in params: 11337 path_params['envelopeId'] = params['envelope_id'] 11338 11339 query_params = {} 11340 11341 header_params = {} 11342 11343 form_params = [] 11344 local_var_files = {} 11345 11346 body_params = None 11347 if 'attachment' in params: 11348 body_params = params['attachment'] 11349 # HTTP header `Accept` 11350 header_params['Accept'] = self.api_client.\ 11351 select_header_accept(['application/json']) 11352 11353 # Authentication setting 11354 auth_settings = [] 11355 11356 return self.api_client.call_api(resource_path, 'PUT', 11357 path_params, 11358 query_params, 11359 header_params, 11360 body=body_params, 11361 post_params=form_params, 11362 files=local_var_files, 11363 response_type='EnvelopeAttachmentsResult', 11364 auth_settings=auth_settings, 11365 callback=params.get('callback'), 11366 _return_http_data_only=params.get('_return_http_data_only'), 11367 _preload_content=params.get('_preload_content', True), 11368 _request_timeout=params.get('_request_timeout'), 11369 collection_formats=collection_formats)
Add an attachment to a DRAFT or IN-PROCESS envelope.
Adds an attachment to a draft or in-process envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.put_attachment_with_http_info(account_id, attachment_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str attachment_id: (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- Attachment attachment:
Returns
EnvelopeAttachmentsResult If the method is called asynchronously, returns the request thread.
def
put_attachments(self, account_id, envelope_id, **kwargs)
11371 def put_attachments(self, account_id, envelope_id, **kwargs): 11372 """ 11373 Add one or more attachments to a DRAFT or IN-PROCESS envelope. 11374 Adds one or more attachments to a draft or in-process envelope. Envelope attachments are files that an application can include in an envelope. They are not converted to PDF. Envelope attachments are available only through the API. There is no user interface in the DocuSign web application for them. For a list of supported file formats, see [Supported File Formats](https://support.docusign.com/guides/ndse-user-guide-supported-file-formats). 11375 This method makes a synchronous HTTP request by default. To make an 11376 asynchronous HTTP request, please define a `callback` function 11377 to be invoked when receiving the response. 11378 >>> def callback_function(response): 11379 >>> pprint(response) 11380 >>> 11381 >>> thread = api.put_attachments(account_id, envelope_id, callback=callback_function) 11382 11383 :param callback function: The callback function 11384 for asynchronous request. (optional) 11385 :param str account_id: The external account number (int) or account ID Guid. (required) 11386 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11387 :param EnvelopeAttachmentsRequest envelope_attachments_request: 11388 :return: EnvelopeAttachmentsResult 11389 If the method is called asynchronously, 11390 returns the request thread. 11391 """ 11392 kwargs['_return_http_data_only'] = True 11393 if kwargs.get('callback'): 11394 return self.put_attachments_with_http_info(account_id, envelope_id, **kwargs) 11395 else: 11396 (data) = self.put_attachments_with_http_info(account_id, envelope_id, **kwargs) 11397 return data
Add one or more attachments to a DRAFT or IN-PROCESS envelope.
Adds one or more attachments to a draft or in-process envelope. Envelope attachments are files that an application can include in an envelope. They are not converted to PDF. Envelope attachments are available only through the API. There is no user interface in the DocuSign web application for them. For a list of supported file formats, see Supported File Formats.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.put_attachments(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- EnvelopeAttachmentsRequest envelope_attachments_request:
Returns
EnvelopeAttachmentsResult If the method is called asynchronously, returns the request thread.
def
put_attachments_with_http_info(self, account_id, envelope_id, **kwargs)
11399 def put_attachments_with_http_info(self, account_id, envelope_id, **kwargs): 11400 """ 11401 Add one or more attachments to a DRAFT or IN-PROCESS envelope. 11402 Adds one or more attachments to a draft or in-process envelope. Envelope attachments are files that an application can include in an envelope. They are not converted to PDF. Envelope attachments are available only through the API. There is no user interface in the DocuSign web application for them. For a list of supported file formats, see [Supported File Formats](https://support.docusign.com/guides/ndse-user-guide-supported-file-formats). 11403 This method makes a synchronous HTTP request by default. To make an 11404 asynchronous HTTP request, please define a `callback` function 11405 to be invoked when receiving the response. 11406 >>> def callback_function(response): 11407 >>> pprint(response) 11408 >>> 11409 >>> thread = api.put_attachments_with_http_info(account_id, envelope_id, callback=callback_function) 11410 11411 :param callback function: The callback function 11412 for asynchronous request. (optional) 11413 :param str account_id: The external account number (int) or account ID Guid. (required) 11414 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11415 :param EnvelopeAttachmentsRequest envelope_attachments_request: 11416 :return: EnvelopeAttachmentsResult 11417 If the method is called asynchronously, 11418 returns the request thread. 11419 """ 11420 11421 all_params = ['account_id', 'envelope_id', 'envelope_attachments_request'] 11422 all_params.append('callback') 11423 all_params.append('_return_http_data_only') 11424 all_params.append('_preload_content') 11425 all_params.append('_request_timeout') 11426 11427 params = locals() 11428 for key, val in iteritems(params['kwargs']): 11429 if key not in all_params: 11430 raise TypeError( 11431 "Got an unexpected keyword argument '%s'" 11432 " to method put_attachments" % key 11433 ) 11434 params[key] = val 11435 del params['kwargs'] 11436 # verify the required parameter 'account_id' is set 11437 if ('account_id' not in params) or (params['account_id'] is None): 11438 raise ValueError("Missing the required parameter `account_id` when calling `put_attachments`") 11439 # verify the required parameter 'envelope_id' is set 11440 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11441 raise ValueError("Missing the required parameter `envelope_id` when calling `put_attachments`") 11442 11443 11444 collection_formats = {} 11445 11446 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments'.replace('{format}', 'json') 11447 path_params = {} 11448 if 'account_id' in params: 11449 path_params['accountId'] = params['account_id'] 11450 if 'envelope_id' in params: 11451 path_params['envelopeId'] = params['envelope_id'] 11452 11453 query_params = {} 11454 11455 header_params = {} 11456 11457 form_params = [] 11458 local_var_files = {} 11459 11460 body_params = None 11461 if 'envelope_attachments_request' in params: 11462 body_params = params['envelope_attachments_request'] 11463 # HTTP header `Accept` 11464 header_params['Accept'] = self.api_client.\ 11465 select_header_accept(['application/json']) 11466 11467 # Authentication setting 11468 auth_settings = [] 11469 11470 return self.api_client.call_api(resource_path, 'PUT', 11471 path_params, 11472 query_params, 11473 header_params, 11474 body=body_params, 11475 post_params=form_params, 11476 files=local_var_files, 11477 response_type='EnvelopeAttachmentsResult', 11478 auth_settings=auth_settings, 11479 callback=params.get('callback'), 11480 _return_http_data_only=params.get('_return_http_data_only'), 11481 _preload_content=params.get('_preload_content', True), 11482 _request_timeout=params.get('_request_timeout'), 11483 collection_formats=collection_formats)
Add one or more attachments to a DRAFT or IN-PROCESS envelope.
Adds one or more attachments to a draft or in-process envelope. Envelope attachments are files that an application can include in an envelope. They are not converted to PDF. Envelope attachments are available only through the API. There is no user interface in the DocuSign web application for them. For a list of supported file formats, see Supported File Formats.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.put_attachments_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- EnvelopeAttachmentsRequest envelope_attachments_request:
Returns
EnvelopeAttachmentsResult If the method is called asynchronously, returns the request thread.
def
rotate_document_page(self, account_id, document_id, envelope_id, page_number, **kwargs)
11485 def rotate_document_page(self, account_id, document_id, envelope_id, page_number, **kwargs): 11486 """ 11487 Rotates page image from an envelope for display. 11488 Rotates page image from an envelope for display. The page image can be rotated to the left or right. 11489 This method makes a synchronous HTTP request by default. To make an 11490 asynchronous HTTP request, please define a `callback` function 11491 to be invoked when receiving the response. 11492 >>> def callback_function(response): 11493 >>> pprint(response) 11494 >>> 11495 >>> thread = api.rotate_document_page(account_id, document_id, envelope_id, page_number, callback=callback_function) 11496 11497 :param callback function: The callback function 11498 for asynchronous request. (optional) 11499 :param str account_id: The external account number (int) or account ID Guid. (required) 11500 :param str document_id: The ID of the document being accessed. (required) 11501 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11502 :param str page_number: The page number being accessed. (required) 11503 :param PageRequest page_request: 11504 :return: None 11505 If the method is called asynchronously, 11506 returns the request thread. 11507 """ 11508 kwargs['_return_http_data_only'] = True 11509 if kwargs.get('callback'): 11510 return self.rotate_document_page_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 11511 else: 11512 (data) = self.rotate_document_page_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 11513 return data
Rotates page image from an envelope for display.
Rotates page image from an envelope for display. The page image can be rotated to the left or right.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.rotate_document_page(account_id, document_id, envelope_id, page_number, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str page_number: The page number being accessed. (required)
- PageRequest page_request:
Returns
None If the method is called asynchronously, returns the request thread.
def
rotate_document_page_with_http_info(self, account_id, document_id, envelope_id, page_number, **kwargs)
11515 def rotate_document_page_with_http_info(self, account_id, document_id, envelope_id, page_number, **kwargs): 11516 """ 11517 Rotates page image from an envelope for display. 11518 Rotates page image from an envelope for display. The page image can be rotated to the left or right. 11519 This method makes a synchronous HTTP request by default. To make an 11520 asynchronous HTTP request, please define a `callback` function 11521 to be invoked when receiving the response. 11522 >>> def callback_function(response): 11523 >>> pprint(response) 11524 >>> 11525 >>> thread = api.rotate_document_page_with_http_info(account_id, document_id, envelope_id, page_number, callback=callback_function) 11526 11527 :param callback function: The callback function 11528 for asynchronous request. (optional) 11529 :param str account_id: The external account number (int) or account ID Guid. (required) 11530 :param str document_id: The ID of the document being accessed. (required) 11531 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11532 :param str page_number: The page number being accessed. (required) 11533 :param PageRequest page_request: 11534 :return: None 11535 If the method is called asynchronously, 11536 returns the request thread. 11537 """ 11538 11539 all_params = ['account_id', 'document_id', 'envelope_id', 'page_number', 'page_request'] 11540 all_params.append('callback') 11541 all_params.append('_return_http_data_only') 11542 all_params.append('_preload_content') 11543 all_params.append('_request_timeout') 11544 11545 params = locals() 11546 for key, val in iteritems(params['kwargs']): 11547 if key not in all_params: 11548 raise TypeError( 11549 "Got an unexpected keyword argument '%s'" 11550 " to method rotate_document_page" % key 11551 ) 11552 params[key] = val 11553 del params['kwargs'] 11554 # verify the required parameter 'account_id' is set 11555 if ('account_id' not in params) or (params['account_id'] is None): 11556 raise ValueError("Missing the required parameter `account_id` when calling `rotate_document_page`") 11557 # verify the required parameter 'document_id' is set 11558 if ('document_id' not in params) or (params['document_id'] is None): 11559 raise ValueError("Missing the required parameter `document_id` when calling `rotate_document_page`") 11560 # verify the required parameter 'envelope_id' is set 11561 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11562 raise ValueError("Missing the required parameter `envelope_id` when calling `rotate_document_page`") 11563 # verify the required parameter 'page_number' is set 11564 if ('page_number' not in params) or (params['page_number'] is None): 11565 raise ValueError("Missing the required parameter `page_number` when calling `rotate_document_page`") 11566 11567 11568 collection_formats = {} 11569 11570 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/pages/{pageNumber}/page_image'.replace('{format}', 'json') 11571 path_params = {} 11572 if 'account_id' in params: 11573 path_params['accountId'] = params['account_id'] 11574 if 'document_id' in params: 11575 path_params['documentId'] = params['document_id'] 11576 if 'envelope_id' in params: 11577 path_params['envelopeId'] = params['envelope_id'] 11578 if 'page_number' in params: 11579 path_params['pageNumber'] = params['page_number'] 11580 11581 query_params = {} 11582 11583 header_params = {} 11584 11585 form_params = [] 11586 local_var_files = {} 11587 11588 body_params = None 11589 if 'page_request' in params: 11590 body_params = params['page_request'] 11591 # HTTP header `Accept` 11592 header_params['Accept'] = self.api_client.\ 11593 select_header_accept(['application/json']) 11594 11595 # Authentication setting 11596 auth_settings = [] 11597 11598 return self.api_client.call_api(resource_path, 'PUT', 11599 path_params, 11600 query_params, 11601 header_params, 11602 body=body_params, 11603 post_params=form_params, 11604 files=local_var_files, 11605 response_type=None, 11606 auth_settings=auth_settings, 11607 callback=params.get('callback'), 11608 _return_http_data_only=params.get('_return_http_data_only'), 11609 _preload_content=params.get('_preload_content', True), 11610 _request_timeout=params.get('_request_timeout'), 11611 collection_formats=collection_formats)
Rotates page image from an envelope for display.
Rotates page image from an envelope for display. The page image can be rotated to the left or right.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.rotate_document_page_with_http_info(account_id, document_id, envelope_id, page_number, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str page_number: The page number being accessed. (required)
- PageRequest page_request:
Returns
None If the method is called asynchronously, returns the request thread.
def
update(self, account_id, envelope_id, **kwargs)
11613 def update(self, account_id, envelope_id, **kwargs): 11614 """ 11615 Send Draft Envelope/Void Envelope/Move/Purge Envelope/Modify draft 11616 The Put Envelopes endpoint provides the following functionality: * Sends the specified single draft envelope. Add {\"status\":\"sent\"} to the request body to send the envelope. * Voids the specified in-process envelope. Add {\"status\":\"voided\", \"voidedReason\":\"The reason for voiding the envelope\"} to the request body to void the envelope. * Replaces the current email subject and message for a draft envelope. Add {\"emailSubject\":\"subject\", \"emailBlurb\":\"message\"} to the request body to modify the subject and message. * Place the envelope documents and envelope metadata in a purge queue so that this information is removed from the DocuSign system. Add {\"purgeState\":\"purge type\"} to the request body. *Additional information on purging documents* The purge request can only be used for completed envelopes that are not marked as the authoritative copy. The requesting user must have permission to purge documents and must be the sender (the requesting user can act as the sender using Send On Behalf Of). ###### Note: If you have set the Document Retention policy on your account, envelope documents are automatically placed in the purge queue and the warning emails are sent at the end of the retention period. ###### Note: You can set the Document Retention policy in the Classic DocuSign Experience by specifying the number of days to retain documents. ###### Note: Setting a Document Retention policy is the same as setting a schedule for purging documents. When the purge request is initiated the envelope documents, or documents and envelope metadata, are placed in a purge queue for deletion in 14 days. A warning email notification is sent to the sender and recipients associated with the envelope, notifying them that the envelope documents will be deleted in 14 days and providing a link to the documents. A second email is sent 7 days later with the same message. At the end of the 14-day period, the envelope documents are deleted from the system. If `purgeState=\"documents_queued\"` is used in the request, then only the documents are deleted and any corresponding attachments and tabs remain in the DocuSign system. If `purgeState= \"documents_and_metadata_queued\"` is used in the request, then the documents, attachments, and tabs are deleted. 11617 This method makes a synchronous HTTP request by default. To make an 11618 asynchronous HTTP request, please define a `callback` function 11619 to be invoked when receiving the response. 11620 >>> def callback_function(response): 11621 >>> pprint(response) 11622 >>> 11623 >>> thread = api.update(account_id, envelope_id, callback=callback_function) 11624 11625 :param callback function: The callback function 11626 for asynchronous request. (optional) 11627 :param str account_id: The external account number (int) or account ID Guid. (required) 11628 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11629 :param str advanced_update: When set to **true**, allows the caller to update recipients, tabs, custom fields, notification, email settings and other envelope attributes. 11630 :param str recycle_on_void: 11631 :param str resend_envelope: When set to **true**, sends the specified envelope again. 11632 :param Envelope envelope: 11633 :return: EnvelopeUpdateSummary 11634 If the method is called asynchronously, 11635 returns the request thread. 11636 """ 11637 kwargs['_return_http_data_only'] = True 11638 if kwargs.get('callback'): 11639 return self.update_with_http_info(account_id, envelope_id, **kwargs) 11640 else: 11641 (data) = self.update_with_http_info(account_id, envelope_id, **kwargs) 11642 return data
Send Draft Envelope/Void Envelope/Move/Purge Envelope/Modify draft
The Put Envelopes endpoint provides the following functionality: * Sends the specified single draft envelope. Add {"status":"sent"} to the request body to send the envelope. * Voids the specified in-process envelope. Add {"status":"voided", "voidedReason":"The reason for voiding the envelope"} to the request body to void the envelope. * Replaces the current email subject and message for a draft envelope. Add {"emailSubject":"subject", "emailBlurb":"message"} to the request body to modify the subject and message. * Place the envelope documents and envelope metadata in a purge queue so that this information is removed from the DocuSign system. Add {"purgeState":"purge type"} to the request body. Additional information on purging documents The purge request can only be used for completed envelopes that are not marked as the authoritative copy. The requesting user must have permission to purge documents and must be the sender (the requesting user can act as the sender using Send On Behalf Of). ###### Note: If you have set the Document Retention policy on your account, envelope documents are automatically placed in the purge queue and the warning emails are sent at the end of the retention period. ###### Note: You can set the Document Retention policy in the Classic DocuSign Experience by specifying the number of days to retain documents. ###### Note: Setting a Document Retention policy is the same as setting a schedule for purging documents. When the purge request is initiated the envelope documents, or documents and envelope metadata, are placed in a purge queue for deletion in 14 days. A warning email notification is sent to the sender and recipients associated with the envelope, notifying them that the envelope documents will be deleted in 14 days and providing a link to the documents. A second email is sent 7 days later with the same message. At the end of the 14-day period, the envelope documents are deleted from the system. If purgeState="documents_queued" is used in the request, then only the documents are deleted and any corresponding attachments and tabs remain in the DocuSign system. If purgeState= "documents_and_metadata_queued" is used in the request, then the documents, attachments, and tabs are deleted.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str advanced_update: When set to true, allows the caller to update recipients, tabs, custom fields, notification, email settings and other envelope attributes.
- str recycle_on_void:
- str resend_envelope: When set to true, sends the specified envelope again.
- Envelope envelope:
Returns
EnvelopeUpdateSummary If the method is called asynchronously, returns the request thread.
def
update_with_http_info(self, account_id, envelope_id, **kwargs)
11644 def update_with_http_info(self, account_id, envelope_id, **kwargs): 11645 """ 11646 Send Draft Envelope/Void Envelope/Move/Purge Envelope/Modify draft 11647 The Put Envelopes endpoint provides the following functionality: * Sends the specified single draft envelope. Add {\"status\":\"sent\"} to the request body to send the envelope. * Voids the specified in-process envelope. Add {\"status\":\"voided\", \"voidedReason\":\"The reason for voiding the envelope\"} to the request body to void the envelope. * Replaces the current email subject and message for a draft envelope. Add {\"emailSubject\":\"subject\", \"emailBlurb\":\"message\"} to the request body to modify the subject and message. * Place the envelope documents and envelope metadata in a purge queue so that this information is removed from the DocuSign system. Add {\"purgeState\":\"purge type\"} to the request body. *Additional information on purging documents* The purge request can only be used for completed envelopes that are not marked as the authoritative copy. The requesting user must have permission to purge documents and must be the sender (the requesting user can act as the sender using Send On Behalf Of). ###### Note: If you have set the Document Retention policy on your account, envelope documents are automatically placed in the purge queue and the warning emails are sent at the end of the retention period. ###### Note: You can set the Document Retention policy in the Classic DocuSign Experience by specifying the number of days to retain documents. ###### Note: Setting a Document Retention policy is the same as setting a schedule for purging documents. When the purge request is initiated the envelope documents, or documents and envelope metadata, are placed in a purge queue for deletion in 14 days. A warning email notification is sent to the sender and recipients associated with the envelope, notifying them that the envelope documents will be deleted in 14 days and providing a link to the documents. A second email is sent 7 days later with the same message. At the end of the 14-day period, the envelope documents are deleted from the system. If `purgeState=\"documents_queued\"` is used in the request, then only the documents are deleted and any corresponding attachments and tabs remain in the DocuSign system. If `purgeState= \"documents_and_metadata_queued\"` is used in the request, then the documents, attachments, and tabs are deleted. 11648 This method makes a synchronous HTTP request by default. To make an 11649 asynchronous HTTP request, please define a `callback` function 11650 to be invoked when receiving the response. 11651 >>> def callback_function(response): 11652 >>> pprint(response) 11653 >>> 11654 >>> thread = api.update_with_http_info(account_id, envelope_id, callback=callback_function) 11655 11656 :param callback function: The callback function 11657 for asynchronous request. (optional) 11658 :param str account_id: The external account number (int) or account ID Guid. (required) 11659 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11660 :param str advanced_update: When set to **true**, allows the caller to update recipients, tabs, custom fields, notification, email settings and other envelope attributes. 11661 :param str recycle_on_void: 11662 :param str resend_envelope: When set to **true**, sends the specified envelope again. 11663 :param Envelope envelope: 11664 :return: EnvelopeUpdateSummary 11665 If the method is called asynchronously, 11666 returns the request thread. 11667 """ 11668 11669 all_params = ['account_id', 'envelope_id', 'advanced_update', 'recycle_on_void', 'resend_envelope', 'envelope'] 11670 all_params.append('callback') 11671 all_params.append('_return_http_data_only') 11672 all_params.append('_preload_content') 11673 all_params.append('_request_timeout') 11674 11675 params = locals() 11676 for key, val in iteritems(params['kwargs']): 11677 if key not in all_params: 11678 raise TypeError( 11679 "Got an unexpected keyword argument '%s'" 11680 " to method update" % key 11681 ) 11682 params[key] = val 11683 del params['kwargs'] 11684 # verify the required parameter 'account_id' is set 11685 if ('account_id' not in params) or (params['account_id'] is None): 11686 raise ValueError("Missing the required parameter `account_id` when calling `update`") 11687 # verify the required parameter 'envelope_id' is set 11688 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11689 raise ValueError("Missing the required parameter `envelope_id` when calling `update`") 11690 11691 11692 collection_formats = {} 11693 11694 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}'.replace('{format}', 'json') 11695 path_params = {} 11696 if 'account_id' in params: 11697 path_params['accountId'] = params['account_id'] 11698 if 'envelope_id' in params: 11699 path_params['envelopeId'] = params['envelope_id'] 11700 11701 query_params = {} 11702 if 'advanced_update' in params: 11703 query_params['advanced_update'] = params['advanced_update'] 11704 if 'recycle_on_void' in params: 11705 query_params['recycle_on_void'] = params['recycle_on_void'] 11706 if 'resend_envelope' in params: 11707 query_params['resend_envelope'] = params['resend_envelope'] 11708 11709 header_params = {} 11710 11711 form_params = [] 11712 local_var_files = {} 11713 11714 body_params = None 11715 if 'envelope' in params: 11716 body_params = params['envelope'] 11717 # HTTP header `Accept` 11718 header_params['Accept'] = self.api_client.\ 11719 select_header_accept(['application/json']) 11720 11721 # Authentication setting 11722 auth_settings = [] 11723 11724 return self.api_client.call_api(resource_path, 'PUT', 11725 path_params, 11726 query_params, 11727 header_params, 11728 body=body_params, 11729 post_params=form_params, 11730 files=local_var_files, 11731 response_type='EnvelopeUpdateSummary', 11732 auth_settings=auth_settings, 11733 callback=params.get('callback'), 11734 _return_http_data_only=params.get('_return_http_data_only'), 11735 _preload_content=params.get('_preload_content', True), 11736 _request_timeout=params.get('_request_timeout'), 11737 collection_formats=collection_formats)
Send Draft Envelope/Void Envelope/Move/Purge Envelope/Modify draft
The Put Envelopes endpoint provides the following functionality: * Sends the specified single draft envelope. Add {"status":"sent"} to the request body to send the envelope. * Voids the specified in-process envelope. Add {"status":"voided", "voidedReason":"The reason for voiding the envelope"} to the request body to void the envelope. * Replaces the current email subject and message for a draft envelope. Add {"emailSubject":"subject", "emailBlurb":"message"} to the request body to modify the subject and message. * Place the envelope documents and envelope metadata in a purge queue so that this information is removed from the DocuSign system. Add {"purgeState":"purge type"} to the request body. Additional information on purging documents The purge request can only be used for completed envelopes that are not marked as the authoritative copy. The requesting user must have permission to purge documents and must be the sender (the requesting user can act as the sender using Send On Behalf Of). ###### Note: If you have set the Document Retention policy on your account, envelope documents are automatically placed in the purge queue and the warning emails are sent at the end of the retention period. ###### Note: You can set the Document Retention policy in the Classic DocuSign Experience by specifying the number of days to retain documents. ###### Note: Setting a Document Retention policy is the same as setting a schedule for purging documents. When the purge request is initiated the envelope documents, or documents and envelope metadata, are placed in a purge queue for deletion in 14 days. A warning email notification is sent to the sender and recipients associated with the envelope, notifying them that the envelope documents will be deleted in 14 days and providing a link to the documents. A second email is sent 7 days later with the same message. At the end of the 14-day period, the envelope documents are deleted from the system. If purgeState="documents_queued" is used in the request, then only the documents are deleted and any corresponding attachments and tabs remain in the DocuSign system. If purgeState= "documents_and_metadata_queued" is used in the request, then the documents, attachments, and tabs are deleted.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str advanced_update: When set to true, allows the caller to update recipients, tabs, custom fields, notification, email settings and other envelope attributes.
- str recycle_on_void:
- str resend_envelope: When set to true, sends the specified envelope again.
- Envelope envelope:
Returns
EnvelopeUpdateSummary If the method is called asynchronously, returns the request thread.
def
update_chunked_upload(self, account_id, chunked_upload_id, **kwargs)
11739 def update_chunked_upload(self, account_id, chunked_upload_id, **kwargs): 11740 """ 11741 Integrity-Check and Commit a ChunkedUpload, readying it for use elsewhere. 11742 This method checks the integrity of a chunked upload and then commits it. When this request is successful, the chunked upload is then ready to be referenced in other API calls. If the request is unsuccessful, ensure that you have uploaded all of the parts by using the Update method. **Note:** After you commit a chunked upload, it no longer accepts additional parts. 11743 This method makes a synchronous HTTP request by default. To make an 11744 asynchronous HTTP request, please define a `callback` function 11745 to be invoked when receiving the response. 11746 >>> def callback_function(response): 11747 >>> pprint(response) 11748 >>> 11749 >>> thread = api.update_chunked_upload(account_id, chunked_upload_id, callback=callback_function) 11750 11751 :param callback function: The callback function 11752 for asynchronous request. (optional) 11753 :param str account_id: The external account number (int) or account ID Guid. (required) 11754 :param str chunked_upload_id: (required) 11755 :param str action: 11756 :return: ChunkedUploadResponse 11757 If the method is called asynchronously, 11758 returns the request thread. 11759 """ 11760 kwargs['_return_http_data_only'] = True 11761 if kwargs.get('callback'): 11762 return self.update_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 11763 else: 11764 (data) = self.update_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 11765 return data
Integrity-Check and Commit a ChunkedUpload, readying it for use elsewhere.
This method checks the integrity of a chunked upload and then commits it. When this request is successful, the chunked upload is then ready to be referenced in other API calls. If the request is unsuccessful, ensure that you have uploaded all of the parts by using the Update method. Note: After you commit a chunked upload, it no longer accepts additional parts.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_chunked_upload(account_id, chunked_upload_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str chunked_upload_id: (required)
- str action:
Returns
ChunkedUploadResponse If the method is called asynchronously, returns the request thread.
def
update_chunked_upload_with_http_info(self, account_id, chunked_upload_id, **kwargs)
11767 def update_chunked_upload_with_http_info(self, account_id, chunked_upload_id, **kwargs): 11768 """ 11769 Integrity-Check and Commit a ChunkedUpload, readying it for use elsewhere. 11770 This method checks the integrity of a chunked upload and then commits it. When this request is successful, the chunked upload is then ready to be referenced in other API calls. If the request is unsuccessful, ensure that you have uploaded all of the parts by using the Update method. **Note:** After you commit a chunked upload, it no longer accepts additional parts. 11771 This method makes a synchronous HTTP request by default. To make an 11772 asynchronous HTTP request, please define a `callback` function 11773 to be invoked when receiving the response. 11774 >>> def callback_function(response): 11775 >>> pprint(response) 11776 >>> 11777 >>> thread = api.update_chunked_upload_with_http_info(account_id, chunked_upload_id, callback=callback_function) 11778 11779 :param callback function: The callback function 11780 for asynchronous request. (optional) 11781 :param str account_id: The external account number (int) or account ID Guid. (required) 11782 :param str chunked_upload_id: (required) 11783 :param str action: 11784 :return: ChunkedUploadResponse 11785 If the method is called asynchronously, 11786 returns the request thread. 11787 """ 11788 11789 all_params = ['account_id', 'chunked_upload_id', 'action'] 11790 all_params.append('callback') 11791 all_params.append('_return_http_data_only') 11792 all_params.append('_preload_content') 11793 all_params.append('_request_timeout') 11794 11795 params = locals() 11796 for key, val in iteritems(params['kwargs']): 11797 if key not in all_params: 11798 raise TypeError( 11799 "Got an unexpected keyword argument '%s'" 11800 " to method update_chunked_upload" % key 11801 ) 11802 params[key] = val 11803 del params['kwargs'] 11804 # verify the required parameter 'account_id' is set 11805 if ('account_id' not in params) or (params['account_id'] is None): 11806 raise ValueError("Missing the required parameter `account_id` when calling `update_chunked_upload`") 11807 # verify the required parameter 'chunked_upload_id' is set 11808 if ('chunked_upload_id' not in params) or (params['chunked_upload_id'] is None): 11809 raise ValueError("Missing the required parameter `chunked_upload_id` when calling `update_chunked_upload`") 11810 11811 11812 collection_formats = {} 11813 11814 resource_path = '/v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}'.replace('{format}', 'json') 11815 path_params = {} 11816 if 'account_id' in params: 11817 path_params['accountId'] = params['account_id'] 11818 if 'chunked_upload_id' in params: 11819 path_params['chunkedUploadId'] = params['chunked_upload_id'] 11820 11821 query_params = {} 11822 if 'action' in params: 11823 query_params['action'] = params['action'] 11824 11825 header_params = {} 11826 11827 form_params = [] 11828 local_var_files = {} 11829 11830 body_params = None 11831 # HTTP header `Accept` 11832 header_params['Accept'] = self.api_client.\ 11833 select_header_accept(['application/json']) 11834 11835 # Authentication setting 11836 auth_settings = [] 11837 11838 return self.api_client.call_api(resource_path, 'PUT', 11839 path_params, 11840 query_params, 11841 header_params, 11842 body=body_params, 11843 post_params=form_params, 11844 files=local_var_files, 11845 response_type='ChunkedUploadResponse', 11846 auth_settings=auth_settings, 11847 callback=params.get('callback'), 11848 _return_http_data_only=params.get('_return_http_data_only'), 11849 _preload_content=params.get('_preload_content', True), 11850 _request_timeout=params.get('_request_timeout'), 11851 collection_formats=collection_formats)
Integrity-Check and Commit a ChunkedUpload, readying it for use elsewhere.
This method checks the integrity of a chunked upload and then commits it. When this request is successful, the chunked upload is then ready to be referenced in other API calls. If the request is unsuccessful, ensure that you have uploaded all of the parts by using the Update method. Note: After you commit a chunked upload, it no longer accepts additional parts.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_chunked_upload_with_http_info(account_id, chunked_upload_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str chunked_upload_id: (required)
- str action:
Returns
ChunkedUploadResponse If the method is called asynchronously, returns the request thread.
def
update_chunked_upload_part( self, account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs)
11853 def update_chunked_upload_part(self, account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs): 11854 """ 11855 Add a chunk, a chunk 'part', to an existing ChunkedUpload. 11856 Adds a chunk or part to an existing chunked upload. After you use the Create method to initiate a new chunked upload and upload the first part, use this method to upload subsequent parts. For simplicity, DocuSign recommends that you upload the parts in their sequential order ( 1,2, 3, 4, etc.). The Create method adds the first part and assigns it the `sequence` value `0`. As a result, DocuSign recommends that you start with a `sequence` value of `1` when you use this method, and continue uploading parts contiguously until you have uploaded the entirety of the original content to DocuSign. Example: ``` PUT /v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}/1 PUT /v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}/2 PUT /v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}/3 ``` **Note:** You cannot replace a part that DocuSign has already received, or add parts to a chunked upload that is already successfully committed. 11857 This method makes a synchronous HTTP request by default. To make an 11858 asynchronous HTTP request, please define a `callback` function 11859 to be invoked when receiving the response. 11860 >>> def callback_function(response): 11861 >>> pprint(response) 11862 >>> 11863 >>> thread = api.update_chunked_upload_part(account_id, chunked_upload_id, chunked_upload_part_seq, callback=callback_function) 11864 11865 :param callback function: The callback function 11866 for asynchronous request. (optional) 11867 :param str account_id: The external account number (int) or account ID Guid. (required) 11868 :param str chunked_upload_id: (required) 11869 :param str chunked_upload_part_seq: (required) 11870 :param ChunkedUploadRequest chunked_upload_request: 11871 :return: ChunkedUploadResponse 11872 If the method is called asynchronously, 11873 returns the request thread. 11874 """ 11875 kwargs['_return_http_data_only'] = True 11876 if kwargs.get('callback'): 11877 return self.update_chunked_upload_part_with_http_info(account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs) 11878 else: 11879 (data) = self.update_chunked_upload_part_with_http_info(account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs) 11880 return data
Add a chunk, a chunk 'part', to an existing ChunkedUpload.
Adds a chunk or part to an existing chunked upload. After you use the Create method to initiate a new chunked upload and upload the first part, use this method to upload subsequent parts. For simplicity, DocuSign recommends that you upload the parts in their sequential order ( 1,2, 3, 4, etc.). The Create method adds the first part and assigns it the sequence value 0. As a result, DocuSign recommends that you start with a sequence value of 1 when you use this method, and continue uploading parts contiguously until you have uploaded the entirety of the original content to DocuSign. Example: PUT /v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}/1 PUT /v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}/2 PUT /v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}/3 Note: You cannot replace a part that DocuSign has already received, or add parts to a chunked upload that is already successfully committed.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_chunked_upload_part(account_id, chunked_upload_id, chunked_upload_part_seq, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str chunked_upload_id: (required)
- str chunked_upload_part_seq: (required)
- ChunkedUploadRequest chunked_upload_request:
Returns
ChunkedUploadResponse If the method is called asynchronously, returns the request thread.
def
update_chunked_upload_part_with_http_info( self, account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs)
11882 def update_chunked_upload_part_with_http_info(self, account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs): 11883 """ 11884 Add a chunk, a chunk 'part', to an existing ChunkedUpload. 11885 Adds a chunk or part to an existing chunked upload. After you use the Create method to initiate a new chunked upload and upload the first part, use this method to upload subsequent parts. For simplicity, DocuSign recommends that you upload the parts in their sequential order ( 1,2, 3, 4, etc.). The Create method adds the first part and assigns it the `sequence` value `0`. As a result, DocuSign recommends that you start with a `sequence` value of `1` when you use this method, and continue uploading parts contiguously until you have uploaded the entirety of the original content to DocuSign. Example: ``` PUT /v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}/1 PUT /v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}/2 PUT /v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}/3 ``` **Note:** You cannot replace a part that DocuSign has already received, or add parts to a chunked upload that is already successfully committed. 11886 This method makes a synchronous HTTP request by default. To make an 11887 asynchronous HTTP request, please define a `callback` function 11888 to be invoked when receiving the response. 11889 >>> def callback_function(response): 11890 >>> pprint(response) 11891 >>> 11892 >>> thread = api.update_chunked_upload_part_with_http_info(account_id, chunked_upload_id, chunked_upload_part_seq, callback=callback_function) 11893 11894 :param callback function: The callback function 11895 for asynchronous request. (optional) 11896 :param str account_id: The external account number (int) or account ID Guid. (required) 11897 :param str chunked_upload_id: (required) 11898 :param str chunked_upload_part_seq: (required) 11899 :param ChunkedUploadRequest chunked_upload_request: 11900 :return: ChunkedUploadResponse 11901 If the method is called asynchronously, 11902 returns the request thread. 11903 """ 11904 11905 all_params = ['account_id', 'chunked_upload_id', 'chunked_upload_part_seq', 'chunked_upload_request'] 11906 all_params.append('callback') 11907 all_params.append('_return_http_data_only') 11908 all_params.append('_preload_content') 11909 all_params.append('_request_timeout') 11910 11911 params = locals() 11912 for key, val in iteritems(params['kwargs']): 11913 if key not in all_params: 11914 raise TypeError( 11915 "Got an unexpected keyword argument '%s'" 11916 " to method update_chunked_upload_part" % key 11917 ) 11918 params[key] = val 11919 del params['kwargs'] 11920 # verify the required parameter 'account_id' is set 11921 if ('account_id' not in params) or (params['account_id'] is None): 11922 raise ValueError("Missing the required parameter `account_id` when calling `update_chunked_upload_part`") 11923 # verify the required parameter 'chunked_upload_id' is set 11924 if ('chunked_upload_id' not in params) or (params['chunked_upload_id'] is None): 11925 raise ValueError("Missing the required parameter `chunked_upload_id` when calling `update_chunked_upload_part`") 11926 # verify the required parameter 'chunked_upload_part_seq' is set 11927 if ('chunked_upload_part_seq' not in params) or (params['chunked_upload_part_seq'] is None): 11928 raise ValueError("Missing the required parameter `chunked_upload_part_seq` when calling `update_chunked_upload_part`") 11929 11930 11931 collection_formats = {} 11932 11933 resource_path = '/v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}/{chunkedUploadPartSeq}'.replace('{format}', 'json') 11934 path_params = {} 11935 if 'account_id' in params: 11936 path_params['accountId'] = params['account_id'] 11937 if 'chunked_upload_id' in params: 11938 path_params['chunkedUploadId'] = params['chunked_upload_id'] 11939 if 'chunked_upload_part_seq' in params: 11940 path_params['chunkedUploadPartSeq'] = params['chunked_upload_part_seq'] 11941 11942 query_params = {} 11943 11944 header_params = {} 11945 11946 form_params = [] 11947 local_var_files = {} 11948 11949 body_params = None 11950 if 'chunked_upload_request' in params: 11951 body_params = params['chunked_upload_request'] 11952 # HTTP header `Accept` 11953 header_params['Accept'] = self.api_client.\ 11954 select_header_accept(['application/json']) 11955 11956 # Authentication setting 11957 auth_settings = [] 11958 11959 return self.api_client.call_api(resource_path, 'PUT', 11960 path_params, 11961 query_params, 11962 header_params, 11963 body=body_params, 11964 post_params=form_params, 11965 files=local_var_files, 11966 response_type='ChunkedUploadResponse', 11967 auth_settings=auth_settings, 11968 callback=params.get('callback'), 11969 _return_http_data_only=params.get('_return_http_data_only'), 11970 _preload_content=params.get('_preload_content', True), 11971 _request_timeout=params.get('_request_timeout'), 11972 collection_formats=collection_formats)
Add a chunk, a chunk 'part', to an existing ChunkedUpload.
Adds a chunk or part to an existing chunked upload. After you use the Create method to initiate a new chunked upload and upload the first part, use this method to upload subsequent parts. For simplicity, DocuSign recommends that you upload the parts in their sequential order ( 1,2, 3, 4, etc.). The Create method adds the first part and assigns it the sequence value 0. As a result, DocuSign recommends that you start with a sequence value of 1 when you use this method, and continue uploading parts contiguously until you have uploaded the entirety of the original content to DocuSign. Example: PUT /v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}/1 PUT /v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}/2 PUT /v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}/3 Note: You cannot replace a part that DocuSign has already received, or add parts to a chunked upload that is already successfully committed.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_chunked_upload_part_with_http_info(account_id, chunked_upload_id, chunked_upload_part_seq, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str chunked_upload_id: (required)
- str chunked_upload_part_seq: (required)
- ChunkedUploadRequest chunked_upload_request:
Returns
ChunkedUploadResponse If the method is called asynchronously, returns the request thread.
def
update_custom_fields(self, account_id, envelope_id, **kwargs)
11974 def update_custom_fields(self, account_id, envelope_id, **kwargs): 11975 """ 11976 Updates envelope custom fields in an envelope. 11977 Updates the envelope custom fields in draft and in-process envelopes. Each custom field used in an envelope must have a unique name. 11978 This method makes a synchronous HTTP request by default. To make an 11979 asynchronous HTTP request, please define a `callback` function 11980 to be invoked when receiving the response. 11981 >>> def callback_function(response): 11982 >>> pprint(response) 11983 >>> 11984 >>> thread = api.update_custom_fields(account_id, envelope_id, callback=callback_function) 11985 11986 :param callback function: The callback function 11987 for asynchronous request. (optional) 11988 :param str account_id: The external account number (int) or account ID Guid. (required) 11989 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11990 :param CustomFields custom_fields: 11991 :return: CustomFields 11992 If the method is called asynchronously, 11993 returns the request thread. 11994 """ 11995 kwargs['_return_http_data_only'] = True 11996 if kwargs.get('callback'): 11997 return self.update_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 11998 else: 11999 (data) = self.update_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 12000 return data
Updates envelope custom fields in an envelope.
Updates the envelope custom fields in draft and in-process envelopes. Each custom field used in an envelope must have a unique name.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_custom_fields(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- CustomFields custom_fields:
Returns
CustomFields If the method is called asynchronously, returns the request thread.
def
update_custom_fields_with_http_info(self, account_id, envelope_id, **kwargs)
12002 def update_custom_fields_with_http_info(self, account_id, envelope_id, **kwargs): 12003 """ 12004 Updates envelope custom fields in an envelope. 12005 Updates the envelope custom fields in draft and in-process envelopes. Each custom field used in an envelope must have a unique name. 12006 This method makes a synchronous HTTP request by default. To make an 12007 asynchronous HTTP request, please define a `callback` function 12008 to be invoked when receiving the response. 12009 >>> def callback_function(response): 12010 >>> pprint(response) 12011 >>> 12012 >>> thread = api.update_custom_fields_with_http_info(account_id, envelope_id, callback=callback_function) 12013 12014 :param callback function: The callback function 12015 for asynchronous request. (optional) 12016 :param str account_id: The external account number (int) or account ID Guid. (required) 12017 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12018 :param CustomFields custom_fields: 12019 :return: CustomFields 12020 If the method is called asynchronously, 12021 returns the request thread. 12022 """ 12023 12024 all_params = ['account_id', 'envelope_id', 'custom_fields'] 12025 all_params.append('callback') 12026 all_params.append('_return_http_data_only') 12027 all_params.append('_preload_content') 12028 all_params.append('_request_timeout') 12029 12030 params = locals() 12031 for key, val in iteritems(params['kwargs']): 12032 if key not in all_params: 12033 raise TypeError( 12034 "Got an unexpected keyword argument '%s'" 12035 " to method update_custom_fields" % key 12036 ) 12037 params[key] = val 12038 del params['kwargs'] 12039 # verify the required parameter 'account_id' is set 12040 if ('account_id' not in params) or (params['account_id'] is None): 12041 raise ValueError("Missing the required parameter `account_id` when calling `update_custom_fields`") 12042 # verify the required parameter 'envelope_id' is set 12043 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12044 raise ValueError("Missing the required parameter `envelope_id` when calling `update_custom_fields`") 12045 12046 12047 collection_formats = {} 12048 12049 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/custom_fields'.replace('{format}', 'json') 12050 path_params = {} 12051 if 'account_id' in params: 12052 path_params['accountId'] = params['account_id'] 12053 if 'envelope_id' in params: 12054 path_params['envelopeId'] = params['envelope_id'] 12055 12056 query_params = {} 12057 12058 header_params = {} 12059 12060 form_params = [] 12061 local_var_files = {} 12062 12063 body_params = None 12064 if 'custom_fields' in params: 12065 body_params = params['custom_fields'] 12066 # HTTP header `Accept` 12067 header_params['Accept'] = self.api_client.\ 12068 select_header_accept(['application/json']) 12069 12070 # Authentication setting 12071 auth_settings = [] 12072 12073 return self.api_client.call_api(resource_path, 'PUT', 12074 path_params, 12075 query_params, 12076 header_params, 12077 body=body_params, 12078 post_params=form_params, 12079 files=local_var_files, 12080 response_type='CustomFields', 12081 auth_settings=auth_settings, 12082 callback=params.get('callback'), 12083 _return_http_data_only=params.get('_return_http_data_only'), 12084 _preload_content=params.get('_preload_content', True), 12085 _request_timeout=params.get('_request_timeout'), 12086 collection_formats=collection_formats)
Updates envelope custom fields in an envelope.
Updates the envelope custom fields in draft and in-process envelopes. Each custom field used in an envelope must have a unique name.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_custom_fields_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- CustomFields custom_fields:
Returns
CustomFields If the method is called asynchronously, returns the request thread.
def
update_document( self, account_id, document_id, envelope_id, document_file_bytes, **kwargs)
12088 def update_document(self, account_id, document_id, envelope_id, document_file_bytes, **kwargs): 12089 """ 12090 Adds a document to an existing draft envelope. 12091 Adds a document to an existing draft envelope. 12092 This method makes a synchronous HTTP request by default. To make an 12093 asynchronous HTTP request, please define a `callback` function 12094 to be invoked when receiving the response. 12095 >>> def callback_function(response): 12096 >>> pprint(response) 12097 >>> 12098 >>> thread = api.update_document(account_id, document_id, envelope_id, document_file_bytes, callback=callback_function) 12099 12100 :param callback function: The callback function 12101 for asynchronous request. (optional) 12102 :param str account_id: The external account number (int) or account ID Guid. (required) 12103 :param str document_id: The ID of the document being accessed. (required) 12104 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12105 :param str document_file_bytes: Updated document content. (required) 12106 :return: EnvelopeDocument 12107 If the method is called asynchronously, 12108 returns the request thread. 12109 """ 12110 kwargs['_return_http_data_only'] = True 12111 if kwargs.get('callback'): 12112 return self.update_document_with_http_info(account_id, document_id, envelope_id, document_file_bytes, **kwargs) 12113 else: 12114 (data) = self.update_document_with_http_info(account_id, document_id, envelope_id, document_file_bytes, **kwargs) 12115 return data
Adds a document to an existing draft envelope.
Adds a document to an existing draft envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_document(account_id, document_id, envelope_id, document_file_bytes, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str document_file_bytes: Updated document content. (required)
Returns
EnvelopeDocument If the method is called asynchronously, returns the request thread.
def
update_document_with_http_info( self, account_id, document_id, envelope_id, document_file_bytes, **kwargs)
12117 def update_document_with_http_info(self, account_id, document_id, envelope_id, document_file_bytes, **kwargs): 12118 """ 12119 Adds a document to an existing draft envelope. 12120 Adds a document to an existing draft envelope. 12121 This method makes a synchronous HTTP request by default. To make an 12122 asynchronous HTTP request, please define a `callback` function 12123 to be invoked when receiving the response. 12124 >>> def callback_function(response): 12125 >>> pprint(response) 12126 >>> 12127 >>> thread = api.update_document_with_http_info(account_id, document_id, envelope_id, document_file_bytes, callback=callback_function) 12128 12129 :param callback function: The callback function 12130 for asynchronous request. (optional) 12131 :param str account_id: The external account number (int) or account ID Guid. (required) 12132 :param str document_id: The ID of the document being accessed. (required) 12133 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12134 :param str document_file_bytes: Updated document content. (required) 12135 :return: EnvelopeDocument 12136 If the method is called asynchronously, 12137 returns the request thread. 12138 """ 12139 12140 all_params = ['account_id', 'document_id', 'envelope_id', 'document_file_bytes'] 12141 all_params.append('callback') 12142 all_params.append('_return_http_data_only') 12143 all_params.append('_preload_content') 12144 all_params.append('_request_timeout') 12145 12146 params = locals() 12147 for key, val in iteritems(params['kwargs']): 12148 if key not in all_params: 12149 raise TypeError( 12150 "Got an unexpected keyword argument '%s'" 12151 " to method update_document" % key 12152 ) 12153 params[key] = val 12154 del params['kwargs'] 12155 # verify the required parameter 'account_id' is set 12156 if ('account_id' not in params) or (params['account_id'] is None): 12157 raise ValueError("Missing the required parameter `account_id` when calling `update_document`") 12158 # verify the required parameter 'document_id' is set 12159 if ('document_id' not in params) or (params['document_id'] is None): 12160 raise ValueError("Missing the required parameter `document_id` when calling `update_document`") 12161 # verify the required parameter 'envelope_id' is set 12162 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12163 raise ValueError("Missing the required parameter `envelope_id` when calling `update_document`") 12164 # verify the required parameter 'document_file_bytes' is set 12165 if ('document_file_bytes' not in params) or (params['document_file_bytes'] is None): 12166 raise ValueError("Missing the required parameter `document_file_bytes` when calling `update_document`") 12167 12168 12169 collection_formats = {} 12170 12171 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}'.replace('{format}', 'json') 12172 path_params = {} 12173 if 'account_id' in params: 12174 path_params['accountId'] = params['account_id'] 12175 if 'document_id' in params: 12176 path_params['documentId'] = params['document_id'] 12177 if 'envelope_id' in params: 12178 path_params['envelopeId'] = params['envelope_id'] 12179 12180 query_params = {} 12181 12182 header_params = {} 12183 12184 form_params = [] 12185 local_var_files = {} 12186 12187 body_params = None 12188 if 'document_file_bytes' in params: 12189 body_params = params['document_file_bytes'] 12190 # HTTP header `Accept` 12191 header_params['Accept'] = self.api_client.\ 12192 select_header_accept(['application/json']) 12193 12194 # HTTP header `Content-Type` 12195 header_params['Content-Type'] = self.api_client.\ 12196 select_header_content_type(['application/pdf']) 12197 12198 # Authentication setting 12199 auth_settings = [] 12200 12201 return self.api_client.call_api(resource_path, 'PUT', 12202 path_params, 12203 query_params, 12204 header_params, 12205 body=body_params, 12206 post_params=form_params, 12207 files=local_var_files, 12208 response_type='EnvelopeDocument', 12209 auth_settings=auth_settings, 12210 callback=params.get('callback'), 12211 _return_http_data_only=params.get('_return_http_data_only'), 12212 _preload_content=params.get('_preload_content', True), 12213 _request_timeout=params.get('_request_timeout'), 12214 collection_formats=collection_formats)
Adds a document to an existing draft envelope.
Adds a document to an existing draft envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_document_with_http_info(account_id, document_id, envelope_id, document_file_bytes, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str document_file_bytes: Updated document content. (required)
Returns
EnvelopeDocument If the method is called asynchronously, returns the request thread.
def
update_document_fields(self, account_id, document_id, envelope_id, **kwargs)
12216 def update_document_fields(self, account_id, document_id, envelope_id, **kwargs): 12217 """ 12218 Updates existing custom document fields in an existing envelope document. 12219 Updates existing custom document fields in an existing envelope document. 12220 This method makes a synchronous HTTP request by default. To make an 12221 asynchronous HTTP request, please define a `callback` function 12222 to be invoked when receiving the response. 12223 >>> def callback_function(response): 12224 >>> pprint(response) 12225 >>> 12226 >>> thread = api.update_document_fields(account_id, document_id, envelope_id, callback=callback_function) 12227 12228 :param callback function: The callback function 12229 for asynchronous request. (optional) 12230 :param str account_id: The external account number (int) or account ID Guid. (required) 12231 :param str document_id: The ID of the document being accessed. (required) 12232 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12233 :param DocumentFieldsInformation document_fields_information: 12234 :return: DocumentFieldsInformation 12235 If the method is called asynchronously, 12236 returns the request thread. 12237 """ 12238 kwargs['_return_http_data_only'] = True 12239 if kwargs.get('callback'): 12240 return self.update_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 12241 else: 12242 (data) = self.update_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 12243 return data
Updates existing custom document fields in an existing envelope document.
Updates existing custom document fields in an existing envelope document.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_document_fields(account_id, document_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- DocumentFieldsInformation document_fields_information:
Returns
DocumentFieldsInformation If the method is called asynchronously, returns the request thread.
def
update_document_fields_with_http_info(self, account_id, document_id, envelope_id, **kwargs)
12245 def update_document_fields_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 12246 """ 12247 Updates existing custom document fields in an existing envelope document. 12248 Updates existing custom document fields in an existing envelope document. 12249 This method makes a synchronous HTTP request by default. To make an 12250 asynchronous HTTP request, please define a `callback` function 12251 to be invoked when receiving the response. 12252 >>> def callback_function(response): 12253 >>> pprint(response) 12254 >>> 12255 >>> thread = api.update_document_fields_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 12256 12257 :param callback function: The callback function 12258 for asynchronous request. (optional) 12259 :param str account_id: The external account number (int) or account ID Guid. (required) 12260 :param str document_id: The ID of the document being accessed. (required) 12261 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12262 :param DocumentFieldsInformation document_fields_information: 12263 :return: DocumentFieldsInformation 12264 If the method is called asynchronously, 12265 returns the request thread. 12266 """ 12267 12268 all_params = ['account_id', 'document_id', 'envelope_id', 'document_fields_information'] 12269 all_params.append('callback') 12270 all_params.append('_return_http_data_only') 12271 all_params.append('_preload_content') 12272 all_params.append('_request_timeout') 12273 12274 params = locals() 12275 for key, val in iteritems(params['kwargs']): 12276 if key not in all_params: 12277 raise TypeError( 12278 "Got an unexpected keyword argument '%s'" 12279 " to method update_document_fields" % key 12280 ) 12281 params[key] = val 12282 del params['kwargs'] 12283 # verify the required parameter 'account_id' is set 12284 if ('account_id' not in params) or (params['account_id'] is None): 12285 raise ValueError("Missing the required parameter `account_id` when calling `update_document_fields`") 12286 # verify the required parameter 'document_id' is set 12287 if ('document_id' not in params) or (params['document_id'] is None): 12288 raise ValueError("Missing the required parameter `document_id` when calling `update_document_fields`") 12289 # verify the required parameter 'envelope_id' is set 12290 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12291 raise ValueError("Missing the required parameter `envelope_id` when calling `update_document_fields`") 12292 12293 12294 collection_formats = {} 12295 12296 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/fields'.replace('{format}', 'json') 12297 path_params = {} 12298 if 'account_id' in params: 12299 path_params['accountId'] = params['account_id'] 12300 if 'document_id' in params: 12301 path_params['documentId'] = params['document_id'] 12302 if 'envelope_id' in params: 12303 path_params['envelopeId'] = params['envelope_id'] 12304 12305 query_params = {} 12306 12307 header_params = {} 12308 12309 form_params = [] 12310 local_var_files = {} 12311 12312 body_params = None 12313 if 'document_fields_information' in params: 12314 body_params = params['document_fields_information'] 12315 # HTTP header `Accept` 12316 header_params['Accept'] = self.api_client.\ 12317 select_header_accept(['application/json']) 12318 12319 # Authentication setting 12320 auth_settings = [] 12321 12322 return self.api_client.call_api(resource_path, 'PUT', 12323 path_params, 12324 query_params, 12325 header_params, 12326 body=body_params, 12327 post_params=form_params, 12328 files=local_var_files, 12329 response_type='DocumentFieldsInformation', 12330 auth_settings=auth_settings, 12331 callback=params.get('callback'), 12332 _return_http_data_only=params.get('_return_http_data_only'), 12333 _preload_content=params.get('_preload_content', True), 12334 _request_timeout=params.get('_request_timeout'), 12335 collection_formats=collection_formats)
Updates existing custom document fields in an existing envelope document.
Updates existing custom document fields in an existing envelope document.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_document_fields_with_http_info(account_id, document_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- DocumentFieldsInformation document_fields_information:
Returns
DocumentFieldsInformation If the method is called asynchronously, returns the request thread.
def
update_document_tabs(self, account_id, document_id, envelope_id, **kwargs)
12337 def update_document_tabs(self, account_id, document_id, envelope_id, **kwargs): 12338 """ 12339 Updates the tabs for an envelope document 12340 Updates tabs in the document specified by `documentId` in the envelope specified by `envelopeId`. 12341 This method makes a synchronous HTTP request by default. To make an 12342 asynchronous HTTP request, please define a `callback` function 12343 to be invoked when receiving the response. 12344 >>> def callback_function(response): 12345 >>> pprint(response) 12346 >>> 12347 >>> thread = api.update_document_tabs(account_id, document_id, envelope_id, callback=callback_function) 12348 12349 :param callback function: The callback function 12350 for asynchronous request. (optional) 12351 :param str account_id: The external account number (int) or account ID Guid. (required) 12352 :param str document_id: The ID of the document being accessed. (required) 12353 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12354 :param Tabs tabs: 12355 :return: Tabs 12356 If the method is called asynchronously, 12357 returns the request thread. 12358 """ 12359 kwargs['_return_http_data_only'] = True 12360 if kwargs.get('callback'): 12361 return self.update_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 12362 else: 12363 (data) = self.update_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 12364 return data
Updates the tabs for an envelope document
Updates tabs in the document specified by documentId in the envelope specified by envelopeId.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_document_tabs(account_id, document_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- Tabs tabs:
Returns
Tabs If the method is called asynchronously, returns the request thread.
def
update_document_tabs_with_http_info(self, account_id, document_id, envelope_id, **kwargs)
12366 def update_document_tabs_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 12367 """ 12368 Updates the tabs for an envelope document 12369 Updates tabs in the document specified by `documentId` in the envelope specified by `envelopeId`. 12370 This method makes a synchronous HTTP request by default. To make an 12371 asynchronous HTTP request, please define a `callback` function 12372 to be invoked when receiving the response. 12373 >>> def callback_function(response): 12374 >>> pprint(response) 12375 >>> 12376 >>> thread = api.update_document_tabs_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 12377 12378 :param callback function: The callback function 12379 for asynchronous request. (optional) 12380 :param str account_id: The external account number (int) or account ID Guid. (required) 12381 :param str document_id: The ID of the document being accessed. (required) 12382 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12383 :param Tabs tabs: 12384 :return: Tabs 12385 If the method is called asynchronously, 12386 returns the request thread. 12387 """ 12388 12389 all_params = ['account_id', 'document_id', 'envelope_id', 'tabs'] 12390 all_params.append('callback') 12391 all_params.append('_return_http_data_only') 12392 all_params.append('_preload_content') 12393 all_params.append('_request_timeout') 12394 12395 params = locals() 12396 for key, val in iteritems(params['kwargs']): 12397 if key not in all_params: 12398 raise TypeError( 12399 "Got an unexpected keyword argument '%s'" 12400 " to method update_document_tabs" % key 12401 ) 12402 params[key] = val 12403 del params['kwargs'] 12404 # verify the required parameter 'account_id' is set 12405 if ('account_id' not in params) or (params['account_id'] is None): 12406 raise ValueError("Missing the required parameter `account_id` when calling `update_document_tabs`") 12407 # verify the required parameter 'document_id' is set 12408 if ('document_id' not in params) or (params['document_id'] is None): 12409 raise ValueError("Missing the required parameter `document_id` when calling `update_document_tabs`") 12410 # verify the required parameter 'envelope_id' is set 12411 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12412 raise ValueError("Missing the required parameter `envelope_id` when calling `update_document_tabs`") 12413 12414 12415 collection_formats = {} 12416 12417 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/tabs'.replace('{format}', 'json') 12418 path_params = {} 12419 if 'account_id' in params: 12420 path_params['accountId'] = params['account_id'] 12421 if 'document_id' in params: 12422 path_params['documentId'] = params['document_id'] 12423 if 'envelope_id' in params: 12424 path_params['envelopeId'] = params['envelope_id'] 12425 12426 query_params = {} 12427 12428 header_params = {} 12429 12430 form_params = [] 12431 local_var_files = {} 12432 12433 body_params = None 12434 if 'tabs' in params: 12435 body_params = params['tabs'] 12436 # HTTP header `Accept` 12437 header_params['Accept'] = self.api_client.\ 12438 select_header_accept(['application/json']) 12439 12440 # Authentication setting 12441 auth_settings = [] 12442 12443 return self.api_client.call_api(resource_path, 'PUT', 12444 path_params, 12445 query_params, 12446 header_params, 12447 body=body_params, 12448 post_params=form_params, 12449 files=local_var_files, 12450 response_type='Tabs', 12451 auth_settings=auth_settings, 12452 callback=params.get('callback'), 12453 _return_http_data_only=params.get('_return_http_data_only'), 12454 _preload_content=params.get('_preload_content', True), 12455 _request_timeout=params.get('_request_timeout'), 12456 collection_formats=collection_formats)
Updates the tabs for an envelope document
Updates tabs in the document specified by documentId in the envelope specified by envelopeId.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_document_tabs_with_http_info(account_id, document_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str document_id: The ID of the document being accessed. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- Tabs tabs:
Returns
Tabs If the method is called asynchronously, returns the request thread.
def
update_documents(self, account_id, envelope_id, **kwargs)
12458 def update_documents(self, account_id, envelope_id, **kwargs): 12459 """ 12460 Adds one or more documents to an existing envelope document. 12461 Adds one or more documents to an existing envelope document. 12462 This method makes a synchronous HTTP request by default. To make an 12463 asynchronous HTTP request, please define a `callback` function 12464 to be invoked when receiving the response. 12465 >>> def callback_function(response): 12466 >>> pprint(response) 12467 >>> 12468 >>> thread = api.update_documents(account_id, envelope_id, callback=callback_function) 12469 12470 :param callback function: The callback function 12471 for asynchronous request. (optional) 12472 :param str account_id: The external account number (int) or account ID Guid. (required) 12473 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12474 :param EnvelopeDefinition envelope_definition: 12475 :return: EnvelopeDocumentsResult 12476 If the method is called asynchronously, 12477 returns the request thread. 12478 """ 12479 kwargs['_return_http_data_only'] = True 12480 if kwargs.get('callback'): 12481 return self.update_documents_with_http_info(account_id, envelope_id, **kwargs) 12482 else: 12483 (data) = self.update_documents_with_http_info(account_id, envelope_id, **kwargs) 12484 return data
Adds one or more documents to an existing envelope document.
Adds one or more documents to an existing envelope document.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_documents(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- EnvelopeDefinition envelope_definition:
Returns
EnvelopeDocumentsResult If the method is called asynchronously, returns the request thread.
def
update_documents_with_http_info(self, account_id, envelope_id, **kwargs)
12486 def update_documents_with_http_info(self, account_id, envelope_id, **kwargs): 12487 """ 12488 Adds one or more documents to an existing envelope document. 12489 Adds one or more documents to an existing envelope document. 12490 This method makes a synchronous HTTP request by default. To make an 12491 asynchronous HTTP request, please define a `callback` function 12492 to be invoked when receiving the response. 12493 >>> def callback_function(response): 12494 >>> pprint(response) 12495 >>> 12496 >>> thread = api.update_documents_with_http_info(account_id, envelope_id, callback=callback_function) 12497 12498 :param callback function: The callback function 12499 for asynchronous request. (optional) 12500 :param str account_id: The external account number (int) or account ID Guid. (required) 12501 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12502 :param EnvelopeDefinition envelope_definition: 12503 :return: EnvelopeDocumentsResult 12504 If the method is called asynchronously, 12505 returns the request thread. 12506 """ 12507 12508 all_params = ['account_id', 'envelope_id', 'envelope_definition'] 12509 all_params.append('callback') 12510 all_params.append('_return_http_data_only') 12511 all_params.append('_preload_content') 12512 all_params.append('_request_timeout') 12513 12514 params = locals() 12515 for key, val in iteritems(params['kwargs']): 12516 if key not in all_params: 12517 raise TypeError( 12518 "Got an unexpected keyword argument '%s'" 12519 " to method update_documents" % key 12520 ) 12521 params[key] = val 12522 del params['kwargs'] 12523 # verify the required parameter 'account_id' is set 12524 if ('account_id' not in params) or (params['account_id'] is None): 12525 raise ValueError("Missing the required parameter `account_id` when calling `update_documents`") 12526 # verify the required parameter 'envelope_id' is set 12527 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12528 raise ValueError("Missing the required parameter `envelope_id` when calling `update_documents`") 12529 12530 12531 collection_formats = {} 12532 12533 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents'.replace('{format}', 'json') 12534 path_params = {} 12535 if 'account_id' in params: 12536 path_params['accountId'] = params['account_id'] 12537 if 'envelope_id' in params: 12538 path_params['envelopeId'] = params['envelope_id'] 12539 12540 query_params = {} 12541 12542 header_params = {} 12543 12544 form_params = [] 12545 local_var_files = {} 12546 12547 body_params = None 12548 if 'envelope_definition' in params: 12549 body_params = params['envelope_definition'] 12550 # HTTP header `Accept` 12551 header_params['Accept'] = self.api_client.\ 12552 select_header_accept(['application/json']) 12553 12554 # Authentication setting 12555 auth_settings = [] 12556 12557 return self.api_client.call_api(resource_path, 'PUT', 12558 path_params, 12559 query_params, 12560 header_params, 12561 body=body_params, 12562 post_params=form_params, 12563 files=local_var_files, 12564 response_type='EnvelopeDocumentsResult', 12565 auth_settings=auth_settings, 12566 callback=params.get('callback'), 12567 _return_http_data_only=params.get('_return_http_data_only'), 12568 _preload_content=params.get('_preload_content', True), 12569 _request_timeout=params.get('_request_timeout'), 12570 collection_formats=collection_formats)
Adds one or more documents to an existing envelope document.
Adds one or more documents to an existing envelope document.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_documents_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- EnvelopeDefinition envelope_definition:
Returns
EnvelopeDocumentsResult If the method is called asynchronously, returns the request thread.
def
update_email_settings(self, account_id, envelope_id, **kwargs)
12572 def update_email_settings(self, account_id, envelope_id, **kwargs): 12573 """ 12574 Updates the email setting overrides for an envelope. 12575 Updates the existing email override settings for the specified envelope. Note that modifying email settings will only affect email communications that occur after the modification was made. This can also be used to delete an individual email override setting by using an empty string for the value to be deleted. 12576 This method makes a synchronous HTTP request by default. To make an 12577 asynchronous HTTP request, please define a `callback` function 12578 to be invoked when receiving the response. 12579 >>> def callback_function(response): 12580 >>> pprint(response) 12581 >>> 12582 >>> thread = api.update_email_settings(account_id, envelope_id, callback=callback_function) 12583 12584 :param callback function: The callback function 12585 for asynchronous request. (optional) 12586 :param str account_id: The external account number (int) or account ID Guid. (required) 12587 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12588 :param EmailSettings email_settings: 12589 :return: EmailSettings 12590 If the method is called asynchronously, 12591 returns the request thread. 12592 """ 12593 kwargs['_return_http_data_only'] = True 12594 if kwargs.get('callback'): 12595 return self.update_email_settings_with_http_info(account_id, envelope_id, **kwargs) 12596 else: 12597 (data) = self.update_email_settings_with_http_info(account_id, envelope_id, **kwargs) 12598 return data
Updates the email setting overrides for an envelope.
Updates the existing email override settings for the specified envelope. Note that modifying email settings will only affect email communications that occur after the modification was made. This can also be used to delete an individual email override setting by using an empty string for the value to be deleted.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_email_settings(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- EmailSettings email_settings:
Returns
EmailSettings If the method is called asynchronously, returns the request thread.
def
update_email_settings_with_http_info(self, account_id, envelope_id, **kwargs)
12600 def update_email_settings_with_http_info(self, account_id, envelope_id, **kwargs): 12601 """ 12602 Updates the email setting overrides for an envelope. 12603 Updates the existing email override settings for the specified envelope. Note that modifying email settings will only affect email communications that occur after the modification was made. This can also be used to delete an individual email override setting by using an empty string for the value to be deleted. 12604 This method makes a synchronous HTTP request by default. To make an 12605 asynchronous HTTP request, please define a `callback` function 12606 to be invoked when receiving the response. 12607 >>> def callback_function(response): 12608 >>> pprint(response) 12609 >>> 12610 >>> thread = api.update_email_settings_with_http_info(account_id, envelope_id, callback=callback_function) 12611 12612 :param callback function: The callback function 12613 for asynchronous request. (optional) 12614 :param str account_id: The external account number (int) or account ID Guid. (required) 12615 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12616 :param EmailSettings email_settings: 12617 :return: EmailSettings 12618 If the method is called asynchronously, 12619 returns the request thread. 12620 """ 12621 12622 all_params = ['account_id', 'envelope_id', 'email_settings'] 12623 all_params.append('callback') 12624 all_params.append('_return_http_data_only') 12625 all_params.append('_preload_content') 12626 all_params.append('_request_timeout') 12627 12628 params = locals() 12629 for key, val in iteritems(params['kwargs']): 12630 if key not in all_params: 12631 raise TypeError( 12632 "Got an unexpected keyword argument '%s'" 12633 " to method update_email_settings" % key 12634 ) 12635 params[key] = val 12636 del params['kwargs'] 12637 # verify the required parameter 'account_id' is set 12638 if ('account_id' not in params) or (params['account_id'] is None): 12639 raise ValueError("Missing the required parameter `account_id` when calling `update_email_settings`") 12640 # verify the required parameter 'envelope_id' is set 12641 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12642 raise ValueError("Missing the required parameter `envelope_id` when calling `update_email_settings`") 12643 12644 12645 collection_formats = {} 12646 12647 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/email_settings'.replace('{format}', 'json') 12648 path_params = {} 12649 if 'account_id' in params: 12650 path_params['accountId'] = params['account_id'] 12651 if 'envelope_id' in params: 12652 path_params['envelopeId'] = params['envelope_id'] 12653 12654 query_params = {} 12655 12656 header_params = {} 12657 12658 form_params = [] 12659 local_var_files = {} 12660 12661 body_params = None 12662 if 'email_settings' in params: 12663 body_params = params['email_settings'] 12664 # HTTP header `Accept` 12665 header_params['Accept'] = self.api_client.\ 12666 select_header_accept(['application/json']) 12667 12668 # Authentication setting 12669 auth_settings = [] 12670 12671 return self.api_client.call_api(resource_path, 'PUT', 12672 path_params, 12673 query_params, 12674 header_params, 12675 body=body_params, 12676 post_params=form_params, 12677 files=local_var_files, 12678 response_type='EmailSettings', 12679 auth_settings=auth_settings, 12680 callback=params.get('callback'), 12681 _return_http_data_only=params.get('_return_http_data_only'), 12682 _preload_content=params.get('_preload_content', True), 12683 _request_timeout=params.get('_request_timeout'), 12684 collection_formats=collection_formats)
Updates the email setting overrides for an envelope.
Updates the existing email override settings for the specified envelope. Note that modifying email settings will only affect email communications that occur after the modification was made. This can also be used to delete an individual email override setting by using an empty string for the value to be deleted.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_email_settings_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- EmailSettings email_settings:
Returns
EmailSettings If the method is called asynchronously, returns the request thread.
def
update_envelope_delayed_routing_definition(self, account_id, envelope_id, workflow_step_id, **kwargs)
12686 def update_envelope_delayed_routing_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 12687 """ 12688 Updates the delayed routing rules for an envelope's workflow step definition. 12689 This method makes a synchronous HTTP request by default. To make an 12690 asynchronous HTTP request, please define a `callback` function 12691 to be invoked when receiving the response. 12692 >>> def callback_function(response): 12693 >>> pprint(response) 12694 >>> 12695 >>> thread = api.update_envelope_delayed_routing_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 12696 12697 :param callback function: The callback function 12698 for asynchronous request. (optional) 12699 :param str account_id: The external account number (int) or account ID Guid. (required) 12700 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12701 :param str workflow_step_id: (required) 12702 :param DelayedRouting delayed_routing: 12703 :return: DelayedRouting 12704 If the method is called asynchronously, 12705 returns the request thread. 12706 """ 12707 kwargs['_return_http_data_only'] = True 12708 if kwargs.get('callback'): 12709 return self.update_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 12710 else: 12711 (data) = self.update_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 12712 return data
Updates the delayed routing rules for an envelope's workflow step definition.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_envelope_delayed_routing_definition(account_id, envelope_id, workflow_step_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str workflow_step_id: (required)
- DelayedRouting delayed_routing:
Returns
DelayedRouting If the method is called asynchronously, returns the request thread.
def
update_envelope_delayed_routing_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs)
12714 def update_envelope_delayed_routing_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 12715 """ 12716 Updates the delayed routing rules for an envelope's workflow step definition. 12717 This method makes a synchronous HTTP request by default. To make an 12718 asynchronous HTTP request, please define a `callback` function 12719 to be invoked when receiving the response. 12720 >>> def callback_function(response): 12721 >>> pprint(response) 12722 >>> 12723 >>> thread = api.update_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 12724 12725 :param callback function: The callback function 12726 for asynchronous request. (optional) 12727 :param str account_id: The external account number (int) or account ID Guid. (required) 12728 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12729 :param str workflow_step_id: (required) 12730 :param DelayedRouting delayed_routing: 12731 :return: DelayedRouting 12732 If the method is called asynchronously, 12733 returns the request thread. 12734 """ 12735 12736 all_params = ['account_id', 'envelope_id', 'workflow_step_id', 'delayed_routing'] 12737 all_params.append('callback') 12738 all_params.append('_return_http_data_only') 12739 all_params.append('_preload_content') 12740 all_params.append('_request_timeout') 12741 12742 params = locals() 12743 for key, val in iteritems(params['kwargs']): 12744 if key not in all_params: 12745 raise TypeError( 12746 "Got an unexpected keyword argument '%s'" 12747 " to method update_envelope_delayed_routing_definition" % key 12748 ) 12749 params[key] = val 12750 del params['kwargs'] 12751 # verify the required parameter 'account_id' is set 12752 if ('account_id' not in params) or (params['account_id'] is None): 12753 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_delayed_routing_definition`") 12754 # verify the required parameter 'envelope_id' is set 12755 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12756 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_delayed_routing_definition`") 12757 # verify the required parameter 'workflow_step_id' is set 12758 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 12759 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_envelope_delayed_routing_definition`") 12760 12761 12762 collection_formats = {} 12763 12764 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 12765 path_params = {} 12766 if 'account_id' in params: 12767 path_params['accountId'] = params['account_id'] 12768 if 'envelope_id' in params: 12769 path_params['envelopeId'] = params['envelope_id'] 12770 if 'workflow_step_id' in params: 12771 path_params['workflowStepId'] = params['workflow_step_id'] 12772 12773 query_params = {} 12774 12775 header_params = {} 12776 12777 form_params = [] 12778 local_var_files = {} 12779 12780 body_params = None 12781 if 'delayed_routing' in params: 12782 body_params = params['delayed_routing'] 12783 # HTTP header `Accept` 12784 header_params['Accept'] = self.api_client.\ 12785 select_header_accept(['application/json']) 12786 12787 # Authentication setting 12788 auth_settings = [] 12789 12790 return self.api_client.call_api(resource_path, 'PUT', 12791 path_params, 12792 query_params, 12793 header_params, 12794 body=body_params, 12795 post_params=form_params, 12796 files=local_var_files, 12797 response_type='DelayedRouting', 12798 auth_settings=auth_settings, 12799 callback=params.get('callback'), 12800 _return_http_data_only=params.get('_return_http_data_only'), 12801 _preload_content=params.get('_preload_content', True), 12802 _request_timeout=params.get('_request_timeout'), 12803 collection_formats=collection_formats)
Updates the delayed routing rules for an envelope's workflow step definition.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str workflow_step_id: (required)
- DelayedRouting delayed_routing:
Returns
DelayedRouting If the method is called asynchronously, returns the request thread.
def
update_envelope_doc_gen_form_fields(self, account_id, envelope_id, **kwargs)
12805 def update_envelope_doc_gen_form_fields(self, account_id, envelope_id, **kwargs): 12806 """ 12807 Updates formfields for an envelope 12808 This method makes a synchronous HTTP request by default. To make an 12809 asynchronous HTTP request, please define a `callback` function 12810 to be invoked when receiving the response. 12811 >>> def callback_function(response): 12812 >>> pprint(response) 12813 >>> 12814 >>> thread = api.update_envelope_doc_gen_form_fields(account_id, envelope_id, callback=callback_function) 12815 12816 :param callback function: The callback function 12817 for asynchronous request. (optional) 12818 :param str account_id: The external account number (int) or account ID Guid. (required) 12819 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12820 :param str update_docgen_formfields_only: 12821 :param DocGenFormFieldRequest doc_gen_form_field_request: 12822 :return: DocGenFormFieldResponse 12823 If the method is called asynchronously, 12824 returns the request thread. 12825 """ 12826 kwargs['_return_http_data_only'] = True 12827 if kwargs.get('callback'): 12828 return self.update_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, **kwargs) 12829 else: 12830 (data) = self.update_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, **kwargs) 12831 return data
Updates formfields for an envelope
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_envelope_doc_gen_form_fields(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str update_docgen_formfields_only:
- DocGenFormFieldRequest doc_gen_form_field_request:
Returns
DocGenFormFieldResponse If the method is called asynchronously, returns the request thread.
def
update_envelope_doc_gen_form_fields_with_http_info(self, account_id, envelope_id, **kwargs)
12833 def update_envelope_doc_gen_form_fields_with_http_info(self, account_id, envelope_id, **kwargs): 12834 """ 12835 Updates formfields for an envelope 12836 This method makes a synchronous HTTP request by default. To make an 12837 asynchronous HTTP request, please define a `callback` function 12838 to be invoked when receiving the response. 12839 >>> def callback_function(response): 12840 >>> pprint(response) 12841 >>> 12842 >>> thread = api.update_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, callback=callback_function) 12843 12844 :param callback function: The callback function 12845 for asynchronous request. (optional) 12846 :param str account_id: The external account number (int) or account ID Guid. (required) 12847 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12848 :param str update_docgen_formfields_only: 12849 :param DocGenFormFieldRequest doc_gen_form_field_request: 12850 :return: DocGenFormFieldResponse 12851 If the method is called asynchronously, 12852 returns the request thread. 12853 """ 12854 12855 all_params = ['account_id', 'envelope_id', 'update_docgen_formfields_only', 'doc_gen_form_field_request'] 12856 all_params.append('callback') 12857 all_params.append('_return_http_data_only') 12858 all_params.append('_preload_content') 12859 all_params.append('_request_timeout') 12860 12861 params = locals() 12862 for key, val in iteritems(params['kwargs']): 12863 if key not in all_params: 12864 raise TypeError( 12865 "Got an unexpected keyword argument '%s'" 12866 " to method update_envelope_doc_gen_form_fields" % key 12867 ) 12868 params[key] = val 12869 del params['kwargs'] 12870 # verify the required parameter 'account_id' is set 12871 if ('account_id' not in params) or (params['account_id'] is None): 12872 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_doc_gen_form_fields`") 12873 # verify the required parameter 'envelope_id' is set 12874 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12875 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_doc_gen_form_fields`") 12876 12877 12878 collection_formats = {} 12879 12880 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/docGenFormFields'.replace('{format}', 'json') 12881 path_params = {} 12882 if 'account_id' in params: 12883 path_params['accountId'] = params['account_id'] 12884 if 'envelope_id' in params: 12885 path_params['envelopeId'] = params['envelope_id'] 12886 12887 query_params = {} 12888 if 'update_docgen_formfields_only' in params: 12889 query_params['update_docgen_formfields_only'] = params['update_docgen_formfields_only'] 12890 12891 header_params = {} 12892 12893 form_params = [] 12894 local_var_files = {} 12895 12896 body_params = None 12897 if 'doc_gen_form_field_request' in params: 12898 body_params = params['doc_gen_form_field_request'] 12899 # HTTP header `Accept` 12900 header_params['Accept'] = self.api_client.\ 12901 select_header_accept(['application/json']) 12902 12903 # Authentication setting 12904 auth_settings = [] 12905 12906 return self.api_client.call_api(resource_path, 'PUT', 12907 path_params, 12908 query_params, 12909 header_params, 12910 body=body_params, 12911 post_params=form_params, 12912 files=local_var_files, 12913 response_type='DocGenFormFieldResponse', 12914 auth_settings=auth_settings, 12915 callback=params.get('callback'), 12916 _return_http_data_only=params.get('_return_http_data_only'), 12917 _preload_content=params.get('_preload_content', True), 12918 _request_timeout=params.get('_request_timeout'), 12919 collection_formats=collection_formats)
Updates formfields for an envelope
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str update_docgen_formfields_only:
- DocGenFormFieldRequest doc_gen_form_field_request:
Returns
DocGenFormFieldResponse If the method is called asynchronously, returns the request thread.
def
update_envelope_scheduled_sending_definition(self, account_id, envelope_id, **kwargs)
12921 def update_envelope_scheduled_sending_definition(self, account_id, envelope_id, **kwargs): 12922 """ 12923 Updates the scheduled sending rules for an envelope's workflow definition. 12924 This method makes a synchronous HTTP request by default. To make an 12925 asynchronous HTTP request, please define a `callback` function 12926 to be invoked when receiving the response. 12927 >>> def callback_function(response): 12928 >>> pprint(response) 12929 >>> 12930 >>> thread = api.update_envelope_scheduled_sending_definition(account_id, envelope_id, callback=callback_function) 12931 12932 :param callback function: The callback function 12933 for asynchronous request. (optional) 12934 :param str account_id: The external account number (int) or account ID Guid. (required) 12935 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12936 :param ScheduledSending scheduled_sending: 12937 :return: ScheduledSending 12938 If the method is called asynchronously, 12939 returns the request thread. 12940 """ 12941 kwargs['_return_http_data_only'] = True 12942 if kwargs.get('callback'): 12943 return self.update_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 12944 else: 12945 (data) = self.update_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 12946 return data
Updates the scheduled sending rules for an envelope's workflow definition.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_envelope_scheduled_sending_definition(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- ScheduledSending scheduled_sending:
Returns
ScheduledSending If the method is called asynchronously, returns the request thread.
def
update_envelope_scheduled_sending_definition_with_http_info(self, account_id, envelope_id, **kwargs)
12948 def update_envelope_scheduled_sending_definition_with_http_info(self, account_id, envelope_id, **kwargs): 12949 """ 12950 Updates the scheduled sending rules for an envelope's workflow definition. 12951 This method makes a synchronous HTTP request by default. To make an 12952 asynchronous HTTP request, please define a `callback` function 12953 to be invoked when receiving the response. 12954 >>> def callback_function(response): 12955 >>> pprint(response) 12956 >>> 12957 >>> thread = api.update_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, callback=callback_function) 12958 12959 :param callback function: The callback function 12960 for asynchronous request. (optional) 12961 :param str account_id: The external account number (int) or account ID Guid. (required) 12962 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12963 :param ScheduledSending scheduled_sending: 12964 :return: ScheduledSending 12965 If the method is called asynchronously, 12966 returns the request thread. 12967 """ 12968 12969 all_params = ['account_id', 'envelope_id', 'scheduled_sending'] 12970 all_params.append('callback') 12971 all_params.append('_return_http_data_only') 12972 all_params.append('_preload_content') 12973 all_params.append('_request_timeout') 12974 12975 params = locals() 12976 for key, val in iteritems(params['kwargs']): 12977 if key not in all_params: 12978 raise TypeError( 12979 "Got an unexpected keyword argument '%s'" 12980 " to method update_envelope_scheduled_sending_definition" % key 12981 ) 12982 params[key] = val 12983 del params['kwargs'] 12984 # verify the required parameter 'account_id' is set 12985 if ('account_id' not in params) or (params['account_id'] is None): 12986 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_scheduled_sending_definition`") 12987 # verify the required parameter 'envelope_id' is set 12988 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12989 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_scheduled_sending_definition`") 12990 12991 12992 collection_formats = {} 12993 12994 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/scheduledSending'.replace('{format}', 'json') 12995 path_params = {} 12996 if 'account_id' in params: 12997 path_params['accountId'] = params['account_id'] 12998 if 'envelope_id' in params: 12999 path_params['envelopeId'] = params['envelope_id'] 13000 13001 query_params = {} 13002 13003 header_params = {} 13004 13005 form_params = [] 13006 local_var_files = {} 13007 13008 body_params = None 13009 if 'scheduled_sending' in params: 13010 body_params = params['scheduled_sending'] 13011 # HTTP header `Accept` 13012 header_params['Accept'] = self.api_client.\ 13013 select_header_accept(['application/json']) 13014 13015 # Authentication setting 13016 auth_settings = [] 13017 13018 return self.api_client.call_api(resource_path, 'PUT', 13019 path_params, 13020 query_params, 13021 header_params, 13022 body=body_params, 13023 post_params=form_params, 13024 files=local_var_files, 13025 response_type='ScheduledSending', 13026 auth_settings=auth_settings, 13027 callback=params.get('callback'), 13028 _return_http_data_only=params.get('_return_http_data_only'), 13029 _preload_content=params.get('_preload_content', True), 13030 _request_timeout=params.get('_request_timeout'), 13031 collection_formats=collection_formats)
Updates the scheduled sending rules for an envelope's workflow definition.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- ScheduledSending scheduled_sending:
Returns
ScheduledSending If the method is called asynchronously, returns the request thread.
def
update_envelope_transfer_rule(self, account_id, envelope_transfer_rule_id, **kwargs)
13033 def update_envelope_transfer_rule(self, account_id, envelope_transfer_rule_id, **kwargs): 13034 """ 13035 Update an envelope transfer rule for an account. 13036 This method changes the status of an envelope transfer rule. You use this method to change whether or not the rule is enabled. You must include the `envelopeTransferRuleId` both as a query parameter, and in the request body. **Note:** You cannot change any other information about the envelope transfer rule. Only Administrators can update an envelope transfer rule. In addition, to use envelope transfer rules, the **Transfer Custody** feature must be enabled for your account. 13037 This method makes a synchronous HTTP request by default. To make an 13038 asynchronous HTTP request, please define a `callback` function 13039 to be invoked when receiving the response. 13040 >>> def callback_function(response): 13041 >>> pprint(response) 13042 >>> 13043 >>> thread = api.update_envelope_transfer_rule(account_id, envelope_transfer_rule_id, callback=callback_function) 13044 13045 :param callback function: The callback function 13046 for asynchronous request. (optional) 13047 :param str account_id: The external account number (int) or account ID Guid. (required) 13048 :param str envelope_transfer_rule_id: (required) 13049 :param EnvelopeTransferRule envelope_transfer_rule: 13050 :return: EnvelopeTransferRule 13051 If the method is called asynchronously, 13052 returns the request thread. 13053 """ 13054 kwargs['_return_http_data_only'] = True 13055 if kwargs.get('callback'): 13056 return self.update_envelope_transfer_rule_with_http_info(account_id, envelope_transfer_rule_id, **kwargs) 13057 else: 13058 (data) = self.update_envelope_transfer_rule_with_http_info(account_id, envelope_transfer_rule_id, **kwargs) 13059 return data
Update an envelope transfer rule for an account.
This method changes the status of an envelope transfer rule. You use this method to change whether or not the rule is enabled. You must include the envelopeTransferRuleId both as a query parameter, and in the request body. Note: You cannot change any other information about the envelope transfer rule. Only Administrators can update an envelope transfer rule. In addition, to use envelope transfer rules, the Transfer Custody feature must be enabled for your account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_envelope_transfer_rule(account_id, envelope_transfer_rule_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_transfer_rule_id: (required)
- EnvelopeTransferRule envelope_transfer_rule:
Returns
EnvelopeTransferRule If the method is called asynchronously, returns the request thread.
def
update_envelope_transfer_rule_with_http_info(self, account_id, envelope_transfer_rule_id, **kwargs)
13061 def update_envelope_transfer_rule_with_http_info(self, account_id, envelope_transfer_rule_id, **kwargs): 13062 """ 13063 Update an envelope transfer rule for an account. 13064 This method changes the status of an envelope transfer rule. You use this method to change whether or not the rule is enabled. You must include the `envelopeTransferRuleId` both as a query parameter, and in the request body. **Note:** You cannot change any other information about the envelope transfer rule. Only Administrators can update an envelope transfer rule. In addition, to use envelope transfer rules, the **Transfer Custody** feature must be enabled for your account. 13065 This method makes a synchronous HTTP request by default. To make an 13066 asynchronous HTTP request, please define a `callback` function 13067 to be invoked when receiving the response. 13068 >>> def callback_function(response): 13069 >>> pprint(response) 13070 >>> 13071 >>> thread = api.update_envelope_transfer_rule_with_http_info(account_id, envelope_transfer_rule_id, callback=callback_function) 13072 13073 :param callback function: The callback function 13074 for asynchronous request. (optional) 13075 :param str account_id: The external account number (int) or account ID Guid. (required) 13076 :param str envelope_transfer_rule_id: (required) 13077 :param EnvelopeTransferRule envelope_transfer_rule: 13078 :return: EnvelopeTransferRule 13079 If the method is called asynchronously, 13080 returns the request thread. 13081 """ 13082 13083 all_params = ['account_id', 'envelope_transfer_rule_id', 'envelope_transfer_rule'] 13084 all_params.append('callback') 13085 all_params.append('_return_http_data_only') 13086 all_params.append('_preload_content') 13087 all_params.append('_request_timeout') 13088 13089 params = locals() 13090 for key, val in iteritems(params['kwargs']): 13091 if key not in all_params: 13092 raise TypeError( 13093 "Got an unexpected keyword argument '%s'" 13094 " to method update_envelope_transfer_rule" % key 13095 ) 13096 params[key] = val 13097 del params['kwargs'] 13098 # verify the required parameter 'account_id' is set 13099 if ('account_id' not in params) or (params['account_id'] is None): 13100 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_transfer_rule`") 13101 # verify the required parameter 'envelope_transfer_rule_id' is set 13102 if ('envelope_transfer_rule_id' not in params) or (params['envelope_transfer_rule_id'] is None): 13103 raise ValueError("Missing the required parameter `envelope_transfer_rule_id` when calling `update_envelope_transfer_rule`") 13104 13105 13106 collection_formats = {} 13107 13108 resource_path = '/v2.1/accounts/{accountId}/envelopes/transfer_rules/{envelopeTransferRuleId}'.replace('{format}', 'json') 13109 path_params = {} 13110 if 'account_id' in params: 13111 path_params['accountId'] = params['account_id'] 13112 if 'envelope_transfer_rule_id' in params: 13113 path_params['envelopeTransferRuleId'] = params['envelope_transfer_rule_id'] 13114 13115 query_params = {} 13116 13117 header_params = {} 13118 13119 form_params = [] 13120 local_var_files = {} 13121 13122 body_params = None 13123 if 'envelope_transfer_rule' in params: 13124 body_params = params['envelope_transfer_rule'] 13125 # HTTP header `Accept` 13126 header_params['Accept'] = self.api_client.\ 13127 select_header_accept(['application/json']) 13128 13129 # Authentication setting 13130 auth_settings = [] 13131 13132 return self.api_client.call_api(resource_path, 'PUT', 13133 path_params, 13134 query_params, 13135 header_params, 13136 body=body_params, 13137 post_params=form_params, 13138 files=local_var_files, 13139 response_type='EnvelopeTransferRule', 13140 auth_settings=auth_settings, 13141 callback=params.get('callback'), 13142 _return_http_data_only=params.get('_return_http_data_only'), 13143 _preload_content=params.get('_preload_content', True), 13144 _request_timeout=params.get('_request_timeout'), 13145 collection_formats=collection_formats)
Update an envelope transfer rule for an account.
This method changes the status of an envelope transfer rule. You use this method to change whether or not the rule is enabled. You must include the envelopeTransferRuleId both as a query parameter, and in the request body. Note: You cannot change any other information about the envelope transfer rule. Only Administrators can update an envelope transfer rule. In addition, to use envelope transfer rules, the Transfer Custody feature must be enabled for your account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_envelope_transfer_rule_with_http_info(account_id, envelope_transfer_rule_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_transfer_rule_id: (required)
- EnvelopeTransferRule envelope_transfer_rule:
Returns
EnvelopeTransferRule If the method is called asynchronously, returns the request thread.
def
update_envelope_transfer_rules(self, account_id, **kwargs)
13147 def update_envelope_transfer_rules(self, account_id, **kwargs): 13148 """ 13149 Update envelope transfer rules for an account. 13150 This method changes the status for one or more envelope transfer rules based on the `envelopeTransferRuleId`s in the request body. You use this method to change whether or not the rules are enabled. **Note:** You cannot change any other information about the envelope transfer rule. Only Administrators can update envelope transfer rules. In addition, to use envelope transfer rules, the **Transfer Custody** feature must be enabled for your account. 13151 This method makes a synchronous HTTP request by default. To make an 13152 asynchronous HTTP request, please define a `callback` function 13153 to be invoked when receiving the response. 13154 >>> def callback_function(response): 13155 >>> pprint(response) 13156 >>> 13157 >>> thread = api.update_envelope_transfer_rules(account_id, callback=callback_function) 13158 13159 :param callback function: The callback function 13160 for asynchronous request. (optional) 13161 :param str account_id: The external account number (int) or account ID Guid. (required) 13162 :param EnvelopeTransferRuleInformation envelope_transfer_rule_information: 13163 :return: EnvelopeTransferRuleInformation 13164 If the method is called asynchronously, 13165 returns the request thread. 13166 """ 13167 kwargs['_return_http_data_only'] = True 13168 if kwargs.get('callback'): 13169 return self.update_envelope_transfer_rules_with_http_info(account_id, **kwargs) 13170 else: 13171 (data) = self.update_envelope_transfer_rules_with_http_info(account_id, **kwargs) 13172 return data
Update envelope transfer rules for an account.
This method changes the status for one or more envelope transfer rules based on the envelopeTransferRuleIds in the request body. You use this method to change whether or not the rules are enabled. Note: You cannot change any other information about the envelope transfer rule. Only Administrators can update envelope transfer rules. In addition, to use envelope transfer rules, the Transfer Custody feature must be enabled for your account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_envelope_transfer_rules(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- EnvelopeTransferRuleInformation envelope_transfer_rule_information:
Returns
EnvelopeTransferRuleInformation If the method is called asynchronously, returns the request thread.
def
update_envelope_transfer_rules_with_http_info(self, account_id, **kwargs)
13174 def update_envelope_transfer_rules_with_http_info(self, account_id, **kwargs): 13175 """ 13176 Update envelope transfer rules for an account. 13177 This method changes the status for one or more envelope transfer rules based on the `envelopeTransferRuleId`s in the request body. You use this method to change whether or not the rules are enabled. **Note:** You cannot change any other information about the envelope transfer rule. Only Administrators can update envelope transfer rules. In addition, to use envelope transfer rules, the **Transfer Custody** feature must be enabled for your account. 13178 This method makes a synchronous HTTP request by default. To make an 13179 asynchronous HTTP request, please define a `callback` function 13180 to be invoked when receiving the response. 13181 >>> def callback_function(response): 13182 >>> pprint(response) 13183 >>> 13184 >>> thread = api.update_envelope_transfer_rules_with_http_info(account_id, callback=callback_function) 13185 13186 :param callback function: The callback function 13187 for asynchronous request. (optional) 13188 :param str account_id: The external account number (int) or account ID Guid. (required) 13189 :param EnvelopeTransferRuleInformation envelope_transfer_rule_information: 13190 :return: EnvelopeTransferRuleInformation 13191 If the method is called asynchronously, 13192 returns the request thread. 13193 """ 13194 13195 all_params = ['account_id', 'envelope_transfer_rule_information'] 13196 all_params.append('callback') 13197 all_params.append('_return_http_data_only') 13198 all_params.append('_preload_content') 13199 all_params.append('_request_timeout') 13200 13201 params = locals() 13202 for key, val in iteritems(params['kwargs']): 13203 if key not in all_params: 13204 raise TypeError( 13205 "Got an unexpected keyword argument '%s'" 13206 " to method update_envelope_transfer_rules" % key 13207 ) 13208 params[key] = val 13209 del params['kwargs'] 13210 # verify the required parameter 'account_id' is set 13211 if ('account_id' not in params) or (params['account_id'] is None): 13212 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_transfer_rules`") 13213 13214 13215 collection_formats = {} 13216 13217 resource_path = '/v2.1/accounts/{accountId}/envelopes/transfer_rules'.replace('{format}', 'json') 13218 path_params = {} 13219 if 'account_id' in params: 13220 path_params['accountId'] = params['account_id'] 13221 13222 query_params = {} 13223 13224 header_params = {} 13225 13226 form_params = [] 13227 local_var_files = {} 13228 13229 body_params = None 13230 if 'envelope_transfer_rule_information' in params: 13231 body_params = params['envelope_transfer_rule_information'] 13232 # HTTP header `Accept` 13233 header_params['Accept'] = self.api_client.\ 13234 select_header_accept(['application/json']) 13235 13236 # Authentication setting 13237 auth_settings = [] 13238 13239 return self.api_client.call_api(resource_path, 'PUT', 13240 path_params, 13241 query_params, 13242 header_params, 13243 body=body_params, 13244 post_params=form_params, 13245 files=local_var_files, 13246 response_type='EnvelopeTransferRuleInformation', 13247 auth_settings=auth_settings, 13248 callback=params.get('callback'), 13249 _return_http_data_only=params.get('_return_http_data_only'), 13250 _preload_content=params.get('_preload_content', True), 13251 _request_timeout=params.get('_request_timeout'), 13252 collection_formats=collection_formats)
Update envelope transfer rules for an account.
This method changes the status for one or more envelope transfer rules based on the envelopeTransferRuleIds in the request body. You use this method to change whether or not the rules are enabled. Note: You cannot change any other information about the envelope transfer rule. Only Administrators can update envelope transfer rules. In addition, to use envelope transfer rules, the Transfer Custody feature must be enabled for your account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_envelope_transfer_rules_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- EnvelopeTransferRuleInformation envelope_transfer_rule_information:
Returns
EnvelopeTransferRuleInformation If the method is called asynchronously, returns the request thread.
def
update_envelope_workflow_definition(self, account_id, envelope_id, **kwargs)
13254 def update_envelope_workflow_definition(self, account_id, envelope_id, **kwargs): 13255 """ 13256 Updates the envelope workflow definition for an envelope. 13257 Updates the specified envelope's workflow definition if it has one. 13258 This method makes a synchronous HTTP request by default. To make an 13259 asynchronous HTTP request, please define a `callback` function 13260 to be invoked when receiving the response. 13261 >>> def callback_function(response): 13262 >>> pprint(response) 13263 >>> 13264 >>> thread = api.update_envelope_workflow_definition(account_id, envelope_id, callback=callback_function) 13265 13266 :param callback function: The callback function 13267 for asynchronous request. (optional) 13268 :param str account_id: The external account number (int) or account ID Guid. (required) 13269 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13270 :param Workflow workflow: 13271 :return: Workflow 13272 If the method is called asynchronously, 13273 returns the request thread. 13274 """ 13275 kwargs['_return_http_data_only'] = True 13276 if kwargs.get('callback'): 13277 return self.update_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 13278 else: 13279 (data) = self.update_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 13280 return data
Updates the envelope workflow definition for an envelope.
Updates the specified envelope's workflow definition if it has one.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_envelope_workflow_definition(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- Workflow workflow:
Returns
Workflow If the method is called asynchronously, returns the request thread.
def
update_envelope_workflow_definition_with_http_info(self, account_id, envelope_id, **kwargs)
13282 def update_envelope_workflow_definition_with_http_info(self, account_id, envelope_id, **kwargs): 13283 """ 13284 Updates the envelope workflow definition for an envelope. 13285 Updates the specified envelope's workflow definition if it has one. 13286 This method makes a synchronous HTTP request by default. To make an 13287 asynchronous HTTP request, please define a `callback` function 13288 to be invoked when receiving the response. 13289 >>> def callback_function(response): 13290 >>> pprint(response) 13291 >>> 13292 >>> thread = api.update_envelope_workflow_definition_with_http_info(account_id, envelope_id, callback=callback_function) 13293 13294 :param callback function: The callback function 13295 for asynchronous request. (optional) 13296 :param str account_id: The external account number (int) or account ID Guid. (required) 13297 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13298 :param Workflow workflow: 13299 :return: Workflow 13300 If the method is called asynchronously, 13301 returns the request thread. 13302 """ 13303 13304 all_params = ['account_id', 'envelope_id', 'workflow'] 13305 all_params.append('callback') 13306 all_params.append('_return_http_data_only') 13307 all_params.append('_preload_content') 13308 all_params.append('_request_timeout') 13309 13310 params = locals() 13311 for key, val in iteritems(params['kwargs']): 13312 if key not in all_params: 13313 raise TypeError( 13314 "Got an unexpected keyword argument '%s'" 13315 " to method update_envelope_workflow_definition" % key 13316 ) 13317 params[key] = val 13318 del params['kwargs'] 13319 # verify the required parameter 'account_id' is set 13320 if ('account_id' not in params) or (params['account_id'] is None): 13321 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_workflow_definition`") 13322 # verify the required parameter 'envelope_id' is set 13323 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13324 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_workflow_definition`") 13325 13326 13327 collection_formats = {} 13328 13329 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow'.replace('{format}', 'json') 13330 path_params = {} 13331 if 'account_id' in params: 13332 path_params['accountId'] = params['account_id'] 13333 if 'envelope_id' in params: 13334 path_params['envelopeId'] = params['envelope_id'] 13335 13336 query_params = {} 13337 13338 header_params = {} 13339 13340 form_params = [] 13341 local_var_files = {} 13342 13343 body_params = None 13344 if 'workflow' in params: 13345 body_params = params['workflow'] 13346 # HTTP header `Accept` 13347 header_params['Accept'] = self.api_client.\ 13348 select_header_accept(['application/json']) 13349 13350 # Authentication setting 13351 auth_settings = [] 13352 13353 return self.api_client.call_api(resource_path, 'PUT', 13354 path_params, 13355 query_params, 13356 header_params, 13357 body=body_params, 13358 post_params=form_params, 13359 files=local_var_files, 13360 response_type='Workflow', 13361 auth_settings=auth_settings, 13362 callback=params.get('callback'), 13363 _return_http_data_only=params.get('_return_http_data_only'), 13364 _preload_content=params.get('_preload_content', True), 13365 _request_timeout=params.get('_request_timeout'), 13366 collection_formats=collection_formats)
Updates the envelope workflow definition for an envelope.
Updates the specified envelope's workflow definition if it has one.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_envelope_workflow_definition_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- Workflow workflow:
Returns
Workflow If the method is called asynchronously, returns the request thread.
def
update_envelope_workflow_step_definition(self, account_id, envelope_id, workflow_step_id, **kwargs)
13368 def update_envelope_workflow_step_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 13369 """ 13370 Updates the envelope workflow step definition for an envelope. 13371 This method makes a synchronous HTTP request by default. To make an 13372 asynchronous HTTP request, please define a `callback` function 13373 to be invoked when receiving the response. 13374 >>> def callback_function(response): 13375 >>> pprint(response) 13376 >>> 13377 >>> thread = api.update_envelope_workflow_step_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 13378 13379 :param callback function: The callback function 13380 for asynchronous request. (optional) 13381 :param str account_id: The external account number (int) or account ID Guid. (required) 13382 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13383 :param str workflow_step_id: (required) 13384 :param WorkflowStep workflow_step: 13385 :return: WorkflowStep 13386 If the method is called asynchronously, 13387 returns the request thread. 13388 """ 13389 kwargs['_return_http_data_only'] = True 13390 if kwargs.get('callback'): 13391 return self.update_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 13392 else: 13393 (data) = self.update_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 13394 return data
Updates the envelope workflow step definition for an envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_envelope_workflow_step_definition(account_id, envelope_id, workflow_step_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str workflow_step_id: (required)
- WorkflowStep workflow_step:
Returns
WorkflowStep If the method is called asynchronously, returns the request thread.
def
update_envelope_workflow_step_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs)
13396 def update_envelope_workflow_step_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 13397 """ 13398 Updates the envelope workflow step definition for an envelope. 13399 This method makes a synchronous HTTP request by default. To make an 13400 asynchronous HTTP request, please define a `callback` function 13401 to be invoked when receiving the response. 13402 >>> def callback_function(response): 13403 >>> pprint(response) 13404 >>> 13405 >>> thread = api.update_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 13406 13407 :param callback function: The callback function 13408 for asynchronous request. (optional) 13409 :param str account_id: The external account number (int) or account ID Guid. (required) 13410 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13411 :param str workflow_step_id: (required) 13412 :param WorkflowStep workflow_step: 13413 :return: WorkflowStep 13414 If the method is called asynchronously, 13415 returns the request thread. 13416 """ 13417 13418 all_params = ['account_id', 'envelope_id', 'workflow_step_id', 'workflow_step'] 13419 all_params.append('callback') 13420 all_params.append('_return_http_data_only') 13421 all_params.append('_preload_content') 13422 all_params.append('_request_timeout') 13423 13424 params = locals() 13425 for key, val in iteritems(params['kwargs']): 13426 if key not in all_params: 13427 raise TypeError( 13428 "Got an unexpected keyword argument '%s'" 13429 " to method update_envelope_workflow_step_definition" % key 13430 ) 13431 params[key] = val 13432 del params['kwargs'] 13433 # verify the required parameter 'account_id' is set 13434 if ('account_id' not in params) or (params['account_id'] is None): 13435 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_workflow_step_definition`") 13436 # verify the required parameter 'envelope_id' is set 13437 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13438 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_workflow_step_definition`") 13439 # verify the required parameter 'workflow_step_id' is set 13440 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 13441 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_envelope_workflow_step_definition`") 13442 13443 13444 collection_formats = {} 13445 13446 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 13447 path_params = {} 13448 if 'account_id' in params: 13449 path_params['accountId'] = params['account_id'] 13450 if 'envelope_id' in params: 13451 path_params['envelopeId'] = params['envelope_id'] 13452 if 'workflow_step_id' in params: 13453 path_params['workflowStepId'] = params['workflow_step_id'] 13454 13455 query_params = {} 13456 13457 header_params = {} 13458 13459 form_params = [] 13460 local_var_files = {} 13461 13462 body_params = None 13463 if 'workflow_step' in params: 13464 body_params = params['workflow_step'] 13465 # HTTP header `Accept` 13466 header_params['Accept'] = self.api_client.\ 13467 select_header_accept(['application/json']) 13468 13469 # Authentication setting 13470 auth_settings = [] 13471 13472 return self.api_client.call_api(resource_path, 'PUT', 13473 path_params, 13474 query_params, 13475 header_params, 13476 body=body_params, 13477 post_params=form_params, 13478 files=local_var_files, 13479 response_type='WorkflowStep', 13480 auth_settings=auth_settings, 13481 callback=params.get('callback'), 13482 _return_http_data_only=params.get('_return_http_data_only'), 13483 _preload_content=params.get('_preload_content', True), 13484 _request_timeout=params.get('_request_timeout'), 13485 collection_formats=collection_formats)
Updates the envelope workflow step definition for an envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str workflow_step_id: (required)
- WorkflowStep workflow_step:
Returns
WorkflowStep If the method is called asynchronously, returns the request thread.
def
update_lock(self, account_id, envelope_id, **kwargs)
13487 def update_lock(self, account_id, envelope_id, **kwargs): 13488 """ 13489 Updates an envelope lock. 13490 Updates the lock duration time or update the `lockedByApp` property information for the specified envelope. The user and integrator key must match the user specified by the `lockByUser` property and integrator key information and the `X-DocuSign-Edit` header must be included or an error will be generated. 13491 This method makes a synchronous HTTP request by default. To make an 13492 asynchronous HTTP request, please define a `callback` function 13493 to be invoked when receiving the response. 13494 >>> def callback_function(response): 13495 >>> pprint(response) 13496 >>> 13497 >>> thread = api.update_lock(account_id, envelope_id, callback=callback_function) 13498 13499 :param callback function: The callback function 13500 for asynchronous request. (optional) 13501 :param str account_id: The external account number (int) or account ID Guid. (required) 13502 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13503 :param LockRequest lock_request: 13504 :return: LockInformation 13505 If the method is called asynchronously, 13506 returns the request thread. 13507 """ 13508 kwargs['_return_http_data_only'] = True 13509 if kwargs.get('callback'): 13510 return self.update_lock_with_http_info(account_id, envelope_id, **kwargs) 13511 else: 13512 (data) = self.update_lock_with_http_info(account_id, envelope_id, **kwargs) 13513 return data
Updates an envelope lock.
Updates the lock duration time or update the lockedByApp property information for the specified envelope. The user and integrator key must match the user specified by the lockByUser property and integrator key information and the X-DocuSign-Edit header must be included or an error will be generated.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_lock(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- LockRequest lock_request:
Returns
LockInformation If the method is called asynchronously, returns the request thread.
def
update_lock_with_http_info(self, account_id, envelope_id, **kwargs)
13515 def update_lock_with_http_info(self, account_id, envelope_id, **kwargs): 13516 """ 13517 Updates an envelope lock. 13518 Updates the lock duration time or update the `lockedByApp` property information for the specified envelope. The user and integrator key must match the user specified by the `lockByUser` property and integrator key information and the `X-DocuSign-Edit` header must be included or an error will be generated. 13519 This method makes a synchronous HTTP request by default. To make an 13520 asynchronous HTTP request, please define a `callback` function 13521 to be invoked when receiving the response. 13522 >>> def callback_function(response): 13523 >>> pprint(response) 13524 >>> 13525 >>> thread = api.update_lock_with_http_info(account_id, envelope_id, callback=callback_function) 13526 13527 :param callback function: The callback function 13528 for asynchronous request. (optional) 13529 :param str account_id: The external account number (int) or account ID Guid. (required) 13530 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13531 :param LockRequest lock_request: 13532 :return: LockInformation 13533 If the method is called asynchronously, 13534 returns the request thread. 13535 """ 13536 13537 all_params = ['account_id', 'envelope_id', 'lock_request'] 13538 all_params.append('callback') 13539 all_params.append('_return_http_data_only') 13540 all_params.append('_preload_content') 13541 all_params.append('_request_timeout') 13542 13543 params = locals() 13544 for key, val in iteritems(params['kwargs']): 13545 if key not in all_params: 13546 raise TypeError( 13547 "Got an unexpected keyword argument '%s'" 13548 " to method update_lock" % key 13549 ) 13550 params[key] = val 13551 del params['kwargs'] 13552 # verify the required parameter 'account_id' is set 13553 if ('account_id' not in params) or (params['account_id'] is None): 13554 raise ValueError("Missing the required parameter `account_id` when calling `update_lock`") 13555 # verify the required parameter 'envelope_id' is set 13556 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13557 raise ValueError("Missing the required parameter `envelope_id` when calling `update_lock`") 13558 13559 13560 collection_formats = {} 13561 13562 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/lock'.replace('{format}', 'json') 13563 path_params = {} 13564 if 'account_id' in params: 13565 path_params['accountId'] = params['account_id'] 13566 if 'envelope_id' in params: 13567 path_params['envelopeId'] = params['envelope_id'] 13568 13569 query_params = {} 13570 13571 header_params = {} 13572 13573 form_params = [] 13574 local_var_files = {} 13575 13576 body_params = None 13577 if 'lock_request' in params: 13578 body_params = params['lock_request'] 13579 # HTTP header `Accept` 13580 header_params['Accept'] = self.api_client.\ 13581 select_header_accept(['application/json']) 13582 13583 # Authentication setting 13584 auth_settings = [] 13585 13586 return self.api_client.call_api(resource_path, 'PUT', 13587 path_params, 13588 query_params, 13589 header_params, 13590 body=body_params, 13591 post_params=form_params, 13592 files=local_var_files, 13593 response_type='LockInformation', 13594 auth_settings=auth_settings, 13595 callback=params.get('callback'), 13596 _return_http_data_only=params.get('_return_http_data_only'), 13597 _preload_content=params.get('_preload_content', True), 13598 _request_timeout=params.get('_request_timeout'), 13599 collection_formats=collection_formats)
Updates an envelope lock.
Updates the lock duration time or update the lockedByApp property information for the specified envelope. The user and integrator key must match the user specified by the lockByUser property and integrator key information and the X-DocuSign-Edit header must be included or an error will be generated.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_lock_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- LockRequest lock_request:
Returns
LockInformation If the method is called asynchronously, returns the request thread.
def
update_notification_settings(self, account_id, envelope_id, **kwargs)
13601 def update_notification_settings(self, account_id, envelope_id, **kwargs): 13602 """ 13603 Sets envelope notification (Reminders/Expirations) structure for an existing envelope. 13604 This method sets the notifications (reminders and expirations) for an existing envelope. The request body sends a structure containing reminders and expirations settings. It also specifies whether to use the settings specified in the request, or the account default notification settings for the envelope. Note that this request only specifies when notifications are sent; it does not initiate sending of email messages. 13605 This method makes a synchronous HTTP request by default. To make an 13606 asynchronous HTTP request, please define a `callback` function 13607 to be invoked when receiving the response. 13608 >>> def callback_function(response): 13609 >>> pprint(response) 13610 >>> 13611 >>> thread = api.update_notification_settings(account_id, envelope_id, callback=callback_function) 13612 13613 :param callback function: The callback function 13614 for asynchronous request. (optional) 13615 :param str account_id: The external account number (int) or account ID Guid. (required) 13616 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13617 :param EnvelopeNotificationRequest envelope_notification_request: 13618 :return: Notification 13619 If the method is called asynchronously, 13620 returns the request thread. 13621 """ 13622 kwargs['_return_http_data_only'] = True 13623 if kwargs.get('callback'): 13624 return self.update_notification_settings_with_http_info(account_id, envelope_id, **kwargs) 13625 else: 13626 (data) = self.update_notification_settings_with_http_info(account_id, envelope_id, **kwargs) 13627 return data
Sets envelope notification (Reminders/Expirations) structure for an existing envelope.
This method sets the notifications (reminders and expirations) for an existing envelope. The request body sends a structure containing reminders and expirations settings. It also specifies whether to use the settings specified in the request, or the account default notification settings for the envelope. Note that this request only specifies when notifications are sent; it does not initiate sending of email messages.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_notification_settings(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- EnvelopeNotificationRequest envelope_notification_request:
Returns
Notification If the method is called asynchronously, returns the request thread.
def
update_notification_settings_with_http_info(self, account_id, envelope_id, **kwargs)
13629 def update_notification_settings_with_http_info(self, account_id, envelope_id, **kwargs): 13630 """ 13631 Sets envelope notification (Reminders/Expirations) structure for an existing envelope. 13632 This method sets the notifications (reminders and expirations) for an existing envelope. The request body sends a structure containing reminders and expirations settings. It also specifies whether to use the settings specified in the request, or the account default notification settings for the envelope. Note that this request only specifies when notifications are sent; it does not initiate sending of email messages. 13633 This method makes a synchronous HTTP request by default. To make an 13634 asynchronous HTTP request, please define a `callback` function 13635 to be invoked when receiving the response. 13636 >>> def callback_function(response): 13637 >>> pprint(response) 13638 >>> 13639 >>> thread = api.update_notification_settings_with_http_info(account_id, envelope_id, callback=callback_function) 13640 13641 :param callback function: The callback function 13642 for asynchronous request. (optional) 13643 :param str account_id: The external account number (int) or account ID Guid. (required) 13644 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13645 :param EnvelopeNotificationRequest envelope_notification_request: 13646 :return: Notification 13647 If the method is called asynchronously, 13648 returns the request thread. 13649 """ 13650 13651 all_params = ['account_id', 'envelope_id', 'envelope_notification_request'] 13652 all_params.append('callback') 13653 all_params.append('_return_http_data_only') 13654 all_params.append('_preload_content') 13655 all_params.append('_request_timeout') 13656 13657 params = locals() 13658 for key, val in iteritems(params['kwargs']): 13659 if key not in all_params: 13660 raise TypeError( 13661 "Got an unexpected keyword argument '%s'" 13662 " to method update_notification_settings" % key 13663 ) 13664 params[key] = val 13665 del params['kwargs'] 13666 # verify the required parameter 'account_id' is set 13667 if ('account_id' not in params) or (params['account_id'] is None): 13668 raise ValueError("Missing the required parameter `account_id` when calling `update_notification_settings`") 13669 # verify the required parameter 'envelope_id' is set 13670 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13671 raise ValueError("Missing the required parameter `envelope_id` when calling `update_notification_settings`") 13672 13673 13674 collection_formats = {} 13675 13676 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/notification'.replace('{format}', 'json') 13677 path_params = {} 13678 if 'account_id' in params: 13679 path_params['accountId'] = params['account_id'] 13680 if 'envelope_id' in params: 13681 path_params['envelopeId'] = params['envelope_id'] 13682 13683 query_params = {} 13684 13685 header_params = {} 13686 13687 form_params = [] 13688 local_var_files = {} 13689 13690 body_params = None 13691 if 'envelope_notification_request' in params: 13692 body_params = params['envelope_notification_request'] 13693 # HTTP header `Accept` 13694 header_params['Accept'] = self.api_client.\ 13695 select_header_accept(['application/json']) 13696 13697 # Authentication setting 13698 auth_settings = [] 13699 13700 return self.api_client.call_api(resource_path, 'PUT', 13701 path_params, 13702 query_params, 13703 header_params, 13704 body=body_params, 13705 post_params=form_params, 13706 files=local_var_files, 13707 response_type='Notification', 13708 auth_settings=auth_settings, 13709 callback=params.get('callback'), 13710 _return_http_data_only=params.get('_return_http_data_only'), 13711 _preload_content=params.get('_preload_content', True), 13712 _request_timeout=params.get('_request_timeout'), 13713 collection_formats=collection_formats)
Sets envelope notification (Reminders/Expirations) structure for an existing envelope.
This method sets the notifications (reminders and expirations) for an existing envelope. The request body sends a structure containing reminders and expirations settings. It also specifies whether to use the settings specified in the request, or the account default notification settings for the envelope. Note that this request only specifies when notifications are sent; it does not initiate sending of email messages.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_notification_settings_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- EnvelopeNotificationRequest envelope_notification_request:
Returns
Notification If the method is called asynchronously, returns the request thread.
def
update_recipient_document_visibility(self, account_id, envelope_id, recipient_id, **kwargs)
13715 def update_recipient_document_visibility(self, account_id, envelope_id, recipient_id, **kwargs): 13716 """ 13717 Updates document visibility for the recipients 13718 This method updates document visibility for a recipient. **Note:** A document cannot be hidden from a recipient if the recipient has tabs assigned to them on the document. Carbon Copy, Certified Delivery (Needs to Sign), Editor, and Agent recipients can always see all documents. 13719 This method makes a synchronous HTTP request by default. To make an 13720 asynchronous HTTP request, please define a `callback` function 13721 to be invoked when receiving the response. 13722 >>> def callback_function(response): 13723 >>> pprint(response) 13724 >>> 13725 >>> thread = api.update_recipient_document_visibility(account_id, envelope_id, recipient_id, callback=callback_function) 13726 13727 :param callback function: The callback function 13728 for asynchronous request. (optional) 13729 :param str account_id: The external account number (int) or account ID Guid. (required) 13730 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13731 :param str recipient_id: The ID of the recipient being accessed. (required) 13732 :param DocumentVisibilityList document_visibility_list: 13733 :return: DocumentVisibilityList 13734 If the method is called asynchronously, 13735 returns the request thread. 13736 """ 13737 kwargs['_return_http_data_only'] = True 13738 if kwargs.get('callback'): 13739 return self.update_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13740 else: 13741 (data) = self.update_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13742 return data
Updates document visibility for the recipients
This method updates document visibility for a recipient. Note: A document cannot be hidden from a recipient if the recipient has tabs assigned to them on the document. Carbon Copy, Certified Delivery (Needs to Sign), Editor, and Agent recipients can always see all documents.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_recipient_document_visibility(account_id, envelope_id, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
- DocumentVisibilityList document_visibility_list:
Returns
DocumentVisibilityList If the method is called asynchronously, returns the request thread.
def
update_recipient_document_visibility_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs)
13744 def update_recipient_document_visibility_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 13745 """ 13746 Updates document visibility for the recipients 13747 This method updates document visibility for a recipient. **Note:** A document cannot be hidden from a recipient if the recipient has tabs assigned to them on the document. Carbon Copy, Certified Delivery (Needs to Sign), Editor, and Agent recipients can always see all documents. 13748 This method makes a synchronous HTTP request by default. To make an 13749 asynchronous HTTP request, please define a `callback` function 13750 to be invoked when receiving the response. 13751 >>> def callback_function(response): 13752 >>> pprint(response) 13753 >>> 13754 >>> thread = api.update_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 13755 13756 :param callback function: The callback function 13757 for asynchronous request. (optional) 13758 :param str account_id: The external account number (int) or account ID Guid. (required) 13759 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13760 :param str recipient_id: The ID of the recipient being accessed. (required) 13761 :param DocumentVisibilityList document_visibility_list: 13762 :return: DocumentVisibilityList 13763 If the method is called asynchronously, 13764 returns the request thread. 13765 """ 13766 13767 all_params = ['account_id', 'envelope_id', 'recipient_id', 'document_visibility_list'] 13768 all_params.append('callback') 13769 all_params.append('_return_http_data_only') 13770 all_params.append('_preload_content') 13771 all_params.append('_request_timeout') 13772 13773 params = locals() 13774 for key, val in iteritems(params['kwargs']): 13775 if key not in all_params: 13776 raise TypeError( 13777 "Got an unexpected keyword argument '%s'" 13778 " to method update_recipient_document_visibility" % key 13779 ) 13780 params[key] = val 13781 del params['kwargs'] 13782 # verify the required parameter 'account_id' is set 13783 if ('account_id' not in params) or (params['account_id'] is None): 13784 raise ValueError("Missing the required parameter `account_id` when calling `update_recipient_document_visibility`") 13785 # verify the required parameter 'envelope_id' is set 13786 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13787 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipient_document_visibility`") 13788 # verify the required parameter 'recipient_id' is set 13789 if ('recipient_id' not in params) or (params['recipient_id'] is None): 13790 raise ValueError("Missing the required parameter `recipient_id` when calling `update_recipient_document_visibility`") 13791 13792 13793 collection_formats = {} 13794 13795 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/document_visibility'.replace('{format}', 'json') 13796 path_params = {} 13797 if 'account_id' in params: 13798 path_params['accountId'] = params['account_id'] 13799 if 'envelope_id' in params: 13800 path_params['envelopeId'] = params['envelope_id'] 13801 if 'recipient_id' in params: 13802 path_params['recipientId'] = params['recipient_id'] 13803 13804 query_params = {} 13805 13806 header_params = {} 13807 13808 form_params = [] 13809 local_var_files = {} 13810 13811 body_params = None 13812 if 'document_visibility_list' in params: 13813 body_params = params['document_visibility_list'] 13814 # HTTP header `Accept` 13815 header_params['Accept'] = self.api_client.\ 13816 select_header_accept(['application/json']) 13817 13818 # Authentication setting 13819 auth_settings = [] 13820 13821 return self.api_client.call_api(resource_path, 'PUT', 13822 path_params, 13823 query_params, 13824 header_params, 13825 body=body_params, 13826 post_params=form_params, 13827 files=local_var_files, 13828 response_type='DocumentVisibilityList', 13829 auth_settings=auth_settings, 13830 callback=params.get('callback'), 13831 _return_http_data_only=params.get('_return_http_data_only'), 13832 _preload_content=params.get('_preload_content', True), 13833 _request_timeout=params.get('_request_timeout'), 13834 collection_formats=collection_formats)
Updates document visibility for the recipients
This method updates document visibility for a recipient. Note: A document cannot be hidden from a recipient if the recipient has tabs assigned to them on the document. Carbon Copy, Certified Delivery (Needs to Sign), Editor, and Agent recipients can always see all documents.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
- DocumentVisibilityList document_visibility_list:
Returns
DocumentVisibilityList If the method is called asynchronously, returns the request thread.
def
update_recipient_initials_image(self, account_id, envelope_id, recipient_id, **kwargs)
13836 def update_recipient_initials_image(self, account_id, envelope_id, recipient_id, **kwargs): 13837 """ 13838 Sets the initials image for an accountless signer. 13839 Updates the initials image for a signer that does not have a DocuSign account. The supported image formats for this file are: gif, png, jpeg, and bmp. The file size must be less than 200K. For the Authentication/Authorization for this call, the credentials must match the sender of the envelope, the recipient must be an accountless signer or in person signer. The account must have the `CanSendEnvelope` property set to **true** and the `ExpressSendOnly` property in `SendingUser` structure must be set to **false**. 13840 This method makes a synchronous HTTP request by default. To make an 13841 asynchronous HTTP request, please define a `callback` function 13842 to be invoked when receiving the response. 13843 >>> def callback_function(response): 13844 >>> pprint(response) 13845 >>> 13846 >>> thread = api.update_recipient_initials_image(account_id, envelope_id, recipient_id, callback=callback_function) 13847 13848 :param callback function: The callback function 13849 for asynchronous request. (optional) 13850 :param str account_id: The external account number (int) or account ID Guid. (required) 13851 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13852 :param str recipient_id: The ID of the recipient being accessed. (required) 13853 :return: None 13854 If the method is called asynchronously, 13855 returns the request thread. 13856 """ 13857 kwargs['_return_http_data_only'] = True 13858 if kwargs.get('callback'): 13859 return self.update_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13860 else: 13861 (data) = self.update_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13862 return data
Sets the initials image for an accountless signer.
Updates the initials image for a signer that does not have a DocuSign account. The supported image formats for this file are: gif, png, jpeg, and bmp. The file size must be less than 200K. For the Authentication/Authorization for this call, the credentials must match the sender of the envelope, the recipient must be an accountless signer or in person signer. The account must have the CanSendEnvelope property set to true and the ExpressSendOnly property in SendingUser structure must be set to false.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_recipient_initials_image(account_id, envelope_id, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
update_recipient_initials_image_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs)
13864 def update_recipient_initials_image_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 13865 """ 13866 Sets the initials image for an accountless signer. 13867 Updates the initials image for a signer that does not have a DocuSign account. The supported image formats for this file are: gif, png, jpeg, and bmp. The file size must be less than 200K. For the Authentication/Authorization for this call, the credentials must match the sender of the envelope, the recipient must be an accountless signer or in person signer. The account must have the `CanSendEnvelope` property set to **true** and the `ExpressSendOnly` property in `SendingUser` structure must be set to **false**. 13868 This method makes a synchronous HTTP request by default. To make an 13869 asynchronous HTTP request, please define a `callback` function 13870 to be invoked when receiving the response. 13871 >>> def callback_function(response): 13872 >>> pprint(response) 13873 >>> 13874 >>> thread = api.update_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 13875 13876 :param callback function: The callback function 13877 for asynchronous request. (optional) 13878 :param str account_id: The external account number (int) or account ID Guid. (required) 13879 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13880 :param str recipient_id: The ID of the recipient being accessed. (required) 13881 :return: None 13882 If the method is called asynchronously, 13883 returns the request thread. 13884 """ 13885 13886 all_params = ['account_id', 'envelope_id', 'recipient_id'] 13887 all_params.append('callback') 13888 all_params.append('_return_http_data_only') 13889 all_params.append('_preload_content') 13890 all_params.append('_request_timeout') 13891 13892 params = locals() 13893 for key, val in iteritems(params['kwargs']): 13894 if key not in all_params: 13895 raise TypeError( 13896 "Got an unexpected keyword argument '%s'" 13897 " to method update_recipient_initials_image" % key 13898 ) 13899 params[key] = val 13900 del params['kwargs'] 13901 # verify the required parameter 'account_id' is set 13902 if ('account_id' not in params) or (params['account_id'] is None): 13903 raise ValueError("Missing the required parameter `account_id` when calling `update_recipient_initials_image`") 13904 # verify the required parameter 'envelope_id' is set 13905 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13906 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipient_initials_image`") 13907 # verify the required parameter 'recipient_id' is set 13908 if ('recipient_id' not in params) or (params['recipient_id'] is None): 13909 raise ValueError("Missing the required parameter `recipient_id` when calling `update_recipient_initials_image`") 13910 13911 13912 collection_formats = {} 13913 13914 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/initials_image'.replace('{format}', 'json') 13915 path_params = {} 13916 if 'account_id' in params: 13917 path_params['accountId'] = params['account_id'] 13918 if 'envelope_id' in params: 13919 path_params['envelopeId'] = params['envelope_id'] 13920 if 'recipient_id' in params: 13921 path_params['recipientId'] = params['recipient_id'] 13922 13923 query_params = {} 13924 13925 header_params = {} 13926 13927 form_params = [] 13928 local_var_files = {} 13929 13930 body_params = None 13931 # HTTP header `Accept` 13932 header_params['Accept'] = self.api_client.\ 13933 select_header_accept(['application/json']) 13934 13935 # HTTP header `Content-Type` 13936 header_params['Content-Type'] = self.api_client.\ 13937 select_header_content_type(['image/gif']) 13938 13939 # Authentication setting 13940 auth_settings = [] 13941 13942 return self.api_client.call_api(resource_path, 'PUT', 13943 path_params, 13944 query_params, 13945 header_params, 13946 body=body_params, 13947 post_params=form_params, 13948 files=local_var_files, 13949 response_type=None, 13950 auth_settings=auth_settings, 13951 callback=params.get('callback'), 13952 _return_http_data_only=params.get('_return_http_data_only'), 13953 _preload_content=params.get('_preload_content', True), 13954 _request_timeout=params.get('_request_timeout'), 13955 collection_formats=collection_formats)
Sets the initials image for an accountless signer.
Updates the initials image for a signer that does not have a DocuSign account. The supported image formats for this file are: gif, png, jpeg, and bmp. The file size must be less than 200K. For the Authentication/Authorization for this call, the credentials must match the sender of the envelope, the recipient must be an accountless signer or in person signer. The account must have the CanSendEnvelope property set to true and the ExpressSendOnly property in SendingUser structure must be set to false.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
update_recipient_signature_image(self, account_id, envelope_id, recipient_id, **kwargs)
13957 def update_recipient_signature_image(self, account_id, envelope_id, recipient_id, **kwargs): 13958 """ 13959 Sets the signature image for an accountless signer. 13960 Updates the signature image for an accountless signer. The supported image formats for this file are: gif, png, jpeg, and bmp. The file size must be less than 200K. For the Authentication/Authorization for this call, the credentials must match the sender of the envelope, the recipient must be an accountless signer or in person signer. The account must have the `CanSendEnvelope` property set to **true** and the `ExpressSendOnly` property in `SendingUser` structure must be set to **false**. 13961 This method makes a synchronous HTTP request by default. To make an 13962 asynchronous HTTP request, please define a `callback` function 13963 to be invoked when receiving the response. 13964 >>> def callback_function(response): 13965 >>> pprint(response) 13966 >>> 13967 >>> thread = api.update_recipient_signature_image(account_id, envelope_id, recipient_id, callback=callback_function) 13968 13969 :param callback function: The callback function 13970 for asynchronous request. (optional) 13971 :param str account_id: The external account number (int) or account ID Guid. (required) 13972 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13973 :param str recipient_id: The ID of the recipient being accessed. (required) 13974 :return: None 13975 If the method is called asynchronously, 13976 returns the request thread. 13977 """ 13978 kwargs['_return_http_data_only'] = True 13979 if kwargs.get('callback'): 13980 return self.update_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13981 else: 13982 (data) = self.update_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13983 return data
Sets the signature image for an accountless signer.
Updates the signature image for an accountless signer. The supported image formats for this file are: gif, png, jpeg, and bmp. The file size must be less than 200K. For the Authentication/Authorization for this call, the credentials must match the sender of the envelope, the recipient must be an accountless signer or in person signer. The account must have the CanSendEnvelope property set to true and the ExpressSendOnly property in SendingUser structure must be set to false.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_recipient_signature_image(account_id, envelope_id, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
update_recipient_signature_image_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs)
13985 def update_recipient_signature_image_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 13986 """ 13987 Sets the signature image for an accountless signer. 13988 Updates the signature image for an accountless signer. The supported image formats for this file are: gif, png, jpeg, and bmp. The file size must be less than 200K. For the Authentication/Authorization for this call, the credentials must match the sender of the envelope, the recipient must be an accountless signer or in person signer. The account must have the `CanSendEnvelope` property set to **true** and the `ExpressSendOnly` property in `SendingUser` structure must be set to **false**. 13989 This method makes a synchronous HTTP request by default. To make an 13990 asynchronous HTTP request, please define a `callback` function 13991 to be invoked when receiving the response. 13992 >>> def callback_function(response): 13993 >>> pprint(response) 13994 >>> 13995 >>> thread = api.update_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 13996 13997 :param callback function: The callback function 13998 for asynchronous request. (optional) 13999 :param str account_id: The external account number (int) or account ID Guid. (required) 14000 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14001 :param str recipient_id: The ID of the recipient being accessed. (required) 14002 :return: None 14003 If the method is called asynchronously, 14004 returns the request thread. 14005 """ 14006 14007 all_params = ['account_id', 'envelope_id', 'recipient_id'] 14008 all_params.append('callback') 14009 all_params.append('_return_http_data_only') 14010 all_params.append('_preload_content') 14011 all_params.append('_request_timeout') 14012 14013 params = locals() 14014 for key, val in iteritems(params['kwargs']): 14015 if key not in all_params: 14016 raise TypeError( 14017 "Got an unexpected keyword argument '%s'" 14018 " to method update_recipient_signature_image" % key 14019 ) 14020 params[key] = val 14021 del params['kwargs'] 14022 # verify the required parameter 'account_id' is set 14023 if ('account_id' not in params) or (params['account_id'] is None): 14024 raise ValueError("Missing the required parameter `account_id` when calling `update_recipient_signature_image`") 14025 # verify the required parameter 'envelope_id' is set 14026 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14027 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipient_signature_image`") 14028 # verify the required parameter 'recipient_id' is set 14029 if ('recipient_id' not in params) or (params['recipient_id'] is None): 14030 raise ValueError("Missing the required parameter `recipient_id` when calling `update_recipient_signature_image`") 14031 14032 14033 collection_formats = {} 14034 14035 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/signature_image'.replace('{format}', 'json') 14036 path_params = {} 14037 if 'account_id' in params: 14038 path_params['accountId'] = params['account_id'] 14039 if 'envelope_id' in params: 14040 path_params['envelopeId'] = params['envelope_id'] 14041 if 'recipient_id' in params: 14042 path_params['recipientId'] = params['recipient_id'] 14043 14044 query_params = {} 14045 14046 header_params = {} 14047 14048 form_params = [] 14049 local_var_files = {} 14050 14051 body_params = None 14052 # HTTP header `Accept` 14053 header_params['Accept'] = self.api_client.\ 14054 select_header_accept(['application/json']) 14055 14056 # HTTP header `Content-Type` 14057 header_params['Content-Type'] = self.api_client.\ 14058 select_header_content_type(['image/gif']) 14059 14060 # Authentication setting 14061 auth_settings = [] 14062 14063 return self.api_client.call_api(resource_path, 'PUT', 14064 path_params, 14065 query_params, 14066 header_params, 14067 body=body_params, 14068 post_params=form_params, 14069 files=local_var_files, 14070 response_type=None, 14071 auth_settings=auth_settings, 14072 callback=params.get('callback'), 14073 _return_http_data_only=params.get('_return_http_data_only'), 14074 _preload_content=params.get('_preload_content', True), 14075 _request_timeout=params.get('_request_timeout'), 14076 collection_formats=collection_formats)
Sets the signature image for an accountless signer.
Updates the signature image for an accountless signer. The supported image formats for this file are: gif, png, jpeg, and bmp. The file size must be less than 200K. For the Authentication/Authorization for this call, the credentials must match the sender of the envelope, the recipient must be an accountless signer or in person signer. The account must have the CanSendEnvelope property set to true and the ExpressSendOnly property in SendingUser structure must be set to false.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
update_recipients(self, account_id, envelope_id, **kwargs)
14078 def update_recipients(self, account_id, envelope_id, **kwargs): 14079 """ 14080 Updates recipients in a draft envelope or corrects recipient information for an in process envelope. 14081 Updates recipients in a draft envelope or corrects recipient information for an in process envelope. For draft envelopes, you can edit the following properties: `email`, `userName`, `routingOrder`, `faxNumber`, `deliveryMethod`, `accessCode`, and `requireIdLookup`. Once an envelope has been sent, you can only edit: `email`, `userName`, `signerName`, `routingOrder`, `faxNumber`, and `deliveryMethod`. You can also select to resend an envelope by using the `resend_envelope` option. If you send information for a recipient that does not already exist in a draft envelope, the recipient is added to the envelope (similar to the POST). 14082 This method makes a synchronous HTTP request by default. To make an 14083 asynchronous HTTP request, please define a `callback` function 14084 to be invoked when receiving the response. 14085 >>> def callback_function(response): 14086 >>> pprint(response) 14087 >>> 14088 >>> thread = api.update_recipients(account_id, envelope_id, callback=callback_function) 14089 14090 :param callback function: The callback function 14091 for asynchronous request. (optional) 14092 :param str account_id: The external account number (int) or account ID Guid. (required) 14093 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14094 :param str combine_same_order_recipients: 14095 :param str offline_signing: 14096 :param str resend_envelope: When set to **true**, resends the envelope if the new recipient's routing order is before or the same as the envelope's next recipient. 14097 :param Recipients recipients: 14098 :return: RecipientsUpdateSummary 14099 If the method is called asynchronously, 14100 returns the request thread. 14101 """ 14102 kwargs['_return_http_data_only'] = True 14103 if kwargs.get('callback'): 14104 return self.update_recipients_with_http_info(account_id, envelope_id, **kwargs) 14105 else: 14106 (data) = self.update_recipients_with_http_info(account_id, envelope_id, **kwargs) 14107 return data
Updates recipients in a draft envelope or corrects recipient information for an in process envelope.
Updates recipients in a draft envelope or corrects recipient information for an in process envelope. For draft envelopes, you can edit the following properties: email, userName, routingOrder, faxNumber, deliveryMethod, accessCode, and requireIdLookup. Once an envelope has been sent, you can only edit: email, userName, signerName, routingOrder, faxNumber, and deliveryMethod. You can also select to resend an envelope by using the resend_envelope option. If you send information for a recipient that does not already exist in a draft envelope, the recipient is added to the envelope (similar to the POST).
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_recipients(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str combine_same_order_recipients:
- str offline_signing:
- str resend_envelope: When set to true, resends the envelope if the new recipient's routing order is before or the same as the envelope's next recipient.
- Recipients recipients:
Returns
RecipientsUpdateSummary If the method is called asynchronously, returns the request thread.
def
update_recipients_with_http_info(self, account_id, envelope_id, **kwargs)
14109 def update_recipients_with_http_info(self, account_id, envelope_id, **kwargs): 14110 """ 14111 Updates recipients in a draft envelope or corrects recipient information for an in process envelope. 14112 Updates recipients in a draft envelope or corrects recipient information for an in process envelope. For draft envelopes, you can edit the following properties: `email`, `userName`, `routingOrder`, `faxNumber`, `deliveryMethod`, `accessCode`, and `requireIdLookup`. Once an envelope has been sent, you can only edit: `email`, `userName`, `signerName`, `routingOrder`, `faxNumber`, and `deliveryMethod`. You can also select to resend an envelope by using the `resend_envelope` option. If you send information for a recipient that does not already exist in a draft envelope, the recipient is added to the envelope (similar to the POST). 14113 This method makes a synchronous HTTP request by default. To make an 14114 asynchronous HTTP request, please define a `callback` function 14115 to be invoked when receiving the response. 14116 >>> def callback_function(response): 14117 >>> pprint(response) 14118 >>> 14119 >>> thread = api.update_recipients_with_http_info(account_id, envelope_id, callback=callback_function) 14120 14121 :param callback function: The callback function 14122 for asynchronous request. (optional) 14123 :param str account_id: The external account number (int) or account ID Guid. (required) 14124 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14125 :param str combine_same_order_recipients: 14126 :param str offline_signing: 14127 :param str resend_envelope: When set to **true**, resends the envelope if the new recipient's routing order is before or the same as the envelope's next recipient. 14128 :param Recipients recipients: 14129 :return: RecipientsUpdateSummary 14130 If the method is called asynchronously, 14131 returns the request thread. 14132 """ 14133 14134 all_params = ['account_id', 'envelope_id', 'combine_same_order_recipients', 'offline_signing', 'resend_envelope', 'recipients'] 14135 all_params.append('callback') 14136 all_params.append('_return_http_data_only') 14137 all_params.append('_preload_content') 14138 all_params.append('_request_timeout') 14139 14140 params = locals() 14141 for key, val in iteritems(params['kwargs']): 14142 if key not in all_params: 14143 raise TypeError( 14144 "Got an unexpected keyword argument '%s'" 14145 " to method update_recipients" % key 14146 ) 14147 params[key] = val 14148 del params['kwargs'] 14149 # verify the required parameter 'account_id' is set 14150 if ('account_id' not in params) or (params['account_id'] is None): 14151 raise ValueError("Missing the required parameter `account_id` when calling `update_recipients`") 14152 # verify the required parameter 'envelope_id' is set 14153 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14154 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipients`") 14155 14156 14157 collection_formats = {} 14158 14159 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients'.replace('{format}', 'json') 14160 path_params = {} 14161 if 'account_id' in params: 14162 path_params['accountId'] = params['account_id'] 14163 if 'envelope_id' in params: 14164 path_params['envelopeId'] = params['envelope_id'] 14165 14166 query_params = {} 14167 if 'combine_same_order_recipients' in params: 14168 query_params['combine_same_order_recipients'] = params['combine_same_order_recipients'] 14169 if 'offline_signing' in params: 14170 query_params['offline_signing'] = params['offline_signing'] 14171 if 'resend_envelope' in params: 14172 query_params['resend_envelope'] = params['resend_envelope'] 14173 14174 header_params = {} 14175 14176 form_params = [] 14177 local_var_files = {} 14178 14179 body_params = None 14180 if 'recipients' in params: 14181 body_params = params['recipients'] 14182 # HTTP header `Accept` 14183 header_params['Accept'] = self.api_client.\ 14184 select_header_accept(['application/json']) 14185 14186 # Authentication setting 14187 auth_settings = [] 14188 14189 return self.api_client.call_api(resource_path, 'PUT', 14190 path_params, 14191 query_params, 14192 header_params, 14193 body=body_params, 14194 post_params=form_params, 14195 files=local_var_files, 14196 response_type='RecipientsUpdateSummary', 14197 auth_settings=auth_settings, 14198 callback=params.get('callback'), 14199 _return_http_data_only=params.get('_return_http_data_only'), 14200 _preload_content=params.get('_preload_content', True), 14201 _request_timeout=params.get('_request_timeout'), 14202 collection_formats=collection_formats)
Updates recipients in a draft envelope or corrects recipient information for an in process envelope.
Updates recipients in a draft envelope or corrects recipient information for an in process envelope. For draft envelopes, you can edit the following properties: email, userName, routingOrder, faxNumber, deliveryMethod, accessCode, and requireIdLookup. Once an envelope has been sent, you can only edit: email, userName, signerName, routingOrder, faxNumber, and deliveryMethod. You can also select to resend an envelope by using the resend_envelope option. If you send information for a recipient that does not already exist in a draft envelope, the recipient is added to the envelope (similar to the POST).
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_recipients_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str combine_same_order_recipients:
- str offline_signing:
- str resend_envelope: When set to true, resends the envelope if the new recipient's routing order is before or the same as the envelope's next recipient.
- Recipients recipients:
Returns
RecipientsUpdateSummary If the method is called asynchronously, returns the request thread.
def
update_recipients_document_visibility(self, account_id, envelope_id, **kwargs)
14204 def update_recipients_document_visibility(self, account_id, envelope_id, **kwargs): 14205 """ 14206 Updates document visibility for the recipients 14207 This method updates document visibility for one or more recipients based on the `recipientId` and `visible` values that you include in the request body. **Note:** A document cannot be hidden from a recipient if the recipient has tabs assigned to them on the document. Carbon Copy, Certified Delivery (Needs to Sign), Editor, and Agent recipients can always see all documents. 14208 This method makes a synchronous HTTP request by default. To make an 14209 asynchronous HTTP request, please define a `callback` function 14210 to be invoked when receiving the response. 14211 >>> def callback_function(response): 14212 >>> pprint(response) 14213 >>> 14214 >>> thread = api.update_recipients_document_visibility(account_id, envelope_id, callback=callback_function) 14215 14216 :param callback function: The callback function 14217 for asynchronous request. (optional) 14218 :param str account_id: The external account number (int) or account ID Guid. (required) 14219 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14220 :param DocumentVisibilityList document_visibility_list: 14221 :return: DocumentVisibilityList 14222 If the method is called asynchronously, 14223 returns the request thread. 14224 """ 14225 kwargs['_return_http_data_only'] = True 14226 if kwargs.get('callback'): 14227 return self.update_recipients_document_visibility_with_http_info(account_id, envelope_id, **kwargs) 14228 else: 14229 (data) = self.update_recipients_document_visibility_with_http_info(account_id, envelope_id, **kwargs) 14230 return data
Updates document visibility for the recipients
This method updates document visibility for one or more recipients based on the recipientId and visible values that you include in the request body. Note: A document cannot be hidden from a recipient if the recipient has tabs assigned to them on the document. Carbon Copy, Certified Delivery (Needs to Sign), Editor, and Agent recipients can always see all documents.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_recipients_document_visibility(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- DocumentVisibilityList document_visibility_list:
Returns
DocumentVisibilityList If the method is called asynchronously, returns the request thread.
def
update_recipients_document_visibility_with_http_info(self, account_id, envelope_id, **kwargs)
14232 def update_recipients_document_visibility_with_http_info(self, account_id, envelope_id, **kwargs): 14233 """ 14234 Updates document visibility for the recipients 14235 This method updates document visibility for one or more recipients based on the `recipientId` and `visible` values that you include in the request body. **Note:** A document cannot be hidden from a recipient if the recipient has tabs assigned to them on the document. Carbon Copy, Certified Delivery (Needs to Sign), Editor, and Agent recipients can always see all documents. 14236 This method makes a synchronous HTTP request by default. To make an 14237 asynchronous HTTP request, please define a `callback` function 14238 to be invoked when receiving the response. 14239 >>> def callback_function(response): 14240 >>> pprint(response) 14241 >>> 14242 >>> thread = api.update_recipients_document_visibility_with_http_info(account_id, envelope_id, callback=callback_function) 14243 14244 :param callback function: The callback function 14245 for asynchronous request. (optional) 14246 :param str account_id: The external account number (int) or account ID Guid. (required) 14247 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14248 :param DocumentVisibilityList document_visibility_list: 14249 :return: DocumentVisibilityList 14250 If the method is called asynchronously, 14251 returns the request thread. 14252 """ 14253 14254 all_params = ['account_id', 'envelope_id', 'document_visibility_list'] 14255 all_params.append('callback') 14256 all_params.append('_return_http_data_only') 14257 all_params.append('_preload_content') 14258 all_params.append('_request_timeout') 14259 14260 params = locals() 14261 for key, val in iteritems(params['kwargs']): 14262 if key not in all_params: 14263 raise TypeError( 14264 "Got an unexpected keyword argument '%s'" 14265 " to method update_recipients_document_visibility" % key 14266 ) 14267 params[key] = val 14268 del params['kwargs'] 14269 # verify the required parameter 'account_id' is set 14270 if ('account_id' not in params) or (params['account_id'] is None): 14271 raise ValueError("Missing the required parameter `account_id` when calling `update_recipients_document_visibility`") 14272 # verify the required parameter 'envelope_id' is set 14273 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14274 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipients_document_visibility`") 14275 14276 14277 collection_formats = {} 14278 14279 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/document_visibility'.replace('{format}', 'json') 14280 path_params = {} 14281 if 'account_id' in params: 14282 path_params['accountId'] = params['account_id'] 14283 if 'envelope_id' in params: 14284 path_params['envelopeId'] = params['envelope_id'] 14285 14286 query_params = {} 14287 14288 header_params = {} 14289 14290 form_params = [] 14291 local_var_files = {} 14292 14293 body_params = None 14294 if 'document_visibility_list' in params: 14295 body_params = params['document_visibility_list'] 14296 # HTTP header `Accept` 14297 header_params['Accept'] = self.api_client.\ 14298 select_header_accept(['application/json']) 14299 14300 # Authentication setting 14301 auth_settings = [] 14302 14303 return self.api_client.call_api(resource_path, 'PUT', 14304 path_params, 14305 query_params, 14306 header_params, 14307 body=body_params, 14308 post_params=form_params, 14309 files=local_var_files, 14310 response_type='DocumentVisibilityList', 14311 auth_settings=auth_settings, 14312 callback=params.get('callback'), 14313 _return_http_data_only=params.get('_return_http_data_only'), 14314 _preload_content=params.get('_preload_content', True), 14315 _request_timeout=params.get('_request_timeout'), 14316 collection_formats=collection_formats)
Updates document visibility for the recipients
This method updates document visibility for one or more recipients based on the recipientId and visible values that you include in the request body. Note: A document cannot be hidden from a recipient if the recipient has tabs assigned to them on the document. Carbon Copy, Certified Delivery (Needs to Sign), Editor, and Agent recipients can always see all documents.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_recipients_document_visibility_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- DocumentVisibilityList document_visibility_list:
Returns
DocumentVisibilityList If the method is called asynchronously, returns the request thread.
def
update_tabs(self, account_id, envelope_id, recipient_id, **kwargs)
14318 def update_tabs(self, account_id, envelope_id, recipient_id, **kwargs): 14319 """ 14320 Updates the tabs for a recipient. 14321 Updates one or more tabs for a recipient in a draft envelope. 14322 This method makes a synchronous HTTP request by default. To make an 14323 asynchronous HTTP request, please define a `callback` function 14324 to be invoked when receiving the response. 14325 >>> def callback_function(response): 14326 >>> pprint(response) 14327 >>> 14328 >>> thread = api.update_tabs(account_id, envelope_id, recipient_id, callback=callback_function) 14329 14330 :param callback function: The callback function 14331 for asynchronous request. (optional) 14332 :param str account_id: The external account number (int) or account ID Guid. (required) 14333 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14334 :param str recipient_id: The ID of the recipient being accessed. (required) 14335 :param Tabs tabs: 14336 :return: Tabs 14337 If the method is called asynchronously, 14338 returns the request thread. 14339 """ 14340 kwargs['_return_http_data_only'] = True 14341 if kwargs.get('callback'): 14342 return self.update_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 14343 else: 14344 (data) = self.update_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 14345 return data
Updates the tabs for a recipient.
Updates one or more tabs for a recipient in a draft envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_tabs(account_id, envelope_id, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
- Tabs tabs:
Returns
Tabs If the method is called asynchronously, returns the request thread.
def
update_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs)
14347 def update_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 14348 """ 14349 Updates the tabs for a recipient. 14350 Updates one or more tabs for a recipient in a draft envelope. 14351 This method makes a synchronous HTTP request by default. To make an 14352 asynchronous HTTP request, please define a `callback` function 14353 to be invoked when receiving the response. 14354 >>> def callback_function(response): 14355 >>> pprint(response) 14356 >>> 14357 >>> thread = api.update_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 14358 14359 :param callback function: The callback function 14360 for asynchronous request. (optional) 14361 :param str account_id: The external account number (int) or account ID Guid. (required) 14362 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14363 :param str recipient_id: The ID of the recipient being accessed. (required) 14364 :param Tabs tabs: 14365 :return: Tabs 14366 If the method is called asynchronously, 14367 returns the request thread. 14368 """ 14369 14370 all_params = ['account_id', 'envelope_id', 'recipient_id', 'tabs'] 14371 all_params.append('callback') 14372 all_params.append('_return_http_data_only') 14373 all_params.append('_preload_content') 14374 all_params.append('_request_timeout') 14375 14376 params = locals() 14377 for key, val in iteritems(params['kwargs']): 14378 if key not in all_params: 14379 raise TypeError( 14380 "Got an unexpected keyword argument '%s'" 14381 " to method update_tabs" % key 14382 ) 14383 params[key] = val 14384 del params['kwargs'] 14385 # verify the required parameter 'account_id' is set 14386 if ('account_id' not in params) or (params['account_id'] is None): 14387 raise ValueError("Missing the required parameter `account_id` when calling `update_tabs`") 14388 # verify the required parameter 'envelope_id' is set 14389 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14390 raise ValueError("Missing the required parameter `envelope_id` when calling `update_tabs`") 14391 # verify the required parameter 'recipient_id' is set 14392 if ('recipient_id' not in params) or (params['recipient_id'] is None): 14393 raise ValueError("Missing the required parameter `recipient_id` when calling `update_tabs`") 14394 14395 14396 collection_formats = {} 14397 14398 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/tabs'.replace('{format}', 'json') 14399 path_params = {} 14400 if 'account_id' in params: 14401 path_params['accountId'] = params['account_id'] 14402 if 'envelope_id' in params: 14403 path_params['envelopeId'] = params['envelope_id'] 14404 if 'recipient_id' in params: 14405 path_params['recipientId'] = params['recipient_id'] 14406 14407 query_params = {} 14408 14409 header_params = {} 14410 14411 form_params = [] 14412 local_var_files = {} 14413 14414 body_params = None 14415 if 'tabs' in params: 14416 body_params = params['tabs'] 14417 # HTTP header `Accept` 14418 header_params['Accept'] = self.api_client.\ 14419 select_header_accept(['application/json']) 14420 14421 # Authentication setting 14422 auth_settings = [] 14423 14424 return self.api_client.call_api(resource_path, 'PUT', 14425 path_params, 14426 query_params, 14427 header_params, 14428 body=body_params, 14429 post_params=form_params, 14430 files=local_var_files, 14431 response_type='Tabs', 14432 auth_settings=auth_settings, 14433 callback=params.get('callback'), 14434 _return_http_data_only=params.get('_return_http_data_only'), 14435 _preload_content=params.get('_preload_content', True), 14436 _request_timeout=params.get('_request_timeout'), 14437 collection_formats=collection_formats)
Updates the tabs for a recipient.
Updates one or more tabs for a recipient in a draft envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
- Tabs tabs:
Returns
Tabs If the method is called asynchronously, returns the request thread.
def
update_tabs_blob(self, account_id, envelope_id, **kwargs)
14439 def update_tabs_blob(self, account_id, envelope_id, **kwargs): 14440 """ 14441 Update encrypted tabs for envelope. 14442 14443 This method makes a synchronous HTTP request by default. To make an 14444 asynchronous HTTP request, please define a `callback` function 14445 to be invoked when receiving the response. 14446 >>> def callback_function(response): 14447 >>> pprint(response) 14448 >>> 14449 >>> thread = api.update_tabs_blob(account_id, envelope_id, callback=callback_function) 14450 14451 :param callback function: The callback function 14452 for asynchronous request. (optional) 14453 :param str account_id: The external account number (int) or account ID Guid. (required) 14454 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14455 :return: None 14456 If the method is called asynchronously, 14457 returns the request thread. 14458 """ 14459 kwargs['_return_http_data_only'] = True 14460 if kwargs.get('callback'): 14461 return self.update_tabs_blob_with_http_info(account_id, envelope_id, **kwargs) 14462 else: 14463 (data) = self.update_tabs_blob_with_http_info(account_id, envelope_id, **kwargs) 14464 return data
Update encrypted tabs for envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_tabs_blob(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
update_tabs_blob_with_http_info(self, account_id, envelope_id, **kwargs)
14466 def update_tabs_blob_with_http_info(self, account_id, envelope_id, **kwargs): 14467 """ 14468 Update encrypted tabs for envelope. 14469 14470 This method makes a synchronous HTTP request by default. To make an 14471 asynchronous HTTP request, please define a `callback` function 14472 to be invoked when receiving the response. 14473 >>> def callback_function(response): 14474 >>> pprint(response) 14475 >>> 14476 >>> thread = api.update_tabs_blob_with_http_info(account_id, envelope_id, callback=callback_function) 14477 14478 :param callback function: The callback function 14479 for asynchronous request. (optional) 14480 :param str account_id: The external account number (int) or account ID Guid. (required) 14481 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14482 :return: None 14483 If the method is called asynchronously, 14484 returns the request thread. 14485 """ 14486 14487 all_params = ['account_id', 'envelope_id'] 14488 all_params.append('callback') 14489 all_params.append('_return_http_data_only') 14490 all_params.append('_preload_content') 14491 all_params.append('_request_timeout') 14492 14493 params = locals() 14494 for key, val in iteritems(params['kwargs']): 14495 if key not in all_params: 14496 raise TypeError( 14497 "Got an unexpected keyword argument '%s'" 14498 " to method update_tabs_blob" % key 14499 ) 14500 params[key] = val 14501 del params['kwargs'] 14502 # verify the required parameter 'account_id' is set 14503 if ('account_id' not in params) or (params['account_id'] is None): 14504 raise ValueError("Missing the required parameter `account_id` when calling `update_tabs_blob`") 14505 # verify the required parameter 'envelope_id' is set 14506 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14507 raise ValueError("Missing the required parameter `envelope_id` when calling `update_tabs_blob`") 14508 14509 14510 collection_formats = {} 14511 14512 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/tabs_blob'.replace('{format}', 'json') 14513 path_params = {} 14514 if 'account_id' in params: 14515 path_params['accountId'] = params['account_id'] 14516 if 'envelope_id' in params: 14517 path_params['envelopeId'] = params['envelope_id'] 14518 14519 query_params = {} 14520 14521 header_params = {} 14522 14523 form_params = [] 14524 local_var_files = {} 14525 14526 body_params = None 14527 # HTTP header `Accept` 14528 header_params['Accept'] = self.api_client.\ 14529 select_header_accept(['application/json']) 14530 14531 # Authentication setting 14532 auth_settings = [] 14533 14534 return self.api_client.call_api(resource_path, 'PUT', 14535 path_params, 14536 query_params, 14537 header_params, 14538 body=body_params, 14539 post_params=form_params, 14540 files=local_var_files, 14541 response_type=None, 14542 auth_settings=auth_settings, 14543 callback=params.get('callback'), 14544 _return_http_data_only=params.get('_return_http_data_only'), 14545 _preload_content=params.get('_preload_content', True), 14546 _request_timeout=params.get('_request_timeout'), 14547 collection_formats=collection_formats)
Update encrypted tabs for envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_tabs_blob_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
update_template_delayed_routing_definition(self, account_id, template_id, workflow_step_id, **kwargs)
14549 def update_template_delayed_routing_definition(self, account_id, template_id, workflow_step_id, **kwargs): 14550 """ 14551 Updates the delayed routing rules for a template's workflow step definition. 14552 This method makes a synchronous HTTP request by default. To make an 14553 asynchronous HTTP request, please define a `callback` function 14554 to be invoked when receiving the response. 14555 >>> def callback_function(response): 14556 >>> pprint(response) 14557 >>> 14558 >>> thread = api.update_template_delayed_routing_definition(account_id, template_id, workflow_step_id, callback=callback_function) 14559 14560 :param callback function: The callback function 14561 for asynchronous request. (optional) 14562 :param str account_id: The external account number (int) or account ID Guid. (required) 14563 :param str template_id: The ID of the template being accessed. (required) 14564 :param str workflow_step_id: (required) 14565 :param DelayedRouting delayed_routing: 14566 :return: DelayedRouting 14567 If the method is called asynchronously, 14568 returns the request thread. 14569 """ 14570 kwargs['_return_http_data_only'] = True 14571 if kwargs.get('callback'): 14572 return self.update_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 14573 else: 14574 (data) = self.update_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 14575 return data
Updates the delayed routing rules for a template's workflow step definition.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_template_delayed_routing_definition(account_id, template_id, workflow_step_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str template_id: The ID of the template being accessed. (required)
- str workflow_step_id: (required)
- DelayedRouting delayed_routing:
Returns
DelayedRouting If the method is called asynchronously, returns the request thread.
def
update_template_delayed_routing_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs)
14577 def update_template_delayed_routing_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 14578 """ 14579 Updates the delayed routing rules for a template's workflow step definition. 14580 This method makes a synchronous HTTP request by default. To make an 14581 asynchronous HTTP request, please define a `callback` function 14582 to be invoked when receiving the response. 14583 >>> def callback_function(response): 14584 >>> pprint(response) 14585 >>> 14586 >>> thread = api.update_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 14587 14588 :param callback function: The callback function 14589 for asynchronous request. (optional) 14590 :param str account_id: The external account number (int) or account ID Guid. (required) 14591 :param str template_id: The ID of the template being accessed. (required) 14592 :param str workflow_step_id: (required) 14593 :param DelayedRouting delayed_routing: 14594 :return: DelayedRouting 14595 If the method is called asynchronously, 14596 returns the request thread. 14597 """ 14598 14599 all_params = ['account_id', 'template_id', 'workflow_step_id', 'delayed_routing'] 14600 all_params.append('callback') 14601 all_params.append('_return_http_data_only') 14602 all_params.append('_preload_content') 14603 all_params.append('_request_timeout') 14604 14605 params = locals() 14606 for key, val in iteritems(params['kwargs']): 14607 if key not in all_params: 14608 raise TypeError( 14609 "Got an unexpected keyword argument '%s'" 14610 " to method update_template_delayed_routing_definition" % key 14611 ) 14612 params[key] = val 14613 del params['kwargs'] 14614 # verify the required parameter 'account_id' is set 14615 if ('account_id' not in params) or (params['account_id'] is None): 14616 raise ValueError("Missing the required parameter `account_id` when calling `update_template_delayed_routing_definition`") 14617 # verify the required parameter 'template_id' is set 14618 if ('template_id' not in params) or (params['template_id'] is None): 14619 raise ValueError("Missing the required parameter `template_id` when calling `update_template_delayed_routing_definition`") 14620 # verify the required parameter 'workflow_step_id' is set 14621 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 14622 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_template_delayed_routing_definition`") 14623 14624 14625 collection_formats = {} 14626 14627 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 14628 path_params = {} 14629 if 'account_id' in params: 14630 path_params['accountId'] = params['account_id'] 14631 if 'template_id' in params: 14632 path_params['templateId'] = params['template_id'] 14633 if 'workflow_step_id' in params: 14634 path_params['workflowStepId'] = params['workflow_step_id'] 14635 14636 query_params = {} 14637 14638 header_params = {} 14639 14640 form_params = [] 14641 local_var_files = {} 14642 14643 body_params = None 14644 if 'delayed_routing' in params: 14645 body_params = params['delayed_routing'] 14646 # HTTP header `Accept` 14647 header_params['Accept'] = self.api_client.\ 14648 select_header_accept(['application/json']) 14649 14650 # Authentication setting 14651 auth_settings = [] 14652 14653 return self.api_client.call_api(resource_path, 'PUT', 14654 path_params, 14655 query_params, 14656 header_params, 14657 body=body_params, 14658 post_params=form_params, 14659 files=local_var_files, 14660 response_type='DelayedRouting', 14661 auth_settings=auth_settings, 14662 callback=params.get('callback'), 14663 _return_http_data_only=params.get('_return_http_data_only'), 14664 _preload_content=params.get('_preload_content', True), 14665 _request_timeout=params.get('_request_timeout'), 14666 collection_formats=collection_formats)
Updates the delayed routing rules for a template's workflow step definition.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str template_id: The ID of the template being accessed. (required)
- str workflow_step_id: (required)
- DelayedRouting delayed_routing:
Returns
DelayedRouting If the method is called asynchronously, returns the request thread.
def
update_template_recipient_document_visibility(self, account_id, recipient_id, template_id, **kwargs)
14668 def update_template_recipient_document_visibility(self, account_id, recipient_id, template_id, **kwargs): 14669 """ 14670 Updates document visibility for the recipients 14671 This method updates the document visibility for a template recipient. **Note:** A document cannot be hidden from a recipient if the recipient has tabs assigned to them on the document. Carbon Copy, Certified Delivery (Needs to Sign), Editor, and Agent recipients can always see all documents. 14672 This method makes a synchronous HTTP request by default. To make an 14673 asynchronous HTTP request, please define a `callback` function 14674 to be invoked when receiving the response. 14675 >>> def callback_function(response): 14676 >>> pprint(response) 14677 >>> 14678 >>> thread = api.update_template_recipient_document_visibility(account_id, recipient_id, template_id, callback=callback_function) 14679 14680 :param callback function: The callback function 14681 for asynchronous request. (optional) 14682 :param str account_id: The external account number (int) or account ID Guid. (required) 14683 :param str recipient_id: The ID of the recipient being accessed. (required) 14684 :param str template_id: The ID of the template being accessed. (required) 14685 :param TemplateDocumentVisibilityList template_document_visibility_list: 14686 :return: TemplateDocumentVisibilityList 14687 If the method is called asynchronously, 14688 returns the request thread. 14689 """ 14690 kwargs['_return_http_data_only'] = True 14691 if kwargs.get('callback'): 14692 return self.update_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, **kwargs) 14693 else: 14694 (data) = self.update_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, **kwargs) 14695 return data
Updates document visibility for the recipients
This method updates the document visibility for a template recipient. Note: A document cannot be hidden from a recipient if the recipient has tabs assigned to them on the document. Carbon Copy, Certified Delivery (Needs to Sign), Editor, and Agent recipients can always see all documents.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_template_recipient_document_visibility(account_id, recipient_id, template_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
- str template_id: The ID of the template being accessed. (required)
- TemplateDocumentVisibilityList template_document_visibility_list:
Returns
TemplateDocumentVisibilityList If the method is called asynchronously, returns the request thread.
def
update_template_recipient_document_visibility_with_http_info(self, account_id, recipient_id, template_id, **kwargs)
14697 def update_template_recipient_document_visibility_with_http_info(self, account_id, recipient_id, template_id, **kwargs): 14698 """ 14699 Updates document visibility for the recipients 14700 This method updates the document visibility for a template recipient. **Note:** A document cannot be hidden from a recipient if the recipient has tabs assigned to them on the document. Carbon Copy, Certified Delivery (Needs to Sign), Editor, and Agent recipients can always see all documents. 14701 This method makes a synchronous HTTP request by default. To make an 14702 asynchronous HTTP request, please define a `callback` function 14703 to be invoked when receiving the response. 14704 >>> def callback_function(response): 14705 >>> pprint(response) 14706 >>> 14707 >>> thread = api.update_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, callback=callback_function) 14708 14709 :param callback function: The callback function 14710 for asynchronous request. (optional) 14711 :param str account_id: The external account number (int) or account ID Guid. (required) 14712 :param str recipient_id: The ID of the recipient being accessed. (required) 14713 :param str template_id: The ID of the template being accessed. (required) 14714 :param TemplateDocumentVisibilityList template_document_visibility_list: 14715 :return: TemplateDocumentVisibilityList 14716 If the method is called asynchronously, 14717 returns the request thread. 14718 """ 14719 14720 all_params = ['account_id', 'recipient_id', 'template_id', 'template_document_visibility_list'] 14721 all_params.append('callback') 14722 all_params.append('_return_http_data_only') 14723 all_params.append('_preload_content') 14724 all_params.append('_request_timeout') 14725 14726 params = locals() 14727 for key, val in iteritems(params['kwargs']): 14728 if key not in all_params: 14729 raise TypeError( 14730 "Got an unexpected keyword argument '%s'" 14731 " to method update_template_recipient_document_visibility" % key 14732 ) 14733 params[key] = val 14734 del params['kwargs'] 14735 # verify the required parameter 'account_id' is set 14736 if ('account_id' not in params) or (params['account_id'] is None): 14737 raise ValueError("Missing the required parameter `account_id` when calling `update_template_recipient_document_visibility`") 14738 # verify the required parameter 'recipient_id' is set 14739 if ('recipient_id' not in params) or (params['recipient_id'] is None): 14740 raise ValueError("Missing the required parameter `recipient_id` when calling `update_template_recipient_document_visibility`") 14741 # verify the required parameter 'template_id' is set 14742 if ('template_id' not in params) or (params['template_id'] is None): 14743 raise ValueError("Missing the required parameter `template_id` when calling `update_template_recipient_document_visibility`") 14744 14745 14746 collection_formats = {} 14747 14748 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/recipients/{recipientId}/document_visibility'.replace('{format}', 'json') 14749 path_params = {} 14750 if 'account_id' in params: 14751 path_params['accountId'] = params['account_id'] 14752 if 'recipient_id' in params: 14753 path_params['recipientId'] = params['recipient_id'] 14754 if 'template_id' in params: 14755 path_params['templateId'] = params['template_id'] 14756 14757 query_params = {} 14758 14759 header_params = {} 14760 14761 form_params = [] 14762 local_var_files = {} 14763 14764 body_params = None 14765 if 'template_document_visibility_list' in params: 14766 body_params = params['template_document_visibility_list'] 14767 # HTTP header `Accept` 14768 header_params['Accept'] = self.api_client.\ 14769 select_header_accept(['application/json']) 14770 14771 # Authentication setting 14772 auth_settings = [] 14773 14774 return self.api_client.call_api(resource_path, 'PUT', 14775 path_params, 14776 query_params, 14777 header_params, 14778 body=body_params, 14779 post_params=form_params, 14780 files=local_var_files, 14781 response_type='TemplateDocumentVisibilityList', 14782 auth_settings=auth_settings, 14783 callback=params.get('callback'), 14784 _return_http_data_only=params.get('_return_http_data_only'), 14785 _preload_content=params.get('_preload_content', True), 14786 _request_timeout=params.get('_request_timeout'), 14787 collection_formats=collection_formats)
Updates document visibility for the recipients
This method updates the document visibility for a template recipient. Note: A document cannot be hidden from a recipient if the recipient has tabs assigned to them on the document. Carbon Copy, Certified Delivery (Needs to Sign), Editor, and Agent recipients can always see all documents.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str recipient_id: The ID of the recipient being accessed. (required)
- str template_id: The ID of the template being accessed. (required)
- TemplateDocumentVisibilityList template_document_visibility_list:
Returns
TemplateDocumentVisibilityList If the method is called asynchronously, returns the request thread.
def
update_template_recipients_document_visibility(self, account_id, template_id, **kwargs)
14789 def update_template_recipients_document_visibility(self, account_id, template_id, **kwargs): 14790 """ 14791 Updates document visibility for the recipients 14792 This method updates document visibility for one or more template recipients based on the `recipientId` and `visible` values that you include in the request body. **Note:** A document cannot be hidden from a recipient if the recipient has tabs assigned to them on the document. Carbon Copy, Certified Delivery (Needs to Sign), Editor, and Agent recipients can always see all documents. 14793 This method makes a synchronous HTTP request by default. To make an 14794 asynchronous HTTP request, please define a `callback` function 14795 to be invoked when receiving the response. 14796 >>> def callback_function(response): 14797 >>> pprint(response) 14798 >>> 14799 >>> thread = api.update_template_recipients_document_visibility(account_id, template_id, callback=callback_function) 14800 14801 :param callback function: The callback function 14802 for asynchronous request. (optional) 14803 :param str account_id: The external account number (int) or account ID Guid. (required) 14804 :param str template_id: The ID of the template being accessed. (required) 14805 :param TemplateDocumentVisibilityList template_document_visibility_list: 14806 :return: TemplateDocumentVisibilityList 14807 If the method is called asynchronously, 14808 returns the request thread. 14809 """ 14810 kwargs['_return_http_data_only'] = True 14811 if kwargs.get('callback'): 14812 return self.update_template_recipients_document_visibility_with_http_info(account_id, template_id, **kwargs) 14813 else: 14814 (data) = self.update_template_recipients_document_visibility_with_http_info(account_id, template_id, **kwargs) 14815 return data
Updates document visibility for the recipients
This method updates document visibility for one or more template recipients based on the recipientId and visible values that you include in the request body. Note: A document cannot be hidden from a recipient if the recipient has tabs assigned to them on the document. Carbon Copy, Certified Delivery (Needs to Sign), Editor, and Agent recipients can always see all documents.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_template_recipients_document_visibility(account_id, template_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str template_id: The ID of the template being accessed. (required)
- TemplateDocumentVisibilityList template_document_visibility_list:
Returns
TemplateDocumentVisibilityList If the method is called asynchronously, returns the request thread.
def
update_template_recipients_document_visibility_with_http_info(self, account_id, template_id, **kwargs)
14817 def update_template_recipients_document_visibility_with_http_info(self, account_id, template_id, **kwargs): 14818 """ 14819 Updates document visibility for the recipients 14820 This method updates document visibility for one or more template recipients based on the `recipientId` and `visible` values that you include in the request body. **Note:** A document cannot be hidden from a recipient if the recipient has tabs assigned to them on the document. Carbon Copy, Certified Delivery (Needs to Sign), Editor, and Agent recipients can always see all documents. 14821 This method makes a synchronous HTTP request by default. To make an 14822 asynchronous HTTP request, please define a `callback` function 14823 to be invoked when receiving the response. 14824 >>> def callback_function(response): 14825 >>> pprint(response) 14826 >>> 14827 >>> thread = api.update_template_recipients_document_visibility_with_http_info(account_id, template_id, callback=callback_function) 14828 14829 :param callback function: The callback function 14830 for asynchronous request. (optional) 14831 :param str account_id: The external account number (int) or account ID Guid. (required) 14832 :param str template_id: The ID of the template being accessed. (required) 14833 :param TemplateDocumentVisibilityList template_document_visibility_list: 14834 :return: TemplateDocumentVisibilityList 14835 If the method is called asynchronously, 14836 returns the request thread. 14837 """ 14838 14839 all_params = ['account_id', 'template_id', 'template_document_visibility_list'] 14840 all_params.append('callback') 14841 all_params.append('_return_http_data_only') 14842 all_params.append('_preload_content') 14843 all_params.append('_request_timeout') 14844 14845 params = locals() 14846 for key, val in iteritems(params['kwargs']): 14847 if key not in all_params: 14848 raise TypeError( 14849 "Got an unexpected keyword argument '%s'" 14850 " to method update_template_recipients_document_visibility" % key 14851 ) 14852 params[key] = val 14853 del params['kwargs'] 14854 # verify the required parameter 'account_id' is set 14855 if ('account_id' not in params) or (params['account_id'] is None): 14856 raise ValueError("Missing the required parameter `account_id` when calling `update_template_recipients_document_visibility`") 14857 # verify the required parameter 'template_id' is set 14858 if ('template_id' not in params) or (params['template_id'] is None): 14859 raise ValueError("Missing the required parameter `template_id` when calling `update_template_recipients_document_visibility`") 14860 14861 14862 collection_formats = {} 14863 14864 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/recipients/document_visibility'.replace('{format}', 'json') 14865 path_params = {} 14866 if 'account_id' in params: 14867 path_params['accountId'] = params['account_id'] 14868 if 'template_id' in params: 14869 path_params['templateId'] = params['template_id'] 14870 14871 query_params = {} 14872 14873 header_params = {} 14874 14875 form_params = [] 14876 local_var_files = {} 14877 14878 body_params = None 14879 if 'template_document_visibility_list' in params: 14880 body_params = params['template_document_visibility_list'] 14881 # HTTP header `Accept` 14882 header_params['Accept'] = self.api_client.\ 14883 select_header_accept(['application/json']) 14884 14885 # Authentication setting 14886 auth_settings = [] 14887 14888 return self.api_client.call_api(resource_path, 'PUT', 14889 path_params, 14890 query_params, 14891 header_params, 14892 body=body_params, 14893 post_params=form_params, 14894 files=local_var_files, 14895 response_type='TemplateDocumentVisibilityList', 14896 auth_settings=auth_settings, 14897 callback=params.get('callback'), 14898 _return_http_data_only=params.get('_return_http_data_only'), 14899 _preload_content=params.get('_preload_content', True), 14900 _request_timeout=params.get('_request_timeout'), 14901 collection_formats=collection_formats)
Updates document visibility for the recipients
This method updates document visibility for one or more template recipients based on the recipientId and visible values that you include in the request body. Note: A document cannot be hidden from a recipient if the recipient has tabs assigned to them on the document. Carbon Copy, Certified Delivery (Needs to Sign), Editor, and Agent recipients can always see all documents.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_template_recipients_document_visibility_with_http_info(account_id, template_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str template_id: The ID of the template being accessed. (required)
- TemplateDocumentVisibilityList template_document_visibility_list:
Returns
TemplateDocumentVisibilityList If the method is called asynchronously, returns the request thread.
def
update_template_scheduled_sending_definition(self, account_id, template_id, **kwargs)
14903 def update_template_scheduled_sending_definition(self, account_id, template_id, **kwargs): 14904 """ 14905 Updates the scheduled sending rules for a template's workflow definition. 14906 This method makes a synchronous HTTP request by default. To make an 14907 asynchronous HTTP request, please define a `callback` function 14908 to be invoked when receiving the response. 14909 >>> def callback_function(response): 14910 >>> pprint(response) 14911 >>> 14912 >>> thread = api.update_template_scheduled_sending_definition(account_id, template_id, callback=callback_function) 14913 14914 :param callback function: The callback function 14915 for asynchronous request. (optional) 14916 :param str account_id: The external account number (int) or account ID Guid. (required) 14917 :param str template_id: The ID of the template being accessed. (required) 14918 :param ScheduledSending scheduled_sending: 14919 :return: ScheduledSending 14920 If the method is called asynchronously, 14921 returns the request thread. 14922 """ 14923 kwargs['_return_http_data_only'] = True 14924 if kwargs.get('callback'): 14925 return self.update_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 14926 else: 14927 (data) = self.update_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 14928 return data
Updates the scheduled sending rules for a template's workflow definition.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_template_scheduled_sending_definition(account_id, template_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str template_id: The ID of the template being accessed. (required)
- ScheduledSending scheduled_sending:
Returns
ScheduledSending If the method is called asynchronously, returns the request thread.
def
update_template_scheduled_sending_definition_with_http_info(self, account_id, template_id, **kwargs)
14930 def update_template_scheduled_sending_definition_with_http_info(self, account_id, template_id, **kwargs): 14931 """ 14932 Updates the scheduled sending rules for a template's workflow definition. 14933 This method makes a synchronous HTTP request by default. To make an 14934 asynchronous HTTP request, please define a `callback` function 14935 to be invoked when receiving the response. 14936 >>> def callback_function(response): 14937 >>> pprint(response) 14938 >>> 14939 >>> thread = api.update_template_scheduled_sending_definition_with_http_info(account_id, template_id, callback=callback_function) 14940 14941 :param callback function: The callback function 14942 for asynchronous request. (optional) 14943 :param str account_id: The external account number (int) or account ID Guid. (required) 14944 :param str template_id: The ID of the template being accessed. (required) 14945 :param ScheduledSending scheduled_sending: 14946 :return: ScheduledSending 14947 If the method is called asynchronously, 14948 returns the request thread. 14949 """ 14950 14951 all_params = ['account_id', 'template_id', 'scheduled_sending'] 14952 all_params.append('callback') 14953 all_params.append('_return_http_data_only') 14954 all_params.append('_preload_content') 14955 all_params.append('_request_timeout') 14956 14957 params = locals() 14958 for key, val in iteritems(params['kwargs']): 14959 if key not in all_params: 14960 raise TypeError( 14961 "Got an unexpected keyword argument '%s'" 14962 " to method update_template_scheduled_sending_definition" % key 14963 ) 14964 params[key] = val 14965 del params['kwargs'] 14966 # verify the required parameter 'account_id' is set 14967 if ('account_id' not in params) or (params['account_id'] is None): 14968 raise ValueError("Missing the required parameter `account_id` when calling `update_template_scheduled_sending_definition`") 14969 # verify the required parameter 'template_id' is set 14970 if ('template_id' not in params) or (params['template_id'] is None): 14971 raise ValueError("Missing the required parameter `template_id` when calling `update_template_scheduled_sending_definition`") 14972 14973 14974 collection_formats = {} 14975 14976 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/scheduledSending'.replace('{format}', 'json') 14977 path_params = {} 14978 if 'account_id' in params: 14979 path_params['accountId'] = params['account_id'] 14980 if 'template_id' in params: 14981 path_params['templateId'] = params['template_id'] 14982 14983 query_params = {} 14984 14985 header_params = {} 14986 14987 form_params = [] 14988 local_var_files = {} 14989 14990 body_params = None 14991 if 'scheduled_sending' in params: 14992 body_params = params['scheduled_sending'] 14993 # HTTP header `Accept` 14994 header_params['Accept'] = self.api_client.\ 14995 select_header_accept(['application/json']) 14996 14997 # Authentication setting 14998 auth_settings = [] 14999 15000 return self.api_client.call_api(resource_path, 'PUT', 15001 path_params, 15002 query_params, 15003 header_params, 15004 body=body_params, 15005 post_params=form_params, 15006 files=local_var_files, 15007 response_type='ScheduledSending', 15008 auth_settings=auth_settings, 15009 callback=params.get('callback'), 15010 _return_http_data_only=params.get('_return_http_data_only'), 15011 _preload_content=params.get('_preload_content', True), 15012 _request_timeout=params.get('_request_timeout'), 15013 collection_formats=collection_formats)
Updates the scheduled sending rules for a template's workflow definition.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_template_scheduled_sending_definition_with_http_info(account_id, template_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str template_id: The ID of the template being accessed. (required)
- ScheduledSending scheduled_sending:
Returns
ScheduledSending If the method is called asynchronously, returns the request thread.
def
update_template_workflow_definition(self, account_id, template_id, **kwargs)
15015 def update_template_workflow_definition(self, account_id, template_id, **kwargs): 15016 """ 15017 Updates the workflow definition for a template. 15018 Updates the specified template's workflow definition if it has one. 15019 This method makes a synchronous HTTP request by default. To make an 15020 asynchronous HTTP request, please define a `callback` function 15021 to be invoked when receiving the response. 15022 >>> def callback_function(response): 15023 >>> pprint(response) 15024 >>> 15025 >>> thread = api.update_template_workflow_definition(account_id, template_id, callback=callback_function) 15026 15027 :param callback function: The callback function 15028 for asynchronous request. (optional) 15029 :param str account_id: The external account number (int) or account ID Guid. (required) 15030 :param str template_id: The ID of the template being accessed. (required) 15031 :param Workflow workflow: 15032 :return: Workflow 15033 If the method is called asynchronously, 15034 returns the request thread. 15035 """ 15036 kwargs['_return_http_data_only'] = True 15037 if kwargs.get('callback'): 15038 return self.update_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 15039 else: 15040 (data) = self.update_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 15041 return data
Updates the workflow definition for a template.
Updates the specified template's workflow definition if it has one.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_template_workflow_definition(account_id, template_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str template_id: The ID of the template being accessed. (required)
- Workflow workflow:
Returns
Workflow If the method is called asynchronously, returns the request thread.
def
update_template_workflow_definition_with_http_info(self, account_id, template_id, **kwargs)
15043 def update_template_workflow_definition_with_http_info(self, account_id, template_id, **kwargs): 15044 """ 15045 Updates the workflow definition for a template. 15046 Updates the specified template's workflow definition if it has one. 15047 This method makes a synchronous HTTP request by default. To make an 15048 asynchronous HTTP request, please define a `callback` function 15049 to be invoked when receiving the response. 15050 >>> def callback_function(response): 15051 >>> pprint(response) 15052 >>> 15053 >>> thread = api.update_template_workflow_definition_with_http_info(account_id, template_id, callback=callback_function) 15054 15055 :param callback function: The callback function 15056 for asynchronous request. (optional) 15057 :param str account_id: The external account number (int) or account ID Guid. (required) 15058 :param str template_id: The ID of the template being accessed. (required) 15059 :param Workflow workflow: 15060 :return: Workflow 15061 If the method is called asynchronously, 15062 returns the request thread. 15063 """ 15064 15065 all_params = ['account_id', 'template_id', 'workflow'] 15066 all_params.append('callback') 15067 all_params.append('_return_http_data_only') 15068 all_params.append('_preload_content') 15069 all_params.append('_request_timeout') 15070 15071 params = locals() 15072 for key, val in iteritems(params['kwargs']): 15073 if key not in all_params: 15074 raise TypeError( 15075 "Got an unexpected keyword argument '%s'" 15076 " to method update_template_workflow_definition" % key 15077 ) 15078 params[key] = val 15079 del params['kwargs'] 15080 # verify the required parameter 'account_id' is set 15081 if ('account_id' not in params) or (params['account_id'] is None): 15082 raise ValueError("Missing the required parameter `account_id` when calling `update_template_workflow_definition`") 15083 # verify the required parameter 'template_id' is set 15084 if ('template_id' not in params) or (params['template_id'] is None): 15085 raise ValueError("Missing the required parameter `template_id` when calling `update_template_workflow_definition`") 15086 15087 15088 collection_formats = {} 15089 15090 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow'.replace('{format}', 'json') 15091 path_params = {} 15092 if 'account_id' in params: 15093 path_params['accountId'] = params['account_id'] 15094 if 'template_id' in params: 15095 path_params['templateId'] = params['template_id'] 15096 15097 query_params = {} 15098 15099 header_params = {} 15100 15101 form_params = [] 15102 local_var_files = {} 15103 15104 body_params = None 15105 if 'workflow' in params: 15106 body_params = params['workflow'] 15107 # HTTP header `Accept` 15108 header_params['Accept'] = self.api_client.\ 15109 select_header_accept(['application/json']) 15110 15111 # Authentication setting 15112 auth_settings = [] 15113 15114 return self.api_client.call_api(resource_path, 'PUT', 15115 path_params, 15116 query_params, 15117 header_params, 15118 body=body_params, 15119 post_params=form_params, 15120 files=local_var_files, 15121 response_type='Workflow', 15122 auth_settings=auth_settings, 15123 callback=params.get('callback'), 15124 _return_http_data_only=params.get('_return_http_data_only'), 15125 _preload_content=params.get('_preload_content', True), 15126 _request_timeout=params.get('_request_timeout'), 15127 collection_formats=collection_formats)
Updates the workflow definition for a template.
Updates the specified template's workflow definition if it has one.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_template_workflow_definition_with_http_info(account_id, template_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str template_id: The ID of the template being accessed. (required)
- Workflow workflow:
Returns
Workflow If the method is called asynchronously, returns the request thread.
def
update_template_workflow_step_definition(self, account_id, template_id, workflow_step_id, **kwargs)
15129 def update_template_workflow_step_definition(self, account_id, template_id, workflow_step_id, **kwargs): 15130 """ 15131 Updates the template workflow step definition for an envelope. 15132 This method makes a synchronous HTTP request by default. To make an 15133 asynchronous HTTP request, please define a `callback` function 15134 to be invoked when receiving the response. 15135 >>> def callback_function(response): 15136 >>> pprint(response) 15137 >>> 15138 >>> thread = api.update_template_workflow_step_definition(account_id, template_id, workflow_step_id, callback=callback_function) 15139 15140 :param callback function: The callback function 15141 for asynchronous request. (optional) 15142 :param str account_id: The external account number (int) or account ID Guid. (required) 15143 :param str template_id: The ID of the template being accessed. (required) 15144 :param str workflow_step_id: (required) 15145 :param WorkflowStep workflow_step: 15146 :return: WorkflowStep 15147 If the method is called asynchronously, 15148 returns the request thread. 15149 """ 15150 kwargs['_return_http_data_only'] = True 15151 if kwargs.get('callback'): 15152 return self.update_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 15153 else: 15154 (data) = self.update_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 15155 return data
Updates the template workflow step definition for an envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_template_workflow_step_definition(account_id, template_id, workflow_step_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str template_id: The ID of the template being accessed. (required)
- str workflow_step_id: (required)
- WorkflowStep workflow_step:
Returns
WorkflowStep If the method is called asynchronously, returns the request thread.
def
update_template_workflow_step_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs)
15157 def update_template_workflow_step_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 15158 """ 15159 Updates the template workflow step definition for an envelope. 15160 This method makes a synchronous HTTP request by default. To make an 15161 asynchronous HTTP request, please define a `callback` function 15162 to be invoked when receiving the response. 15163 >>> def callback_function(response): 15164 >>> pprint(response) 15165 >>> 15166 >>> thread = api.update_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 15167 15168 :param callback function: The callback function 15169 for asynchronous request. (optional) 15170 :param str account_id: The external account number (int) or account ID Guid. (required) 15171 :param str template_id: The ID of the template being accessed. (required) 15172 :param str workflow_step_id: (required) 15173 :param WorkflowStep workflow_step: 15174 :return: WorkflowStep 15175 If the method is called asynchronously, 15176 returns the request thread. 15177 """ 15178 15179 all_params = ['account_id', 'template_id', 'workflow_step_id', 'workflow_step'] 15180 all_params.append('callback') 15181 all_params.append('_return_http_data_only') 15182 all_params.append('_preload_content') 15183 all_params.append('_request_timeout') 15184 15185 params = locals() 15186 for key, val in iteritems(params['kwargs']): 15187 if key not in all_params: 15188 raise TypeError( 15189 "Got an unexpected keyword argument '%s'" 15190 " to method update_template_workflow_step_definition" % key 15191 ) 15192 params[key] = val 15193 del params['kwargs'] 15194 # verify the required parameter 'account_id' is set 15195 if ('account_id' not in params) or (params['account_id'] is None): 15196 raise ValueError("Missing the required parameter `account_id` when calling `update_template_workflow_step_definition`") 15197 # verify the required parameter 'template_id' is set 15198 if ('template_id' not in params) or (params['template_id'] is None): 15199 raise ValueError("Missing the required parameter `template_id` when calling `update_template_workflow_step_definition`") 15200 # verify the required parameter 'workflow_step_id' is set 15201 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 15202 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_template_workflow_step_definition`") 15203 15204 15205 collection_formats = {} 15206 15207 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 15208 path_params = {} 15209 if 'account_id' in params: 15210 path_params['accountId'] = params['account_id'] 15211 if 'template_id' in params: 15212 path_params['templateId'] = params['template_id'] 15213 if 'workflow_step_id' in params: 15214 path_params['workflowStepId'] = params['workflow_step_id'] 15215 15216 query_params = {} 15217 15218 header_params = {} 15219 15220 form_params = [] 15221 local_var_files = {} 15222 15223 body_params = None 15224 if 'workflow_step' in params: 15225 body_params = params['workflow_step'] 15226 # HTTP header `Accept` 15227 header_params['Accept'] = self.api_client.\ 15228 select_header_accept(['application/json']) 15229 15230 # Authentication setting 15231 auth_settings = [] 15232 15233 return self.api_client.call_api(resource_path, 'PUT', 15234 path_params, 15235 query_params, 15236 header_params, 15237 body=body_params, 15238 post_params=form_params, 15239 files=local_var_files, 15240 response_type='WorkflowStep', 15241 auth_settings=auth_settings, 15242 callback=params.get('callback'), 15243 _return_http_data_only=params.get('_return_http_data_only'), 15244 _preload_content=params.get('_preload_content', True), 15245 _request_timeout=params.get('_request_timeout'), 15246 collection_formats=collection_formats)
Updates the template workflow step definition for an envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str template_id: The ID of the template being accessed. (required)
- str workflow_step_id: (required)
- WorkflowStep workflow_step:
Returns
WorkflowStep If the method is called asynchronously, returns the request thread.