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 :param str locale: Locale setting for the response, e.g., 'en-US'. 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 :param str locale: Locale setting for the response, e.g., 'en-US'. 9951 :return: EnvelopeAuditEventResponse 9952 If the method is called asynchronously, 9953 returns the request thread. 9954 """ 9955 9956 all_params = ['account_id', 'envelope_id', 'locale'] 9957 all_params.append('callback') 9958 all_params.append('_return_http_data_only') 9959 all_params.append('_preload_content') 9960 all_params.append('_request_timeout') 9961 9962 params = locals() 9963 for key, val in iteritems(params['kwargs']): 9964 if key not in all_params: 9965 raise TypeError( 9966 "Got an unexpected keyword argument '%s'" 9967 " to method list_audit_events" % key 9968 ) 9969 params[key] = val 9970 del params['kwargs'] 9971 # verify the required parameter 'account_id' is set 9972 if ('account_id' not in params) or (params['account_id'] is None): 9973 raise ValueError("Missing the required parameter `account_id` when calling `list_audit_events`") 9974 # verify the required parameter 'envelope_id' is set 9975 if ('envelope_id' not in params) or (params['envelope_id'] is None): 9976 raise ValueError("Missing the required parameter `envelope_id` when calling `list_audit_events`") 9977 9978 9979 collection_formats = {} 9980 9981 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/audit_events'.replace('{format}', 'json') 9982 path_params = {} 9983 if 'account_id' in params: 9984 path_params['accountId'] = params['account_id'] 9985 if 'envelope_id' in params: 9986 path_params['envelopeId'] = params['envelope_id'] 9987 9988 query_params = {} 9989 if 'locale' in params: 9990 query_params['locale'] = params['locale'] 9991 9992 header_params = {} 9993 9994 form_params = [] 9995 local_var_files = {} 9996 9997 body_params = None 9998 # HTTP header `Accept` 9999 header_params['Accept'] = self.api_client.\ 10000 select_header_accept(['application/json']) 10001 10002 # Authentication setting 10003 auth_settings = [] 10004 10005 return self.api_client.call_api(resource_path, 'GET', 10006 path_params, 10007 query_params, 10008 header_params, 10009 body=body_params, 10010 post_params=form_params, 10011 files=local_var_files, 10012 response_type='EnvelopeAuditEventResponse', 10013 auth_settings=auth_settings, 10014 callback=params.get('callback'), 10015 _return_http_data_only=params.get('_return_http_data_only'), 10016 _preload_content=params.get('_preload_content', True), 10017 _request_timeout=params.get('_request_timeout'), 10018 collection_formats=collection_formats) 10019 10020 def list_custom_fields(self, account_id, envelope_id, **kwargs): 10021 """ 10022 Gets the custom field information for the specified envelope. 10023 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. 10024 This method makes a synchronous HTTP request by default. To make an 10025 asynchronous HTTP request, please define a `callback` function 10026 to be invoked when receiving the response. 10027 >>> def callback_function(response): 10028 >>> pprint(response) 10029 >>> 10030 >>> thread = api.list_custom_fields(account_id, envelope_id, callback=callback_function) 10031 10032 :param callback function: The callback function 10033 for asynchronous request. (optional) 10034 :param str account_id: The external account number (int) or account ID Guid. (required) 10035 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10036 :return: CustomFieldsEnvelope 10037 If the method is called asynchronously, 10038 returns the request thread. 10039 """ 10040 kwargs['_return_http_data_only'] = True 10041 if kwargs.get('callback'): 10042 return self.list_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 10043 else: 10044 (data) = self.list_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 10045 return data 10046 10047 def list_custom_fields_with_http_info(self, account_id, envelope_id, **kwargs): 10048 """ 10049 Gets the custom field information for the specified envelope. 10050 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. 10051 This method makes a synchronous HTTP request by default. To make an 10052 asynchronous HTTP request, please define a `callback` function 10053 to be invoked when receiving the response. 10054 >>> def callback_function(response): 10055 >>> pprint(response) 10056 >>> 10057 >>> thread = api.list_custom_fields_with_http_info(account_id, envelope_id, callback=callback_function) 10058 10059 :param callback function: The callback function 10060 for asynchronous request. (optional) 10061 :param str account_id: The external account number (int) or account ID Guid. (required) 10062 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10063 :return: CustomFieldsEnvelope 10064 If the method is called asynchronously, 10065 returns the request thread. 10066 """ 10067 10068 all_params = ['account_id', 'envelope_id'] 10069 all_params.append('callback') 10070 all_params.append('_return_http_data_only') 10071 all_params.append('_preload_content') 10072 all_params.append('_request_timeout') 10073 10074 params = locals() 10075 for key, val in iteritems(params['kwargs']): 10076 if key not in all_params: 10077 raise TypeError( 10078 "Got an unexpected keyword argument '%s'" 10079 " to method list_custom_fields" % key 10080 ) 10081 params[key] = val 10082 del params['kwargs'] 10083 # verify the required parameter 'account_id' is set 10084 if ('account_id' not in params) or (params['account_id'] is None): 10085 raise ValueError("Missing the required parameter `account_id` when calling `list_custom_fields`") 10086 # verify the required parameter 'envelope_id' is set 10087 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10088 raise ValueError("Missing the required parameter `envelope_id` when calling `list_custom_fields`") 10089 10090 10091 collection_formats = {} 10092 10093 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/custom_fields'.replace('{format}', 'json') 10094 path_params = {} 10095 if 'account_id' in params: 10096 path_params['accountId'] = params['account_id'] 10097 if 'envelope_id' in params: 10098 path_params['envelopeId'] = params['envelope_id'] 10099 10100 query_params = {} 10101 10102 header_params = {} 10103 10104 form_params = [] 10105 local_var_files = {} 10106 10107 body_params = None 10108 # HTTP header `Accept` 10109 header_params['Accept'] = self.api_client.\ 10110 select_header_accept(['application/json']) 10111 10112 # Authentication setting 10113 auth_settings = [] 10114 10115 return self.api_client.call_api(resource_path, 'GET', 10116 path_params, 10117 query_params, 10118 header_params, 10119 body=body_params, 10120 post_params=form_params, 10121 files=local_var_files, 10122 response_type='CustomFieldsEnvelope', 10123 auth_settings=auth_settings, 10124 callback=params.get('callback'), 10125 _return_http_data_only=params.get('_return_http_data_only'), 10126 _preload_content=params.get('_preload_content', True), 10127 _request_timeout=params.get('_request_timeout'), 10128 collection_formats=collection_formats) 10129 10130 def list_document_fields(self, account_id, document_id, envelope_id, **kwargs): 10131 """ 10132 Gets the custom document fields from an existing envelope document. 10133 Retrieves the custom document field information from an existing envelope document. 10134 This method makes a synchronous HTTP request by default. To make an 10135 asynchronous HTTP request, please define a `callback` function 10136 to be invoked when receiving the response. 10137 >>> def callback_function(response): 10138 >>> pprint(response) 10139 >>> 10140 >>> thread = api.list_document_fields(account_id, document_id, envelope_id, callback=callback_function) 10141 10142 :param callback function: The callback function 10143 for asynchronous request. (optional) 10144 :param str account_id: The external account number (int) or account ID Guid. (required) 10145 :param str document_id: The ID of the document being accessed. (required) 10146 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10147 :return: DocumentFieldsInformation 10148 If the method is called asynchronously, 10149 returns the request thread. 10150 """ 10151 kwargs['_return_http_data_only'] = True 10152 if kwargs.get('callback'): 10153 return self.list_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 10154 else: 10155 (data) = self.list_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 10156 return data 10157 10158 def list_document_fields_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 10159 """ 10160 Gets the custom document fields from an existing envelope document. 10161 Retrieves the custom document field information from an existing envelope document. 10162 This method makes a synchronous HTTP request by default. To make an 10163 asynchronous HTTP request, please define a `callback` function 10164 to be invoked when receiving the response. 10165 >>> def callback_function(response): 10166 >>> pprint(response) 10167 >>> 10168 >>> thread = api.list_document_fields_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 10169 10170 :param callback function: The callback function 10171 for asynchronous request. (optional) 10172 :param str account_id: The external account number (int) or account ID Guid. (required) 10173 :param str document_id: The ID of the document being accessed. (required) 10174 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10175 :return: DocumentFieldsInformation 10176 If the method is called asynchronously, 10177 returns the request thread. 10178 """ 10179 10180 all_params = ['account_id', 'document_id', 'envelope_id'] 10181 all_params.append('callback') 10182 all_params.append('_return_http_data_only') 10183 all_params.append('_preload_content') 10184 all_params.append('_request_timeout') 10185 10186 params = locals() 10187 for key, val in iteritems(params['kwargs']): 10188 if key not in all_params: 10189 raise TypeError( 10190 "Got an unexpected keyword argument '%s'" 10191 " to method list_document_fields" % key 10192 ) 10193 params[key] = val 10194 del params['kwargs'] 10195 # verify the required parameter 'account_id' is set 10196 if ('account_id' not in params) or (params['account_id'] is None): 10197 raise ValueError("Missing the required parameter `account_id` when calling `list_document_fields`") 10198 # verify the required parameter 'document_id' is set 10199 if ('document_id' not in params) or (params['document_id'] is None): 10200 raise ValueError("Missing the required parameter `document_id` when calling `list_document_fields`") 10201 # verify the required parameter 'envelope_id' is set 10202 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10203 raise ValueError("Missing the required parameter `envelope_id` when calling `list_document_fields`") 10204 10205 10206 collection_formats = {} 10207 10208 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/fields'.replace('{format}', 'json') 10209 path_params = {} 10210 if 'account_id' in params: 10211 path_params['accountId'] = params['account_id'] 10212 if 'document_id' in params: 10213 path_params['documentId'] = params['document_id'] 10214 if 'envelope_id' in params: 10215 path_params['envelopeId'] = params['envelope_id'] 10216 10217 query_params = {} 10218 10219 header_params = {} 10220 10221 form_params = [] 10222 local_var_files = {} 10223 10224 body_params = None 10225 # HTTP header `Accept` 10226 header_params['Accept'] = self.api_client.\ 10227 select_header_accept(['application/json']) 10228 10229 # Authentication setting 10230 auth_settings = [] 10231 10232 return self.api_client.call_api(resource_path, 'GET', 10233 path_params, 10234 query_params, 10235 header_params, 10236 body=body_params, 10237 post_params=form_params, 10238 files=local_var_files, 10239 response_type='DocumentFieldsInformation', 10240 auth_settings=auth_settings, 10241 callback=params.get('callback'), 10242 _return_http_data_only=params.get('_return_http_data_only'), 10243 _preload_content=params.get('_preload_content', True), 10244 _request_timeout=params.get('_request_timeout'), 10245 collection_formats=collection_formats) 10246 10247 def list_documents(self, account_id, envelope_id, **kwargs): 10248 """ 10249 Gets a list of envelope documents. 10250 Retrieves a list of documents associated with the specified envelope. 10251 This method makes a synchronous HTTP request by default. To make an 10252 asynchronous HTTP request, please define a `callback` function 10253 to be invoked when receiving the response. 10254 >>> def callback_function(response): 10255 >>> pprint(response) 10256 >>> 10257 >>> thread = api.list_documents(account_id, envelope_id, callback=callback_function) 10258 10259 :param callback function: The callback function 10260 for asynchronous request. (optional) 10261 :param str account_id: The external account number (int) or account ID Guid. (required) 10262 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10263 :param str documents_by_userid: 10264 :param str include_agreement_type: 10265 :param str include_docgen_formfields: 10266 :param str include_document_size: 10267 :param str include_metadata: 10268 :param str include_tabs: 10269 :param str recipient_id: 10270 :param str shared_user_id: 10271 :return: EnvelopeDocumentsResult 10272 If the method is called asynchronously, 10273 returns the request thread. 10274 """ 10275 kwargs['_return_http_data_only'] = True 10276 if kwargs.get('callback'): 10277 return self.list_documents_with_http_info(account_id, envelope_id, **kwargs) 10278 else: 10279 (data) = self.list_documents_with_http_info(account_id, envelope_id, **kwargs) 10280 return data 10281 10282 def list_documents_with_http_info(self, account_id, envelope_id, **kwargs): 10283 """ 10284 Gets a list of envelope documents. 10285 Retrieves a list of documents associated with the specified envelope. 10286 This method makes a synchronous HTTP request by default. To make an 10287 asynchronous HTTP request, please define a `callback` function 10288 to be invoked when receiving the response. 10289 >>> def callback_function(response): 10290 >>> pprint(response) 10291 >>> 10292 >>> thread = api.list_documents_with_http_info(account_id, envelope_id, callback=callback_function) 10293 10294 :param callback function: The callback function 10295 for asynchronous request. (optional) 10296 :param str account_id: The external account number (int) or account ID Guid. (required) 10297 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10298 :param str documents_by_userid: 10299 :param str include_agreement_type: 10300 :param str include_docgen_formfields: 10301 :param str include_document_size: 10302 :param str include_metadata: 10303 :param str include_tabs: 10304 :param str recipient_id: 10305 :param str shared_user_id: 10306 :return: EnvelopeDocumentsResult 10307 If the method is called asynchronously, 10308 returns the request thread. 10309 """ 10310 10311 all_params = ['account_id', 'envelope_id', 'documents_by_userid', 'include_agreement_type', 'include_docgen_formfields', 'include_document_size', 'include_metadata', 'include_tabs', 'recipient_id', 'shared_user_id'] 10312 all_params.append('callback') 10313 all_params.append('_return_http_data_only') 10314 all_params.append('_preload_content') 10315 all_params.append('_request_timeout') 10316 10317 params = locals() 10318 for key, val in iteritems(params['kwargs']): 10319 if key not in all_params: 10320 raise TypeError( 10321 "Got an unexpected keyword argument '%s'" 10322 " to method list_documents" % key 10323 ) 10324 params[key] = val 10325 del params['kwargs'] 10326 # verify the required parameter 'account_id' is set 10327 if ('account_id' not in params) or (params['account_id'] is None): 10328 raise ValueError("Missing the required parameter `account_id` when calling `list_documents`") 10329 # verify the required parameter 'envelope_id' is set 10330 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10331 raise ValueError("Missing the required parameter `envelope_id` when calling `list_documents`") 10332 10333 10334 collection_formats = {} 10335 10336 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents'.replace('{format}', 'json') 10337 path_params = {} 10338 if 'account_id' in params: 10339 path_params['accountId'] = params['account_id'] 10340 if 'envelope_id' in params: 10341 path_params['envelopeId'] = params['envelope_id'] 10342 10343 query_params = {} 10344 if 'documents_by_userid' in params: 10345 query_params['documents_by_userid'] = params['documents_by_userid'] 10346 if 'include_agreement_type' in params: 10347 query_params['include_agreement_type'] = params['include_agreement_type'] 10348 if 'include_docgen_formfields' in params: 10349 query_params['include_docgen_formfields'] = params['include_docgen_formfields'] 10350 if 'include_document_size' in params: 10351 query_params['include_document_size'] = params['include_document_size'] 10352 if 'include_metadata' in params: 10353 query_params['include_metadata'] = params['include_metadata'] 10354 if 'include_tabs' in params: 10355 query_params['include_tabs'] = params['include_tabs'] 10356 if 'recipient_id' in params: 10357 query_params['recipient_id'] = params['recipient_id'] 10358 if 'shared_user_id' in params: 10359 query_params['shared_user_id'] = params['shared_user_id'] 10360 10361 header_params = {} 10362 10363 form_params = [] 10364 local_var_files = {} 10365 10366 body_params = None 10367 # HTTP header `Accept` 10368 header_params['Accept'] = self.api_client.\ 10369 select_header_accept(['application/json']) 10370 10371 # Authentication setting 10372 auth_settings = [] 10373 10374 return self.api_client.call_api(resource_path, 'GET', 10375 path_params, 10376 query_params, 10377 header_params, 10378 body=body_params, 10379 post_params=form_params, 10380 files=local_var_files, 10381 response_type='EnvelopeDocumentsResult', 10382 auth_settings=auth_settings, 10383 callback=params.get('callback'), 10384 _return_http_data_only=params.get('_return_http_data_only'), 10385 _preload_content=params.get('_preload_content', True), 10386 _request_timeout=params.get('_request_timeout'), 10387 collection_formats=collection_formats) 10388 10389 def list_recipients(self, account_id, envelope_id, **kwargs): 10390 """ 10391 Gets the status of recipients for an envelope. 10392 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. 10393 This method makes a synchronous HTTP request by default. To make an 10394 asynchronous HTTP request, please define a `callback` function 10395 to be invoked when receiving the response. 10396 >>> def callback_function(response): 10397 >>> pprint(response) 10398 >>> 10399 >>> thread = api.list_recipients(account_id, envelope_id, callback=callback_function) 10400 10401 :param callback function: The callback function 10402 for asynchronous request. (optional) 10403 :param str account_id: The external account number (int) or account ID Guid. (required) 10404 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10405 :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. 10406 :param str include_extended: When set to **true**, the extended properties are included in the response. 10407 :param str include_metadata: 10408 :param str include_tabs: When set to **true**, the tab information associated with the recipient is included in the response. 10409 :return: Recipients 10410 If the method is called asynchronously, 10411 returns the request thread. 10412 """ 10413 kwargs['_return_http_data_only'] = True 10414 if kwargs.get('callback'): 10415 return self.list_recipients_with_http_info(account_id, envelope_id, **kwargs) 10416 else: 10417 (data) = self.list_recipients_with_http_info(account_id, envelope_id, **kwargs) 10418 return data 10419 10420 def list_recipients_with_http_info(self, account_id, envelope_id, **kwargs): 10421 """ 10422 Gets the status of recipients for an envelope. 10423 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. 10424 This method makes a synchronous HTTP request by default. To make an 10425 asynchronous HTTP request, please define a `callback` function 10426 to be invoked when receiving the response. 10427 >>> def callback_function(response): 10428 >>> pprint(response) 10429 >>> 10430 >>> thread = api.list_recipients_with_http_info(account_id, envelope_id, callback=callback_function) 10431 10432 :param callback function: The callback function 10433 for asynchronous request. (optional) 10434 :param str account_id: The external account number (int) or account ID Guid. (required) 10435 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10436 :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. 10437 :param str include_extended: When set to **true**, the extended properties are included in the response. 10438 :param str include_metadata: 10439 :param str include_tabs: When set to **true**, the tab information associated with the recipient is included in the response. 10440 :return: Recipients 10441 If the method is called asynchronously, 10442 returns the request thread. 10443 """ 10444 10445 all_params = ['account_id', 'envelope_id', 'include_anchor_tab_locations', 'include_extended', 'include_metadata', 'include_tabs'] 10446 all_params.append('callback') 10447 all_params.append('_return_http_data_only') 10448 all_params.append('_preload_content') 10449 all_params.append('_request_timeout') 10450 10451 params = locals() 10452 for key, val in iteritems(params['kwargs']): 10453 if key not in all_params: 10454 raise TypeError( 10455 "Got an unexpected keyword argument '%s'" 10456 " to method list_recipients" % key 10457 ) 10458 params[key] = val 10459 del params['kwargs'] 10460 # verify the required parameter 'account_id' is set 10461 if ('account_id' not in params) or (params['account_id'] is None): 10462 raise ValueError("Missing the required parameter `account_id` when calling `list_recipients`") 10463 # verify the required parameter 'envelope_id' is set 10464 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10465 raise ValueError("Missing the required parameter `envelope_id` when calling `list_recipients`") 10466 10467 10468 collection_formats = {} 10469 10470 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients'.replace('{format}', 'json') 10471 path_params = {} 10472 if 'account_id' in params: 10473 path_params['accountId'] = params['account_id'] 10474 if 'envelope_id' in params: 10475 path_params['envelopeId'] = params['envelope_id'] 10476 10477 query_params = {} 10478 if 'include_anchor_tab_locations' in params: 10479 query_params['include_anchor_tab_locations'] = params['include_anchor_tab_locations'] 10480 if 'include_extended' in params: 10481 query_params['include_extended'] = params['include_extended'] 10482 if 'include_metadata' in params: 10483 query_params['include_metadata'] = params['include_metadata'] 10484 if 'include_tabs' in params: 10485 query_params['include_tabs'] = params['include_tabs'] 10486 10487 header_params = {} 10488 10489 form_params = [] 10490 local_var_files = {} 10491 10492 body_params = None 10493 # HTTP header `Accept` 10494 header_params['Accept'] = self.api_client.\ 10495 select_header_accept(['application/json']) 10496 10497 # Authentication setting 10498 auth_settings = [] 10499 10500 return self.api_client.call_api(resource_path, 'GET', 10501 path_params, 10502 query_params, 10503 header_params, 10504 body=body_params, 10505 post_params=form_params, 10506 files=local_var_files, 10507 response_type='Recipients', 10508 auth_settings=auth_settings, 10509 callback=params.get('callback'), 10510 _return_http_data_only=params.get('_return_http_data_only'), 10511 _preload_content=params.get('_preload_content', True), 10512 _request_timeout=params.get('_request_timeout'), 10513 collection_formats=collection_formats) 10514 10515 def list_status(self, account_id, **kwargs): 10516 """ 10517 Gets the envelope status for the specified envelopes. 10518 Retrieves the envelope status for the specified envelopes. 10519 This method makes a synchronous HTTP request by default. To make an 10520 asynchronous HTTP request, please define a `callback` function 10521 to be invoked when receiving the response. 10522 >>> def callback_function(response): 10523 >>> pprint(response) 10524 >>> 10525 >>> thread = api.list_status(account_id, callback=callback_function) 10526 10527 :param callback function: The callback function 10528 for asynchronous request. (optional) 10529 :param str account_id: The external account number (int) or account ID Guid. (required) 10530 :param str ac_status: 10531 :param str block: 10532 :param str count: 10533 :param str email: 10534 :param str envelope_ids: 10535 :param str from_date: 10536 :param str from_to_status: 10537 :param str start_position: 10538 :param str status: 10539 :param str to_date: 10540 :param str transaction_ids: 10541 :param str user_name: 10542 :param EnvelopeIdsRequest envelope_ids_request: 10543 :return: EnvelopesInformation 10544 If the method is called asynchronously, 10545 returns the request thread. 10546 """ 10547 kwargs['_return_http_data_only'] = True 10548 if kwargs.get('callback'): 10549 return self.list_status_with_http_info(account_id, **kwargs) 10550 else: 10551 (data) = self.list_status_with_http_info(account_id, **kwargs) 10552 return data 10553 10554 def list_status_with_http_info(self, account_id, **kwargs): 10555 """ 10556 Gets the envelope status for the specified envelopes. 10557 Retrieves the envelope status for the specified envelopes. 10558 This method makes a synchronous HTTP request by default. To make an 10559 asynchronous HTTP request, please define a `callback` function 10560 to be invoked when receiving the response. 10561 >>> def callback_function(response): 10562 >>> pprint(response) 10563 >>> 10564 >>> thread = api.list_status_with_http_info(account_id, callback=callback_function) 10565 10566 :param callback function: The callback function 10567 for asynchronous request. (optional) 10568 :param str account_id: The external account number (int) or account ID Guid. (required) 10569 :param str ac_status: 10570 :param str block: 10571 :param str count: 10572 :param str email: 10573 :param str envelope_ids: 10574 :param str from_date: 10575 :param str from_to_status: 10576 :param str start_position: 10577 :param str status: 10578 :param str to_date: 10579 :param str transaction_ids: 10580 :param str user_name: 10581 :param EnvelopeIdsRequest envelope_ids_request: 10582 :return: EnvelopesInformation 10583 If the method is called asynchronously, 10584 returns the request thread. 10585 """ 10586 10587 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'] 10588 all_params.append('callback') 10589 all_params.append('_return_http_data_only') 10590 all_params.append('_preload_content') 10591 all_params.append('_request_timeout') 10592 10593 params = locals() 10594 for key, val in iteritems(params['kwargs']): 10595 if key not in all_params: 10596 raise TypeError( 10597 "Got an unexpected keyword argument '%s'" 10598 " to method list_status" % key 10599 ) 10600 params[key] = val 10601 del params['kwargs'] 10602 # verify the required parameter 'account_id' is set 10603 if ('account_id' not in params) or (params['account_id'] is None): 10604 raise ValueError("Missing the required parameter `account_id` when calling `list_status`") 10605 10606 10607 collection_formats = {} 10608 10609 resource_path = '/v2.1/accounts/{accountId}/envelopes/status'.replace('{format}', 'json') 10610 path_params = {} 10611 if 'account_id' in params: 10612 path_params['accountId'] = params['account_id'] 10613 10614 query_params = {} 10615 if 'ac_status' in params: 10616 query_params['ac_status'] = params['ac_status'] 10617 if 'block' in params: 10618 query_params['block'] = params['block'] 10619 if 'count' in params: 10620 query_params['count'] = params['count'] 10621 if 'email' in params: 10622 query_params['email'] = params['email'] 10623 if 'envelope_ids' in params: 10624 query_params['envelope_ids'] = params['envelope_ids'] 10625 if 'from_date' in params: 10626 query_params['from_date'] = params['from_date'] 10627 if 'from_to_status' in params: 10628 query_params['from_to_status'] = params['from_to_status'] 10629 if 'start_position' in params: 10630 query_params['start_position'] = params['start_position'] 10631 if 'status' in params: 10632 query_params['status'] = params['status'] 10633 if 'to_date' in params: 10634 query_params['to_date'] = params['to_date'] 10635 if 'transaction_ids' in params: 10636 query_params['transaction_ids'] = params['transaction_ids'] 10637 if 'user_name' in params: 10638 query_params['user_name'] = params['user_name'] 10639 10640 header_params = {} 10641 10642 form_params = [] 10643 local_var_files = {} 10644 10645 body_params = None 10646 if 'envelope_ids_request' in params: 10647 body_params = params['envelope_ids_request'] 10648 # HTTP header `Accept` 10649 header_params['Accept'] = self.api_client.\ 10650 select_header_accept(['application/json']) 10651 10652 # Authentication setting 10653 auth_settings = [] 10654 10655 return self.api_client.call_api(resource_path, 'PUT', 10656 path_params, 10657 query_params, 10658 header_params, 10659 body=body_params, 10660 post_params=form_params, 10661 files=local_var_files, 10662 response_type='EnvelopesInformation', 10663 auth_settings=auth_settings, 10664 callback=params.get('callback'), 10665 _return_http_data_only=params.get('_return_http_data_only'), 10666 _preload_content=params.get('_preload_content', True), 10667 _request_timeout=params.get('_request_timeout'), 10668 collection_formats=collection_formats) 10669 10670 def list_status_changes(self, account_id, **kwargs): 10671 """ 10672 Gets status changes for one or more envelopes. 10673 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. 10674 This method makes a synchronous HTTP request by default. To make an 10675 asynchronous HTTP request, please define a `callback` function 10676 to be invoked when receiving the response. 10677 >>> def callback_function(response): 10678 >>> pprint(response) 10679 >>> 10680 >>> thread = api.list_status_changes(account_id, callback=callback_function) 10681 10682 :param callback function: The callback function 10683 for asynchronous request. (optional) 10684 :param str account_id: The external account number (int) or account ID Guid. (required) 10685 :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. 10686 :param str block: 10687 :param str cdse_mode: 10688 :param str continuation_token: 10689 :param str count: 10690 :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.\" 10691 :param str email: 10692 :param str envelope_ids: 10693 :param str exclude: 10694 :param str folder_ids: 10695 :param str folder_types: 10696 :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. 10697 :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. 10698 :param str include: 10699 :param str include_purge_information: 10700 :param str intersecting_folder_ids: 10701 :param str last_queried_date: 10702 :param str order: 10703 :param str order_by: 10704 :param str powerformids: 10705 :param str query_budget: 10706 :param str requester_date_format: 10707 :param str search_mode: 10708 :param str search_text: 10709 :param str start_position: 10710 :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. 10711 :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`. 10712 :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. 10713 :param str user_filter: 10714 :param str user_id: 10715 :param str user_name: 10716 :return: EnvelopesInformation 10717 If the method is called asynchronously, 10718 returns the request thread. 10719 """ 10720 kwargs['_return_http_data_only'] = True 10721 if kwargs.get('callback'): 10722 return self.list_status_changes_with_http_info(account_id, **kwargs) 10723 else: 10724 (data) = self.list_status_changes_with_http_info(account_id, **kwargs) 10725 return data 10726 10727 def list_status_changes_with_http_info(self, account_id, **kwargs): 10728 """ 10729 Gets status changes for one or more envelopes. 10730 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. 10731 This method makes a synchronous HTTP request by default. To make an 10732 asynchronous HTTP request, please define a `callback` function 10733 to be invoked when receiving the response. 10734 >>> def callback_function(response): 10735 >>> pprint(response) 10736 >>> 10737 >>> thread = api.list_status_changes_with_http_info(account_id, callback=callback_function) 10738 10739 :param callback function: The callback function 10740 for asynchronous request. (optional) 10741 :param str account_id: The external account number (int) or account ID Guid. (required) 10742 :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. 10743 :param str block: 10744 :param str cdse_mode: 10745 :param str continuation_token: 10746 :param str count: 10747 :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.\" 10748 :param str email: 10749 :param str envelope_ids: 10750 :param str exclude: 10751 :param str folder_ids: 10752 :param str folder_types: 10753 :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. 10754 :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. 10755 :param str include: 10756 :param str include_purge_information: 10757 :param str intersecting_folder_ids: 10758 :param str last_queried_date: 10759 :param str order: 10760 :param str order_by: 10761 :param str powerformids: 10762 :param str query_budget: 10763 :param str requester_date_format: 10764 :param str search_mode: 10765 :param str search_text: 10766 :param str start_position: 10767 :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. 10768 :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`. 10769 :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. 10770 :param str user_filter: 10771 :param str user_id: 10772 :param str user_name: 10773 :return: EnvelopesInformation 10774 If the method is called asynchronously, 10775 returns the request thread. 10776 """ 10777 10778 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'] 10779 all_params.append('callback') 10780 all_params.append('_return_http_data_only') 10781 all_params.append('_preload_content') 10782 all_params.append('_request_timeout') 10783 10784 params = locals() 10785 for key, val in iteritems(params['kwargs']): 10786 if key not in all_params: 10787 raise TypeError( 10788 "Got an unexpected keyword argument '%s'" 10789 " to method list_status_changes" % key 10790 ) 10791 params[key] = val 10792 del params['kwargs'] 10793 # verify the required parameter 'account_id' is set 10794 if ('account_id' not in params) or (params['account_id'] is None): 10795 raise ValueError("Missing the required parameter `account_id` when calling `list_status_changes`") 10796 10797 10798 collection_formats = {} 10799 10800 resource_path = '/v2.1/accounts/{accountId}/envelopes'.replace('{format}', 'json') 10801 path_params = {} 10802 if 'account_id' in params: 10803 path_params['accountId'] = params['account_id'] 10804 10805 query_params = {} 10806 if 'ac_status' in params: 10807 query_params['ac_status'] = params['ac_status'] 10808 if 'block' in params: 10809 query_params['block'] = params['block'] 10810 if 'cdse_mode' in params: 10811 query_params['cdse_mode'] = params['cdse_mode'] 10812 if 'continuation_token' in params: 10813 query_params['continuation_token'] = params['continuation_token'] 10814 if 'count' in params: 10815 query_params['count'] = params['count'] 10816 if 'custom_field' in params: 10817 query_params['custom_field'] = params['custom_field'] 10818 if 'email' in params: 10819 query_params['email'] = params['email'] 10820 if 'envelope_ids' in params: 10821 query_params['envelope_ids'] = params['envelope_ids'] 10822 if 'exclude' in params: 10823 query_params['exclude'] = params['exclude'] 10824 if 'folder_ids' in params: 10825 query_params['folder_ids'] = params['folder_ids'] 10826 if 'folder_types' in params: 10827 query_params['folder_types'] = params['folder_types'] 10828 if 'from_date' in params: 10829 query_params['from_date'] = params['from_date'] 10830 if 'from_to_status' in params: 10831 query_params['from_to_status'] = params['from_to_status'] 10832 if 'include' in params: 10833 query_params['include'] = params['include'] 10834 if 'include_purge_information' in params: 10835 query_params['include_purge_information'] = params['include_purge_information'] 10836 if 'intersecting_folder_ids' in params: 10837 query_params['intersecting_folder_ids'] = params['intersecting_folder_ids'] 10838 if 'last_queried_date' in params: 10839 query_params['last_queried_date'] = params['last_queried_date'] 10840 if 'order' in params: 10841 query_params['order'] = params['order'] 10842 if 'order_by' in params: 10843 query_params['order_by'] = params['order_by'] 10844 if 'powerformids' in params: 10845 query_params['powerformids'] = params['powerformids'] 10846 if 'query_budget' in params: 10847 query_params['query_budget'] = params['query_budget'] 10848 if 'requester_date_format' in params: 10849 query_params['requester_date_format'] = params['requester_date_format'] 10850 if 'search_mode' in params: 10851 query_params['search_mode'] = params['search_mode'] 10852 if 'search_text' in params: 10853 query_params['search_text'] = params['search_text'] 10854 if 'start_position' in params: 10855 query_params['start_position'] = params['start_position'] 10856 if 'status' in params: 10857 query_params['status'] = params['status'] 10858 if 'to_date' in params: 10859 query_params['to_date'] = params['to_date'] 10860 if 'transaction_ids' in params: 10861 query_params['transaction_ids'] = params['transaction_ids'] 10862 if 'user_filter' in params: 10863 query_params['user_filter'] = params['user_filter'] 10864 if 'user_id' in params: 10865 query_params['user_id'] = params['user_id'] 10866 if 'user_name' in params: 10867 query_params['user_name'] = params['user_name'] 10868 10869 header_params = {} 10870 10871 form_params = [] 10872 local_var_files = {} 10873 10874 body_params = None 10875 # HTTP header `Accept` 10876 header_params['Accept'] = self.api_client.\ 10877 select_header_accept(['application/json']) 10878 10879 # Authentication setting 10880 auth_settings = [] 10881 10882 return self.api_client.call_api(resource_path, 'GET', 10883 path_params, 10884 query_params, 10885 header_params, 10886 body=body_params, 10887 post_params=form_params, 10888 files=local_var_files, 10889 response_type='EnvelopesInformation', 10890 auth_settings=auth_settings, 10891 callback=params.get('callback'), 10892 _return_http_data_only=params.get('_return_http_data_only'), 10893 _preload_content=params.get('_preload_content', True), 10894 _request_timeout=params.get('_request_timeout'), 10895 collection_formats=collection_formats) 10896 10897 def list_tabs(self, account_id, envelope_id, recipient_id, **kwargs): 10898 """ 10899 Gets the tabs information for a signer or sign-in-person recipient in an envelope. 10900 Retrieves information about the tabs associated with a recipient in a draft envelope. 10901 This method makes a synchronous HTTP request by default. To make an 10902 asynchronous HTTP request, please define a `callback` function 10903 to be invoked when receiving the response. 10904 >>> def callback_function(response): 10905 >>> pprint(response) 10906 >>> 10907 >>> thread = api.list_tabs(account_id, envelope_id, recipient_id, callback=callback_function) 10908 10909 :param callback function: The callback function 10910 for asynchronous request. (optional) 10911 :param str account_id: The external account number (int) or account ID Guid. (required) 10912 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10913 :param str recipient_id: The ID of the recipient being accessed. (required) 10914 :param str include_anchor_tab_locations: When set to **true**, all tabs with anchor tab properties are included in the response. 10915 :param str include_metadata: 10916 :return: Tabs 10917 If the method is called asynchronously, 10918 returns the request thread. 10919 """ 10920 kwargs['_return_http_data_only'] = True 10921 if kwargs.get('callback'): 10922 return self.list_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 10923 else: 10924 (data) = self.list_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 10925 return data 10926 10927 def list_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 10928 """ 10929 Gets the tabs information for a signer or sign-in-person recipient in an envelope. 10930 Retrieves information about the tabs associated with a recipient in a draft envelope. 10931 This method makes a synchronous HTTP request by default. To make an 10932 asynchronous HTTP request, please define a `callback` function 10933 to be invoked when receiving the response. 10934 >>> def callback_function(response): 10935 >>> pprint(response) 10936 >>> 10937 >>> thread = api.list_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 10938 10939 :param callback function: The callback function 10940 for asynchronous request. (optional) 10941 :param str account_id: The external account number (int) or account ID Guid. (required) 10942 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10943 :param str recipient_id: The ID of the recipient being accessed. (required) 10944 :param str include_anchor_tab_locations: When set to **true**, all tabs with anchor tab properties are included in the response. 10945 :param str include_metadata: 10946 :return: Tabs 10947 If the method is called asynchronously, 10948 returns the request thread. 10949 """ 10950 10951 all_params = ['account_id', 'envelope_id', 'recipient_id', 'include_anchor_tab_locations', 'include_metadata'] 10952 all_params.append('callback') 10953 all_params.append('_return_http_data_only') 10954 all_params.append('_preload_content') 10955 all_params.append('_request_timeout') 10956 10957 params = locals() 10958 for key, val in iteritems(params['kwargs']): 10959 if key not in all_params: 10960 raise TypeError( 10961 "Got an unexpected keyword argument '%s'" 10962 " to method list_tabs" % key 10963 ) 10964 params[key] = val 10965 del params['kwargs'] 10966 # verify the required parameter 'account_id' is set 10967 if ('account_id' not in params) or (params['account_id'] is None): 10968 raise ValueError("Missing the required parameter `account_id` when calling `list_tabs`") 10969 # verify the required parameter 'envelope_id' is set 10970 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10971 raise ValueError("Missing the required parameter `envelope_id` when calling `list_tabs`") 10972 # verify the required parameter 'recipient_id' is set 10973 if ('recipient_id' not in params) or (params['recipient_id'] is None): 10974 raise ValueError("Missing the required parameter `recipient_id` when calling `list_tabs`") 10975 10976 10977 collection_formats = {} 10978 10979 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/tabs'.replace('{format}', 'json') 10980 path_params = {} 10981 if 'account_id' in params: 10982 path_params['accountId'] = params['account_id'] 10983 if 'envelope_id' in params: 10984 path_params['envelopeId'] = params['envelope_id'] 10985 if 'recipient_id' in params: 10986 path_params['recipientId'] = params['recipient_id'] 10987 10988 query_params = {} 10989 if 'include_anchor_tab_locations' in params: 10990 query_params['include_anchor_tab_locations'] = params['include_anchor_tab_locations'] 10991 if 'include_metadata' in params: 10992 query_params['include_metadata'] = params['include_metadata'] 10993 10994 header_params = {} 10995 10996 form_params = [] 10997 local_var_files = {} 10998 10999 body_params = None 11000 # HTTP header `Accept` 11001 header_params['Accept'] = self.api_client.\ 11002 select_header_accept(['application/json']) 11003 11004 # Authentication setting 11005 auth_settings = [] 11006 11007 return self.api_client.call_api(resource_path, 'GET', 11008 path_params, 11009 query_params, 11010 header_params, 11011 body=body_params, 11012 post_params=form_params, 11013 files=local_var_files, 11014 response_type='Tabs', 11015 auth_settings=auth_settings, 11016 callback=params.get('callback'), 11017 _return_http_data_only=params.get('_return_http_data_only'), 11018 _preload_content=params.get('_preload_content', True), 11019 _request_timeout=params.get('_request_timeout'), 11020 collection_formats=collection_formats) 11021 11022 def list_templates(self, account_id, envelope_id, **kwargs): 11023 """ 11024 Get List of Templates used in an Envelope 11025 This returns a list of the server-side templates, their name and ID, used in an envelope. 11026 This method makes a synchronous HTTP request by default. To make an 11027 asynchronous HTTP request, please define a `callback` function 11028 to be invoked when receiving the response. 11029 >>> def callback_function(response): 11030 >>> pprint(response) 11031 >>> 11032 >>> thread = api.list_templates(account_id, envelope_id, callback=callback_function) 11033 11034 :param callback function: The callback function 11035 for asynchronous request. (optional) 11036 :param str account_id: The external account number (int) or account ID Guid. (required) 11037 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11038 :param str include: The possible values are: matching_applied - This returns template matching information for the template. 11039 :return: TemplateInformation 11040 If the method is called asynchronously, 11041 returns the request thread. 11042 """ 11043 kwargs['_return_http_data_only'] = True 11044 if kwargs.get('callback'): 11045 return self.list_templates_with_http_info(account_id, envelope_id, **kwargs) 11046 else: 11047 (data) = self.list_templates_with_http_info(account_id, envelope_id, **kwargs) 11048 return data 11049 11050 def list_templates_with_http_info(self, account_id, envelope_id, **kwargs): 11051 """ 11052 Get List of Templates used in an Envelope 11053 This returns a list of the server-side templates, their name and ID, used in an envelope. 11054 This method makes a synchronous HTTP request by default. To make an 11055 asynchronous HTTP request, please define a `callback` function 11056 to be invoked when receiving the response. 11057 >>> def callback_function(response): 11058 >>> pprint(response) 11059 >>> 11060 >>> thread = api.list_templates_with_http_info(account_id, envelope_id, callback=callback_function) 11061 11062 :param callback function: The callback function 11063 for asynchronous request. (optional) 11064 :param str account_id: The external account number (int) or account ID Guid. (required) 11065 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11066 :param str include: The possible values are: matching_applied - This returns template matching information for the template. 11067 :return: TemplateInformation 11068 If the method is called asynchronously, 11069 returns the request thread. 11070 """ 11071 11072 all_params = ['account_id', 'envelope_id', 'include'] 11073 all_params.append('callback') 11074 all_params.append('_return_http_data_only') 11075 all_params.append('_preload_content') 11076 all_params.append('_request_timeout') 11077 11078 params = locals() 11079 for key, val in iteritems(params['kwargs']): 11080 if key not in all_params: 11081 raise TypeError( 11082 "Got an unexpected keyword argument '%s'" 11083 " to method list_templates" % key 11084 ) 11085 params[key] = val 11086 del params['kwargs'] 11087 # verify the required parameter 'account_id' is set 11088 if ('account_id' not in params) or (params['account_id'] is None): 11089 raise ValueError("Missing the required parameter `account_id` when calling `list_templates`") 11090 # verify the required parameter 'envelope_id' is set 11091 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11092 raise ValueError("Missing the required parameter `envelope_id` when calling `list_templates`") 11093 11094 11095 collection_formats = {} 11096 11097 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/templates'.replace('{format}', 'json') 11098 path_params = {} 11099 if 'account_id' in params: 11100 path_params['accountId'] = params['account_id'] 11101 if 'envelope_id' in params: 11102 path_params['envelopeId'] = params['envelope_id'] 11103 11104 query_params = {} 11105 if 'include' in params: 11106 query_params['include'] = params['include'] 11107 11108 header_params = {} 11109 11110 form_params = [] 11111 local_var_files = {} 11112 11113 body_params = None 11114 # HTTP header `Accept` 11115 header_params['Accept'] = self.api_client.\ 11116 select_header_accept(['application/json']) 11117 11118 # Authentication setting 11119 auth_settings = [] 11120 11121 return self.api_client.call_api(resource_path, 'GET', 11122 path_params, 11123 query_params, 11124 header_params, 11125 body=body_params, 11126 post_params=form_params, 11127 files=local_var_files, 11128 response_type='TemplateInformation', 11129 auth_settings=auth_settings, 11130 callback=params.get('callback'), 11131 _return_http_data_only=params.get('_return_http_data_only'), 11132 _preload_content=params.get('_preload_content', True), 11133 _request_timeout=params.get('_request_timeout'), 11134 collection_formats=collection_formats) 11135 11136 def list_templates_for_document(self, account_id, document_id, envelope_id, **kwargs): 11137 """ 11138 Gets the templates associated with a document in an existing envelope. 11139 Retrieves the templates associated with a document in the specified envelope. 11140 This method makes a synchronous HTTP request by default. To make an 11141 asynchronous HTTP request, please define a `callback` function 11142 to be invoked when receiving the response. 11143 >>> def callback_function(response): 11144 >>> pprint(response) 11145 >>> 11146 >>> thread = api.list_templates_for_document(account_id, document_id, envelope_id, callback=callback_function) 11147 11148 :param callback function: The callback function 11149 for asynchronous request. (optional) 11150 :param str account_id: The external account number (int) or account ID Guid. (required) 11151 :param str document_id: The ID of the document being accessed. (required) 11152 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11153 :param str include: 11154 :return: TemplateInformation 11155 If the method is called asynchronously, 11156 returns the request thread. 11157 """ 11158 kwargs['_return_http_data_only'] = True 11159 if kwargs.get('callback'): 11160 return self.list_templates_for_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 11161 else: 11162 (data) = self.list_templates_for_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 11163 return data 11164 11165 def list_templates_for_document_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 11166 """ 11167 Gets the templates associated with a document in an existing envelope. 11168 Retrieves the templates associated with a document in the specified envelope. 11169 This method makes a synchronous HTTP request by default. To make an 11170 asynchronous HTTP request, please define a `callback` function 11171 to be invoked when receiving the response. 11172 >>> def callback_function(response): 11173 >>> pprint(response) 11174 >>> 11175 >>> thread = api.list_templates_for_document_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 11176 11177 :param callback function: The callback function 11178 for asynchronous request. (optional) 11179 :param str account_id: The external account number (int) or account ID Guid. (required) 11180 :param str document_id: The ID of the document being accessed. (required) 11181 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11182 :param str include: 11183 :return: TemplateInformation 11184 If the method is called asynchronously, 11185 returns the request thread. 11186 """ 11187 11188 all_params = ['account_id', 'document_id', 'envelope_id', 'include'] 11189 all_params.append('callback') 11190 all_params.append('_return_http_data_only') 11191 all_params.append('_preload_content') 11192 all_params.append('_request_timeout') 11193 11194 params = locals() 11195 for key, val in iteritems(params['kwargs']): 11196 if key not in all_params: 11197 raise TypeError( 11198 "Got an unexpected keyword argument '%s'" 11199 " to method list_templates_for_document" % key 11200 ) 11201 params[key] = val 11202 del params['kwargs'] 11203 # verify the required parameter 'account_id' is set 11204 if ('account_id' not in params) or (params['account_id'] is None): 11205 raise ValueError("Missing the required parameter `account_id` when calling `list_templates_for_document`") 11206 # verify the required parameter 'document_id' is set 11207 if ('document_id' not in params) or (params['document_id'] is None): 11208 raise ValueError("Missing the required parameter `document_id` when calling `list_templates_for_document`") 11209 # verify the required parameter 'envelope_id' is set 11210 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11211 raise ValueError("Missing the required parameter `envelope_id` when calling `list_templates_for_document`") 11212 11213 11214 collection_formats = {} 11215 11216 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/templates'.replace('{format}', 'json') 11217 path_params = {} 11218 if 'account_id' in params: 11219 path_params['accountId'] = params['account_id'] 11220 if 'document_id' in params: 11221 path_params['documentId'] = params['document_id'] 11222 if 'envelope_id' in params: 11223 path_params['envelopeId'] = params['envelope_id'] 11224 11225 query_params = {} 11226 if 'include' in params: 11227 query_params['include'] = params['include'] 11228 11229 header_params = {} 11230 11231 form_params = [] 11232 local_var_files = {} 11233 11234 body_params = None 11235 # HTTP header `Accept` 11236 header_params['Accept'] = self.api_client.\ 11237 select_header_accept(['application/json']) 11238 11239 # Authentication setting 11240 auth_settings = [] 11241 11242 return self.api_client.call_api(resource_path, 'GET', 11243 path_params, 11244 query_params, 11245 header_params, 11246 body=body_params, 11247 post_params=form_params, 11248 files=local_var_files, 11249 response_type='TemplateInformation', 11250 auth_settings=auth_settings, 11251 callback=params.get('callback'), 11252 _return_http_data_only=params.get('_return_http_data_only'), 11253 _preload_content=params.get('_preload_content', True), 11254 _request_timeout=params.get('_request_timeout'), 11255 collection_formats=collection_formats) 11256 11257 def put_attachment(self, account_id, attachment_id, envelope_id, **kwargs): 11258 """ 11259 Add an attachment to a DRAFT or IN-PROCESS envelope. 11260 Adds an attachment to a draft or in-process envelope. 11261 This method makes a synchronous HTTP request by default. To make an 11262 asynchronous HTTP request, please define a `callback` function 11263 to be invoked when receiving the response. 11264 >>> def callback_function(response): 11265 >>> pprint(response) 11266 >>> 11267 >>> thread = api.put_attachment(account_id, attachment_id, envelope_id, callback=callback_function) 11268 11269 :param callback function: The callback function 11270 for asynchronous request. (optional) 11271 :param str account_id: The external account number (int) or account ID Guid. (required) 11272 :param str attachment_id: (required) 11273 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11274 :param Attachment attachment: 11275 :return: EnvelopeAttachmentsResult 11276 If the method is called asynchronously, 11277 returns the request thread. 11278 """ 11279 kwargs['_return_http_data_only'] = True 11280 if kwargs.get('callback'): 11281 return self.put_attachment_with_http_info(account_id, attachment_id, envelope_id, **kwargs) 11282 else: 11283 (data) = self.put_attachment_with_http_info(account_id, attachment_id, envelope_id, **kwargs) 11284 return data 11285 11286 def put_attachment_with_http_info(self, account_id, attachment_id, envelope_id, **kwargs): 11287 """ 11288 Add an attachment to a DRAFT or IN-PROCESS envelope. 11289 Adds an attachment to a draft or in-process envelope. 11290 This method makes a synchronous HTTP request by default. To make an 11291 asynchronous HTTP request, please define a `callback` function 11292 to be invoked when receiving the response. 11293 >>> def callback_function(response): 11294 >>> pprint(response) 11295 >>> 11296 >>> thread = api.put_attachment_with_http_info(account_id, attachment_id, envelope_id, callback=callback_function) 11297 11298 :param callback function: The callback function 11299 for asynchronous request. (optional) 11300 :param str account_id: The external account number (int) or account ID Guid. (required) 11301 :param str attachment_id: (required) 11302 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11303 :param Attachment attachment: 11304 :return: EnvelopeAttachmentsResult 11305 If the method is called asynchronously, 11306 returns the request thread. 11307 """ 11308 11309 all_params = ['account_id', 'attachment_id', 'envelope_id', 'attachment'] 11310 all_params.append('callback') 11311 all_params.append('_return_http_data_only') 11312 all_params.append('_preload_content') 11313 all_params.append('_request_timeout') 11314 11315 params = locals() 11316 for key, val in iteritems(params['kwargs']): 11317 if key not in all_params: 11318 raise TypeError( 11319 "Got an unexpected keyword argument '%s'" 11320 " to method put_attachment" % key 11321 ) 11322 params[key] = val 11323 del params['kwargs'] 11324 # verify the required parameter 'account_id' is set 11325 if ('account_id' not in params) or (params['account_id'] is None): 11326 raise ValueError("Missing the required parameter `account_id` when calling `put_attachment`") 11327 # verify the required parameter 'attachment_id' is set 11328 if ('attachment_id' not in params) or (params['attachment_id'] is None): 11329 raise ValueError("Missing the required parameter `attachment_id` when calling `put_attachment`") 11330 # verify the required parameter 'envelope_id' is set 11331 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11332 raise ValueError("Missing the required parameter `envelope_id` when calling `put_attachment`") 11333 11334 11335 collection_formats = {} 11336 11337 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments/{attachmentId}'.replace('{format}', 'json') 11338 path_params = {} 11339 if 'account_id' in params: 11340 path_params['accountId'] = params['account_id'] 11341 if 'attachment_id' in params: 11342 path_params['attachmentId'] = params['attachment_id'] 11343 if 'envelope_id' in params: 11344 path_params['envelopeId'] = params['envelope_id'] 11345 11346 query_params = {} 11347 11348 header_params = {} 11349 11350 form_params = [] 11351 local_var_files = {} 11352 11353 body_params = None 11354 if 'attachment' in params: 11355 body_params = params['attachment'] 11356 # HTTP header `Accept` 11357 header_params['Accept'] = self.api_client.\ 11358 select_header_accept(['application/json']) 11359 11360 # Authentication setting 11361 auth_settings = [] 11362 11363 return self.api_client.call_api(resource_path, 'PUT', 11364 path_params, 11365 query_params, 11366 header_params, 11367 body=body_params, 11368 post_params=form_params, 11369 files=local_var_files, 11370 response_type='EnvelopeAttachmentsResult', 11371 auth_settings=auth_settings, 11372 callback=params.get('callback'), 11373 _return_http_data_only=params.get('_return_http_data_only'), 11374 _preload_content=params.get('_preload_content', True), 11375 _request_timeout=params.get('_request_timeout'), 11376 collection_formats=collection_formats) 11377 11378 def put_attachments(self, account_id, envelope_id, **kwargs): 11379 """ 11380 Add one or more attachments to a DRAFT or IN-PROCESS envelope. 11381 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). 11382 This method makes a synchronous HTTP request by default. To make an 11383 asynchronous HTTP request, please define a `callback` function 11384 to be invoked when receiving the response. 11385 >>> def callback_function(response): 11386 >>> pprint(response) 11387 >>> 11388 >>> thread = api.put_attachments(account_id, envelope_id, callback=callback_function) 11389 11390 :param callback function: The callback function 11391 for asynchronous request. (optional) 11392 :param str account_id: The external account number (int) or account ID Guid. (required) 11393 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11394 :param EnvelopeAttachmentsRequest envelope_attachments_request: 11395 :return: EnvelopeAttachmentsResult 11396 If the method is called asynchronously, 11397 returns the request thread. 11398 """ 11399 kwargs['_return_http_data_only'] = True 11400 if kwargs.get('callback'): 11401 return self.put_attachments_with_http_info(account_id, envelope_id, **kwargs) 11402 else: 11403 (data) = self.put_attachments_with_http_info(account_id, envelope_id, **kwargs) 11404 return data 11405 11406 def put_attachments_with_http_info(self, account_id, envelope_id, **kwargs): 11407 """ 11408 Add one or more attachments to a DRAFT or IN-PROCESS envelope. 11409 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). 11410 This method makes a synchronous HTTP request by default. To make an 11411 asynchronous HTTP request, please define a `callback` function 11412 to be invoked when receiving the response. 11413 >>> def callback_function(response): 11414 >>> pprint(response) 11415 >>> 11416 >>> thread = api.put_attachments_with_http_info(account_id, envelope_id, callback=callback_function) 11417 11418 :param callback function: The callback function 11419 for asynchronous request. (optional) 11420 :param str account_id: The external account number (int) or account ID Guid. (required) 11421 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11422 :param EnvelopeAttachmentsRequest envelope_attachments_request: 11423 :return: EnvelopeAttachmentsResult 11424 If the method is called asynchronously, 11425 returns the request thread. 11426 """ 11427 11428 all_params = ['account_id', 'envelope_id', 'envelope_attachments_request'] 11429 all_params.append('callback') 11430 all_params.append('_return_http_data_only') 11431 all_params.append('_preload_content') 11432 all_params.append('_request_timeout') 11433 11434 params = locals() 11435 for key, val in iteritems(params['kwargs']): 11436 if key not in all_params: 11437 raise TypeError( 11438 "Got an unexpected keyword argument '%s'" 11439 " to method put_attachments" % key 11440 ) 11441 params[key] = val 11442 del params['kwargs'] 11443 # verify the required parameter 'account_id' is set 11444 if ('account_id' not in params) or (params['account_id'] is None): 11445 raise ValueError("Missing the required parameter `account_id` when calling `put_attachments`") 11446 # verify the required parameter 'envelope_id' is set 11447 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11448 raise ValueError("Missing the required parameter `envelope_id` when calling `put_attachments`") 11449 11450 11451 collection_formats = {} 11452 11453 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments'.replace('{format}', 'json') 11454 path_params = {} 11455 if 'account_id' in params: 11456 path_params['accountId'] = params['account_id'] 11457 if 'envelope_id' in params: 11458 path_params['envelopeId'] = params['envelope_id'] 11459 11460 query_params = {} 11461 11462 header_params = {} 11463 11464 form_params = [] 11465 local_var_files = {} 11466 11467 body_params = None 11468 if 'envelope_attachments_request' in params: 11469 body_params = params['envelope_attachments_request'] 11470 # HTTP header `Accept` 11471 header_params['Accept'] = self.api_client.\ 11472 select_header_accept(['application/json']) 11473 11474 # Authentication setting 11475 auth_settings = [] 11476 11477 return self.api_client.call_api(resource_path, 'PUT', 11478 path_params, 11479 query_params, 11480 header_params, 11481 body=body_params, 11482 post_params=form_params, 11483 files=local_var_files, 11484 response_type='EnvelopeAttachmentsResult', 11485 auth_settings=auth_settings, 11486 callback=params.get('callback'), 11487 _return_http_data_only=params.get('_return_http_data_only'), 11488 _preload_content=params.get('_preload_content', True), 11489 _request_timeout=params.get('_request_timeout'), 11490 collection_formats=collection_formats) 11491 11492 def rotate_document_page(self, account_id, document_id, envelope_id, page_number, **kwargs): 11493 """ 11494 Rotates page image from an envelope for display. 11495 Rotates page image from an envelope for display. The page image can be rotated to the left or right. 11496 This method makes a synchronous HTTP request by default. To make an 11497 asynchronous HTTP request, please define a `callback` function 11498 to be invoked when receiving the response. 11499 >>> def callback_function(response): 11500 >>> pprint(response) 11501 >>> 11502 >>> thread = api.rotate_document_page(account_id, document_id, envelope_id, page_number, callback=callback_function) 11503 11504 :param callback function: The callback function 11505 for asynchronous request. (optional) 11506 :param str account_id: The external account number (int) or account ID Guid. (required) 11507 :param str document_id: The ID of the document being accessed. (required) 11508 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11509 :param str page_number: The page number being accessed. (required) 11510 :param PageRequest page_request: 11511 :return: None 11512 If the method is called asynchronously, 11513 returns the request thread. 11514 """ 11515 kwargs['_return_http_data_only'] = True 11516 if kwargs.get('callback'): 11517 return self.rotate_document_page_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 11518 else: 11519 (data) = self.rotate_document_page_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 11520 return data 11521 11522 def rotate_document_page_with_http_info(self, account_id, document_id, envelope_id, page_number, **kwargs): 11523 """ 11524 Rotates page image from an envelope for display. 11525 Rotates page image from an envelope for display. The page image can be rotated to the left or right. 11526 This method makes a synchronous HTTP request by default. To make an 11527 asynchronous HTTP request, please define a `callback` function 11528 to be invoked when receiving the response. 11529 >>> def callback_function(response): 11530 >>> pprint(response) 11531 >>> 11532 >>> thread = api.rotate_document_page_with_http_info(account_id, document_id, envelope_id, page_number, callback=callback_function) 11533 11534 :param callback function: The callback function 11535 for asynchronous request. (optional) 11536 :param str account_id: The external account number (int) or account ID Guid. (required) 11537 :param str document_id: The ID of the document being accessed. (required) 11538 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11539 :param str page_number: The page number being accessed. (required) 11540 :param PageRequest page_request: 11541 :return: None 11542 If the method is called asynchronously, 11543 returns the request thread. 11544 """ 11545 11546 all_params = ['account_id', 'document_id', 'envelope_id', 'page_number', 'page_request'] 11547 all_params.append('callback') 11548 all_params.append('_return_http_data_only') 11549 all_params.append('_preload_content') 11550 all_params.append('_request_timeout') 11551 11552 params = locals() 11553 for key, val in iteritems(params['kwargs']): 11554 if key not in all_params: 11555 raise TypeError( 11556 "Got an unexpected keyword argument '%s'" 11557 " to method rotate_document_page" % key 11558 ) 11559 params[key] = val 11560 del params['kwargs'] 11561 # verify the required parameter 'account_id' is set 11562 if ('account_id' not in params) or (params['account_id'] is None): 11563 raise ValueError("Missing the required parameter `account_id` when calling `rotate_document_page`") 11564 # verify the required parameter 'document_id' is set 11565 if ('document_id' not in params) or (params['document_id'] is None): 11566 raise ValueError("Missing the required parameter `document_id` when calling `rotate_document_page`") 11567 # verify the required parameter 'envelope_id' is set 11568 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11569 raise ValueError("Missing the required parameter `envelope_id` when calling `rotate_document_page`") 11570 # verify the required parameter 'page_number' is set 11571 if ('page_number' not in params) or (params['page_number'] is None): 11572 raise ValueError("Missing the required parameter `page_number` when calling `rotate_document_page`") 11573 11574 11575 collection_formats = {} 11576 11577 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/pages/{pageNumber}/page_image'.replace('{format}', 'json') 11578 path_params = {} 11579 if 'account_id' in params: 11580 path_params['accountId'] = params['account_id'] 11581 if 'document_id' in params: 11582 path_params['documentId'] = params['document_id'] 11583 if 'envelope_id' in params: 11584 path_params['envelopeId'] = params['envelope_id'] 11585 if 'page_number' in params: 11586 path_params['pageNumber'] = params['page_number'] 11587 11588 query_params = {} 11589 11590 header_params = {} 11591 11592 form_params = [] 11593 local_var_files = {} 11594 11595 body_params = None 11596 if 'page_request' in params: 11597 body_params = params['page_request'] 11598 # HTTP header `Accept` 11599 header_params['Accept'] = self.api_client.\ 11600 select_header_accept(['application/json']) 11601 11602 # Authentication setting 11603 auth_settings = [] 11604 11605 return self.api_client.call_api(resource_path, 'PUT', 11606 path_params, 11607 query_params, 11608 header_params, 11609 body=body_params, 11610 post_params=form_params, 11611 files=local_var_files, 11612 response_type=None, 11613 auth_settings=auth_settings, 11614 callback=params.get('callback'), 11615 _return_http_data_only=params.get('_return_http_data_only'), 11616 _preload_content=params.get('_preload_content', True), 11617 _request_timeout=params.get('_request_timeout'), 11618 collection_formats=collection_formats) 11619 11620 def update(self, account_id, envelope_id, **kwargs): 11621 """ 11622 Send Draft Envelope/Void Envelope/Move/Purge Envelope/Modify draft 11623 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. 11624 This method makes a synchronous HTTP request by default. To make an 11625 asynchronous HTTP request, please define a `callback` function 11626 to be invoked when receiving the response. 11627 >>> def callback_function(response): 11628 >>> pprint(response) 11629 >>> 11630 >>> thread = api.update(account_id, envelope_id, callback=callback_function) 11631 11632 :param callback function: The callback function 11633 for asynchronous request. (optional) 11634 :param str account_id: The external account number (int) or account ID Guid. (required) 11635 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11636 :param str advanced_update: When set to **true**, allows the caller to update recipients, tabs, custom fields, notification, email settings and other envelope attributes. 11637 :param str recycle_on_void: 11638 :param str resend_envelope: When set to **true**, sends the specified envelope again. 11639 :param Envelope envelope: 11640 :return: EnvelopeUpdateSummary 11641 If the method is called asynchronously, 11642 returns the request thread. 11643 """ 11644 kwargs['_return_http_data_only'] = True 11645 if kwargs.get('callback'): 11646 return self.update_with_http_info(account_id, envelope_id, **kwargs) 11647 else: 11648 (data) = self.update_with_http_info(account_id, envelope_id, **kwargs) 11649 return data 11650 11651 def update_with_http_info(self, account_id, envelope_id, **kwargs): 11652 """ 11653 Send Draft Envelope/Void Envelope/Move/Purge Envelope/Modify draft 11654 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. 11655 This method makes a synchronous HTTP request by default. To make an 11656 asynchronous HTTP request, please define a `callback` function 11657 to be invoked when receiving the response. 11658 >>> def callback_function(response): 11659 >>> pprint(response) 11660 >>> 11661 >>> thread = api.update_with_http_info(account_id, envelope_id, callback=callback_function) 11662 11663 :param callback function: The callback function 11664 for asynchronous request. (optional) 11665 :param str account_id: The external account number (int) or account ID Guid. (required) 11666 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11667 :param str advanced_update: When set to **true**, allows the caller to update recipients, tabs, custom fields, notification, email settings and other envelope attributes. 11668 :param str recycle_on_void: 11669 :param str resend_envelope: When set to **true**, sends the specified envelope again. 11670 :param Envelope envelope: 11671 :return: EnvelopeUpdateSummary 11672 If the method is called asynchronously, 11673 returns the request thread. 11674 """ 11675 11676 all_params = ['account_id', 'envelope_id', 'advanced_update', 'recycle_on_void', 'resend_envelope', 'envelope'] 11677 all_params.append('callback') 11678 all_params.append('_return_http_data_only') 11679 all_params.append('_preload_content') 11680 all_params.append('_request_timeout') 11681 11682 params = locals() 11683 for key, val in iteritems(params['kwargs']): 11684 if key not in all_params: 11685 raise TypeError( 11686 "Got an unexpected keyword argument '%s'" 11687 " to method update" % key 11688 ) 11689 params[key] = val 11690 del params['kwargs'] 11691 # verify the required parameter 'account_id' is set 11692 if ('account_id' not in params) or (params['account_id'] is None): 11693 raise ValueError("Missing the required parameter `account_id` when calling `update`") 11694 # verify the required parameter 'envelope_id' is set 11695 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11696 raise ValueError("Missing the required parameter `envelope_id` when calling `update`") 11697 11698 11699 collection_formats = {} 11700 11701 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}'.replace('{format}', 'json') 11702 path_params = {} 11703 if 'account_id' in params: 11704 path_params['accountId'] = params['account_id'] 11705 if 'envelope_id' in params: 11706 path_params['envelopeId'] = params['envelope_id'] 11707 11708 query_params = {} 11709 if 'advanced_update' in params: 11710 query_params['advanced_update'] = params['advanced_update'] 11711 if 'recycle_on_void' in params: 11712 query_params['recycle_on_void'] = params['recycle_on_void'] 11713 if 'resend_envelope' in params: 11714 query_params['resend_envelope'] = params['resend_envelope'] 11715 11716 header_params = {} 11717 11718 form_params = [] 11719 local_var_files = {} 11720 11721 body_params = None 11722 if 'envelope' in params: 11723 body_params = params['envelope'] 11724 # HTTP header `Accept` 11725 header_params['Accept'] = self.api_client.\ 11726 select_header_accept(['application/json']) 11727 11728 # Authentication setting 11729 auth_settings = [] 11730 11731 return self.api_client.call_api(resource_path, 'PUT', 11732 path_params, 11733 query_params, 11734 header_params, 11735 body=body_params, 11736 post_params=form_params, 11737 files=local_var_files, 11738 response_type='EnvelopeUpdateSummary', 11739 auth_settings=auth_settings, 11740 callback=params.get('callback'), 11741 _return_http_data_only=params.get('_return_http_data_only'), 11742 _preload_content=params.get('_preload_content', True), 11743 _request_timeout=params.get('_request_timeout'), 11744 collection_formats=collection_formats) 11745 11746 def update_chunked_upload(self, account_id, chunked_upload_id, **kwargs): 11747 """ 11748 Integrity-Check and Commit a ChunkedUpload, readying it for use elsewhere. 11749 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. 11750 This method makes a synchronous HTTP request by default. To make an 11751 asynchronous HTTP request, please define a `callback` function 11752 to be invoked when receiving the response. 11753 >>> def callback_function(response): 11754 >>> pprint(response) 11755 >>> 11756 >>> thread = api.update_chunked_upload(account_id, chunked_upload_id, callback=callback_function) 11757 11758 :param callback function: The callback function 11759 for asynchronous request. (optional) 11760 :param str account_id: The external account number (int) or account ID Guid. (required) 11761 :param str chunked_upload_id: (required) 11762 :param str action: 11763 :return: ChunkedUploadResponse 11764 If the method is called asynchronously, 11765 returns the request thread. 11766 """ 11767 kwargs['_return_http_data_only'] = True 11768 if kwargs.get('callback'): 11769 return self.update_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 11770 else: 11771 (data) = self.update_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 11772 return data 11773 11774 def update_chunked_upload_with_http_info(self, account_id, chunked_upload_id, **kwargs): 11775 """ 11776 Integrity-Check and Commit a ChunkedUpload, readying it for use elsewhere. 11777 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. 11778 This method makes a synchronous HTTP request by default. To make an 11779 asynchronous HTTP request, please define a `callback` function 11780 to be invoked when receiving the response. 11781 >>> def callback_function(response): 11782 >>> pprint(response) 11783 >>> 11784 >>> thread = api.update_chunked_upload_with_http_info(account_id, chunked_upload_id, callback=callback_function) 11785 11786 :param callback function: The callback function 11787 for asynchronous request. (optional) 11788 :param str account_id: The external account number (int) or account ID Guid. (required) 11789 :param str chunked_upload_id: (required) 11790 :param str action: 11791 :return: ChunkedUploadResponse 11792 If the method is called asynchronously, 11793 returns the request thread. 11794 """ 11795 11796 all_params = ['account_id', 'chunked_upload_id', 'action'] 11797 all_params.append('callback') 11798 all_params.append('_return_http_data_only') 11799 all_params.append('_preload_content') 11800 all_params.append('_request_timeout') 11801 11802 params = locals() 11803 for key, val in iteritems(params['kwargs']): 11804 if key not in all_params: 11805 raise TypeError( 11806 "Got an unexpected keyword argument '%s'" 11807 " to method update_chunked_upload" % key 11808 ) 11809 params[key] = val 11810 del params['kwargs'] 11811 # verify the required parameter 'account_id' is set 11812 if ('account_id' not in params) or (params['account_id'] is None): 11813 raise ValueError("Missing the required parameter `account_id` when calling `update_chunked_upload`") 11814 # verify the required parameter 'chunked_upload_id' is set 11815 if ('chunked_upload_id' not in params) or (params['chunked_upload_id'] is None): 11816 raise ValueError("Missing the required parameter `chunked_upload_id` when calling `update_chunked_upload`") 11817 11818 11819 collection_formats = {} 11820 11821 resource_path = '/v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}'.replace('{format}', 'json') 11822 path_params = {} 11823 if 'account_id' in params: 11824 path_params['accountId'] = params['account_id'] 11825 if 'chunked_upload_id' in params: 11826 path_params['chunkedUploadId'] = params['chunked_upload_id'] 11827 11828 query_params = {} 11829 if 'action' in params: 11830 query_params['action'] = params['action'] 11831 11832 header_params = {} 11833 11834 form_params = [] 11835 local_var_files = {} 11836 11837 body_params = None 11838 # HTTP header `Accept` 11839 header_params['Accept'] = self.api_client.\ 11840 select_header_accept(['application/json']) 11841 11842 # Authentication setting 11843 auth_settings = [] 11844 11845 return self.api_client.call_api(resource_path, 'PUT', 11846 path_params, 11847 query_params, 11848 header_params, 11849 body=body_params, 11850 post_params=form_params, 11851 files=local_var_files, 11852 response_type='ChunkedUploadResponse', 11853 auth_settings=auth_settings, 11854 callback=params.get('callback'), 11855 _return_http_data_only=params.get('_return_http_data_only'), 11856 _preload_content=params.get('_preload_content', True), 11857 _request_timeout=params.get('_request_timeout'), 11858 collection_formats=collection_formats) 11859 11860 def update_chunked_upload_part(self, account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs): 11861 """ 11862 Add a chunk, a chunk 'part', to an existing ChunkedUpload. 11863 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. 11864 This method makes a synchronous HTTP request by default. To make an 11865 asynchronous HTTP request, please define a `callback` function 11866 to be invoked when receiving the response. 11867 >>> def callback_function(response): 11868 >>> pprint(response) 11869 >>> 11870 >>> thread = api.update_chunked_upload_part(account_id, chunked_upload_id, chunked_upload_part_seq, callback=callback_function) 11871 11872 :param callback function: The callback function 11873 for asynchronous request. (optional) 11874 :param str account_id: The external account number (int) or account ID Guid. (required) 11875 :param str chunked_upload_id: (required) 11876 :param str chunked_upload_part_seq: (required) 11877 :param ChunkedUploadRequest chunked_upload_request: 11878 :return: ChunkedUploadResponse 11879 If the method is called asynchronously, 11880 returns the request thread. 11881 """ 11882 kwargs['_return_http_data_only'] = True 11883 if kwargs.get('callback'): 11884 return self.update_chunked_upload_part_with_http_info(account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs) 11885 else: 11886 (data) = self.update_chunked_upload_part_with_http_info(account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs) 11887 return data 11888 11889 def update_chunked_upload_part_with_http_info(self, account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs): 11890 """ 11891 Add a chunk, a chunk 'part', to an existing ChunkedUpload. 11892 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. 11893 This method makes a synchronous HTTP request by default. To make an 11894 asynchronous HTTP request, please define a `callback` function 11895 to be invoked when receiving the response. 11896 >>> def callback_function(response): 11897 >>> pprint(response) 11898 >>> 11899 >>> thread = api.update_chunked_upload_part_with_http_info(account_id, chunked_upload_id, chunked_upload_part_seq, callback=callback_function) 11900 11901 :param callback function: The callback function 11902 for asynchronous request. (optional) 11903 :param str account_id: The external account number (int) or account ID Guid. (required) 11904 :param str chunked_upload_id: (required) 11905 :param str chunked_upload_part_seq: (required) 11906 :param ChunkedUploadRequest chunked_upload_request: 11907 :return: ChunkedUploadResponse 11908 If the method is called asynchronously, 11909 returns the request thread. 11910 """ 11911 11912 all_params = ['account_id', 'chunked_upload_id', 'chunked_upload_part_seq', 'chunked_upload_request'] 11913 all_params.append('callback') 11914 all_params.append('_return_http_data_only') 11915 all_params.append('_preload_content') 11916 all_params.append('_request_timeout') 11917 11918 params = locals() 11919 for key, val in iteritems(params['kwargs']): 11920 if key not in all_params: 11921 raise TypeError( 11922 "Got an unexpected keyword argument '%s'" 11923 " to method update_chunked_upload_part" % key 11924 ) 11925 params[key] = val 11926 del params['kwargs'] 11927 # verify the required parameter 'account_id' is set 11928 if ('account_id' not in params) or (params['account_id'] is None): 11929 raise ValueError("Missing the required parameter `account_id` when calling `update_chunked_upload_part`") 11930 # verify the required parameter 'chunked_upload_id' is set 11931 if ('chunked_upload_id' not in params) or (params['chunked_upload_id'] is None): 11932 raise ValueError("Missing the required parameter `chunked_upload_id` when calling `update_chunked_upload_part`") 11933 # verify the required parameter 'chunked_upload_part_seq' is set 11934 if ('chunked_upload_part_seq' not in params) or (params['chunked_upload_part_seq'] is None): 11935 raise ValueError("Missing the required parameter `chunked_upload_part_seq` when calling `update_chunked_upload_part`") 11936 11937 11938 collection_formats = {} 11939 11940 resource_path = '/v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}/{chunkedUploadPartSeq}'.replace('{format}', 'json') 11941 path_params = {} 11942 if 'account_id' in params: 11943 path_params['accountId'] = params['account_id'] 11944 if 'chunked_upload_id' in params: 11945 path_params['chunkedUploadId'] = params['chunked_upload_id'] 11946 if 'chunked_upload_part_seq' in params: 11947 path_params['chunkedUploadPartSeq'] = params['chunked_upload_part_seq'] 11948 11949 query_params = {} 11950 11951 header_params = {} 11952 11953 form_params = [] 11954 local_var_files = {} 11955 11956 body_params = None 11957 if 'chunked_upload_request' in params: 11958 body_params = params['chunked_upload_request'] 11959 # HTTP header `Accept` 11960 header_params['Accept'] = self.api_client.\ 11961 select_header_accept(['application/json']) 11962 11963 # Authentication setting 11964 auth_settings = [] 11965 11966 return self.api_client.call_api(resource_path, 'PUT', 11967 path_params, 11968 query_params, 11969 header_params, 11970 body=body_params, 11971 post_params=form_params, 11972 files=local_var_files, 11973 response_type='ChunkedUploadResponse', 11974 auth_settings=auth_settings, 11975 callback=params.get('callback'), 11976 _return_http_data_only=params.get('_return_http_data_only'), 11977 _preload_content=params.get('_preload_content', True), 11978 _request_timeout=params.get('_request_timeout'), 11979 collection_formats=collection_formats) 11980 11981 def update_custom_fields(self, account_id, envelope_id, **kwargs): 11982 """ 11983 Updates envelope custom fields in an envelope. 11984 Updates the envelope custom fields in draft and in-process envelopes. Each custom field used in an envelope must have a unique name. 11985 This method makes a synchronous HTTP request by default. To make an 11986 asynchronous HTTP request, please define a `callback` function 11987 to be invoked when receiving the response. 11988 >>> def callback_function(response): 11989 >>> pprint(response) 11990 >>> 11991 >>> thread = api.update_custom_fields(account_id, envelope_id, callback=callback_function) 11992 11993 :param callback function: The callback function 11994 for asynchronous request. (optional) 11995 :param str account_id: The external account number (int) or account ID Guid. (required) 11996 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11997 :param CustomFields custom_fields: 11998 :return: CustomFields 11999 If the method is called asynchronously, 12000 returns the request thread. 12001 """ 12002 kwargs['_return_http_data_only'] = True 12003 if kwargs.get('callback'): 12004 return self.update_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 12005 else: 12006 (data) = self.update_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 12007 return data 12008 12009 def update_custom_fields_with_http_info(self, account_id, envelope_id, **kwargs): 12010 """ 12011 Updates envelope custom fields in an envelope. 12012 Updates the envelope custom fields in draft and in-process envelopes. Each custom field used in an envelope must have a unique name. 12013 This method makes a synchronous HTTP request by default. To make an 12014 asynchronous HTTP request, please define a `callback` function 12015 to be invoked when receiving the response. 12016 >>> def callback_function(response): 12017 >>> pprint(response) 12018 >>> 12019 >>> thread = api.update_custom_fields_with_http_info(account_id, envelope_id, callback=callback_function) 12020 12021 :param callback function: The callback function 12022 for asynchronous request. (optional) 12023 :param str account_id: The external account number (int) or account ID Guid. (required) 12024 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12025 :param CustomFields custom_fields: 12026 :return: CustomFields 12027 If the method is called asynchronously, 12028 returns the request thread. 12029 """ 12030 12031 all_params = ['account_id', 'envelope_id', 'custom_fields'] 12032 all_params.append('callback') 12033 all_params.append('_return_http_data_only') 12034 all_params.append('_preload_content') 12035 all_params.append('_request_timeout') 12036 12037 params = locals() 12038 for key, val in iteritems(params['kwargs']): 12039 if key not in all_params: 12040 raise TypeError( 12041 "Got an unexpected keyword argument '%s'" 12042 " to method update_custom_fields" % key 12043 ) 12044 params[key] = val 12045 del params['kwargs'] 12046 # verify the required parameter 'account_id' is set 12047 if ('account_id' not in params) or (params['account_id'] is None): 12048 raise ValueError("Missing the required parameter `account_id` when calling `update_custom_fields`") 12049 # verify the required parameter 'envelope_id' is set 12050 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12051 raise ValueError("Missing the required parameter `envelope_id` when calling `update_custom_fields`") 12052 12053 12054 collection_formats = {} 12055 12056 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/custom_fields'.replace('{format}', 'json') 12057 path_params = {} 12058 if 'account_id' in params: 12059 path_params['accountId'] = params['account_id'] 12060 if 'envelope_id' in params: 12061 path_params['envelopeId'] = params['envelope_id'] 12062 12063 query_params = {} 12064 12065 header_params = {} 12066 12067 form_params = [] 12068 local_var_files = {} 12069 12070 body_params = None 12071 if 'custom_fields' in params: 12072 body_params = params['custom_fields'] 12073 # HTTP header `Accept` 12074 header_params['Accept'] = self.api_client.\ 12075 select_header_accept(['application/json']) 12076 12077 # Authentication setting 12078 auth_settings = [] 12079 12080 return self.api_client.call_api(resource_path, 'PUT', 12081 path_params, 12082 query_params, 12083 header_params, 12084 body=body_params, 12085 post_params=form_params, 12086 files=local_var_files, 12087 response_type='CustomFields', 12088 auth_settings=auth_settings, 12089 callback=params.get('callback'), 12090 _return_http_data_only=params.get('_return_http_data_only'), 12091 _preload_content=params.get('_preload_content', True), 12092 _request_timeout=params.get('_request_timeout'), 12093 collection_formats=collection_formats) 12094 12095 def update_document(self, account_id, document_id, envelope_id, document_file_bytes, **kwargs): 12096 """ 12097 Adds a document to an existing draft envelope. 12098 Adds a document to an existing draft envelope. 12099 This method makes a synchronous HTTP request by default. To make an 12100 asynchronous HTTP request, please define a `callback` function 12101 to be invoked when receiving the response. 12102 >>> def callback_function(response): 12103 >>> pprint(response) 12104 >>> 12105 >>> thread = api.update_document(account_id, document_id, envelope_id, document_file_bytes, callback=callback_function) 12106 12107 :param callback function: The callback function 12108 for asynchronous request. (optional) 12109 :param str account_id: The external account number (int) or account ID Guid. (required) 12110 :param str document_id: The ID of the document being accessed. (required) 12111 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12112 :param str document_file_bytes: Updated document content. (required) 12113 :return: EnvelopeDocument 12114 If the method is called asynchronously, 12115 returns the request thread. 12116 """ 12117 kwargs['_return_http_data_only'] = True 12118 if kwargs.get('callback'): 12119 return self.update_document_with_http_info(account_id, document_id, envelope_id, document_file_bytes, **kwargs) 12120 else: 12121 (data) = self.update_document_with_http_info(account_id, document_id, envelope_id, document_file_bytes, **kwargs) 12122 return data 12123 12124 def update_document_with_http_info(self, account_id, document_id, envelope_id, document_file_bytes, **kwargs): 12125 """ 12126 Adds a document to an existing draft envelope. 12127 Adds a document to an existing draft envelope. 12128 This method makes a synchronous HTTP request by default. To make an 12129 asynchronous HTTP request, please define a `callback` function 12130 to be invoked when receiving the response. 12131 >>> def callback_function(response): 12132 >>> pprint(response) 12133 >>> 12134 >>> thread = api.update_document_with_http_info(account_id, document_id, envelope_id, document_file_bytes, callback=callback_function) 12135 12136 :param callback function: The callback function 12137 for asynchronous request. (optional) 12138 :param str account_id: The external account number (int) or account ID Guid. (required) 12139 :param str document_id: The ID of the document being accessed. (required) 12140 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12141 :param str document_file_bytes: Updated document content. (required) 12142 :return: EnvelopeDocument 12143 If the method is called asynchronously, 12144 returns the request thread. 12145 """ 12146 12147 all_params = ['account_id', 'document_id', 'envelope_id', 'document_file_bytes'] 12148 all_params.append('callback') 12149 all_params.append('_return_http_data_only') 12150 all_params.append('_preload_content') 12151 all_params.append('_request_timeout') 12152 12153 params = locals() 12154 for key, val in iteritems(params['kwargs']): 12155 if key not in all_params: 12156 raise TypeError( 12157 "Got an unexpected keyword argument '%s'" 12158 " to method update_document" % key 12159 ) 12160 params[key] = val 12161 del params['kwargs'] 12162 # verify the required parameter 'account_id' is set 12163 if ('account_id' not in params) or (params['account_id'] is None): 12164 raise ValueError("Missing the required parameter `account_id` when calling `update_document`") 12165 # verify the required parameter 'document_id' is set 12166 if ('document_id' not in params) or (params['document_id'] is None): 12167 raise ValueError("Missing the required parameter `document_id` when calling `update_document`") 12168 # verify the required parameter 'envelope_id' is set 12169 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12170 raise ValueError("Missing the required parameter `envelope_id` when calling `update_document`") 12171 # verify the required parameter 'document_file_bytes' is set 12172 if ('document_file_bytes' not in params) or (params['document_file_bytes'] is None): 12173 raise ValueError("Missing the required parameter `document_file_bytes` when calling `update_document`") 12174 12175 12176 collection_formats = {} 12177 12178 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}'.replace('{format}', 'json') 12179 path_params = {} 12180 if 'account_id' in params: 12181 path_params['accountId'] = params['account_id'] 12182 if 'document_id' in params: 12183 path_params['documentId'] = params['document_id'] 12184 if 'envelope_id' in params: 12185 path_params['envelopeId'] = params['envelope_id'] 12186 12187 query_params = {} 12188 12189 header_params = {} 12190 12191 form_params = [] 12192 local_var_files = {} 12193 12194 body_params = None 12195 if 'document_file_bytes' in params: 12196 body_params = params['document_file_bytes'] 12197 # HTTP header `Accept` 12198 header_params['Accept'] = self.api_client.\ 12199 select_header_accept(['application/json']) 12200 12201 # HTTP header `Content-Type` 12202 header_params['Content-Type'] = self.api_client.\ 12203 select_header_content_type(['application/pdf']) 12204 12205 # Authentication setting 12206 auth_settings = [] 12207 12208 return self.api_client.call_api(resource_path, 'PUT', 12209 path_params, 12210 query_params, 12211 header_params, 12212 body=body_params, 12213 post_params=form_params, 12214 files=local_var_files, 12215 response_type='EnvelopeDocument', 12216 auth_settings=auth_settings, 12217 callback=params.get('callback'), 12218 _return_http_data_only=params.get('_return_http_data_only'), 12219 _preload_content=params.get('_preload_content', True), 12220 _request_timeout=params.get('_request_timeout'), 12221 collection_formats=collection_formats) 12222 12223 def update_document_fields(self, account_id, document_id, envelope_id, **kwargs): 12224 """ 12225 Updates existing custom document fields in an existing envelope document. 12226 Updates existing custom document fields in an existing envelope document. 12227 This method makes a synchronous HTTP request by default. To make an 12228 asynchronous HTTP request, please define a `callback` function 12229 to be invoked when receiving the response. 12230 >>> def callback_function(response): 12231 >>> pprint(response) 12232 >>> 12233 >>> thread = api.update_document_fields(account_id, document_id, envelope_id, callback=callback_function) 12234 12235 :param callback function: The callback function 12236 for asynchronous request. (optional) 12237 :param str account_id: The external account number (int) or account ID Guid. (required) 12238 :param str document_id: The ID of the document being accessed. (required) 12239 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12240 :param DocumentFieldsInformation document_fields_information: 12241 :return: DocumentFieldsInformation 12242 If the method is called asynchronously, 12243 returns the request thread. 12244 """ 12245 kwargs['_return_http_data_only'] = True 12246 if kwargs.get('callback'): 12247 return self.update_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 12248 else: 12249 (data) = self.update_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 12250 return data 12251 12252 def update_document_fields_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 12253 """ 12254 Updates existing custom document fields in an existing envelope document. 12255 Updates existing custom document fields in an existing envelope document. 12256 This method makes a synchronous HTTP request by default. To make an 12257 asynchronous HTTP request, please define a `callback` function 12258 to be invoked when receiving the response. 12259 >>> def callback_function(response): 12260 >>> pprint(response) 12261 >>> 12262 >>> thread = api.update_document_fields_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 12263 12264 :param callback function: The callback function 12265 for asynchronous request. (optional) 12266 :param str account_id: The external account number (int) or account ID Guid. (required) 12267 :param str document_id: The ID of the document being accessed. (required) 12268 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12269 :param DocumentFieldsInformation document_fields_information: 12270 :return: DocumentFieldsInformation 12271 If the method is called asynchronously, 12272 returns the request thread. 12273 """ 12274 12275 all_params = ['account_id', 'document_id', 'envelope_id', 'document_fields_information'] 12276 all_params.append('callback') 12277 all_params.append('_return_http_data_only') 12278 all_params.append('_preload_content') 12279 all_params.append('_request_timeout') 12280 12281 params = locals() 12282 for key, val in iteritems(params['kwargs']): 12283 if key not in all_params: 12284 raise TypeError( 12285 "Got an unexpected keyword argument '%s'" 12286 " to method update_document_fields" % key 12287 ) 12288 params[key] = val 12289 del params['kwargs'] 12290 # verify the required parameter 'account_id' is set 12291 if ('account_id' not in params) or (params['account_id'] is None): 12292 raise ValueError("Missing the required parameter `account_id` when calling `update_document_fields`") 12293 # verify the required parameter 'document_id' is set 12294 if ('document_id' not in params) or (params['document_id'] is None): 12295 raise ValueError("Missing the required parameter `document_id` when calling `update_document_fields`") 12296 # verify the required parameter 'envelope_id' is set 12297 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12298 raise ValueError("Missing the required parameter `envelope_id` when calling `update_document_fields`") 12299 12300 12301 collection_formats = {} 12302 12303 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/fields'.replace('{format}', 'json') 12304 path_params = {} 12305 if 'account_id' in params: 12306 path_params['accountId'] = params['account_id'] 12307 if 'document_id' in params: 12308 path_params['documentId'] = params['document_id'] 12309 if 'envelope_id' in params: 12310 path_params['envelopeId'] = params['envelope_id'] 12311 12312 query_params = {} 12313 12314 header_params = {} 12315 12316 form_params = [] 12317 local_var_files = {} 12318 12319 body_params = None 12320 if 'document_fields_information' in params: 12321 body_params = params['document_fields_information'] 12322 # HTTP header `Accept` 12323 header_params['Accept'] = self.api_client.\ 12324 select_header_accept(['application/json']) 12325 12326 # Authentication setting 12327 auth_settings = [] 12328 12329 return self.api_client.call_api(resource_path, 'PUT', 12330 path_params, 12331 query_params, 12332 header_params, 12333 body=body_params, 12334 post_params=form_params, 12335 files=local_var_files, 12336 response_type='DocumentFieldsInformation', 12337 auth_settings=auth_settings, 12338 callback=params.get('callback'), 12339 _return_http_data_only=params.get('_return_http_data_only'), 12340 _preload_content=params.get('_preload_content', True), 12341 _request_timeout=params.get('_request_timeout'), 12342 collection_formats=collection_formats) 12343 12344 def update_document_tabs(self, account_id, document_id, envelope_id, **kwargs): 12345 """ 12346 Updates the tabs for an envelope document 12347 Updates tabs in the document specified by `documentId` in the envelope specified by `envelopeId`. 12348 This method makes a synchronous HTTP request by default. To make an 12349 asynchronous HTTP request, please define a `callback` function 12350 to be invoked when receiving the response. 12351 >>> def callback_function(response): 12352 >>> pprint(response) 12353 >>> 12354 >>> thread = api.update_document_tabs(account_id, document_id, envelope_id, callback=callback_function) 12355 12356 :param callback function: The callback function 12357 for asynchronous request. (optional) 12358 :param str account_id: The external account number (int) or account ID Guid. (required) 12359 :param str document_id: The ID of the document being accessed. (required) 12360 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12361 :param Tabs tabs: 12362 :return: Tabs 12363 If the method is called asynchronously, 12364 returns the request thread. 12365 """ 12366 kwargs['_return_http_data_only'] = True 12367 if kwargs.get('callback'): 12368 return self.update_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 12369 else: 12370 (data) = self.update_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 12371 return data 12372 12373 def update_document_tabs_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 12374 """ 12375 Updates the tabs for an envelope document 12376 Updates tabs in the document specified by `documentId` in the envelope specified by `envelopeId`. 12377 This method makes a synchronous HTTP request by default. To make an 12378 asynchronous HTTP request, please define a `callback` function 12379 to be invoked when receiving the response. 12380 >>> def callback_function(response): 12381 >>> pprint(response) 12382 >>> 12383 >>> thread = api.update_document_tabs_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 12384 12385 :param callback function: The callback function 12386 for asynchronous request. (optional) 12387 :param str account_id: The external account number (int) or account ID Guid. (required) 12388 :param str document_id: The ID of the document being accessed. (required) 12389 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12390 :param Tabs tabs: 12391 :return: Tabs 12392 If the method is called asynchronously, 12393 returns the request thread. 12394 """ 12395 12396 all_params = ['account_id', 'document_id', 'envelope_id', 'tabs'] 12397 all_params.append('callback') 12398 all_params.append('_return_http_data_only') 12399 all_params.append('_preload_content') 12400 all_params.append('_request_timeout') 12401 12402 params = locals() 12403 for key, val in iteritems(params['kwargs']): 12404 if key not in all_params: 12405 raise TypeError( 12406 "Got an unexpected keyword argument '%s'" 12407 " to method update_document_tabs" % key 12408 ) 12409 params[key] = val 12410 del params['kwargs'] 12411 # verify the required parameter 'account_id' is set 12412 if ('account_id' not in params) or (params['account_id'] is None): 12413 raise ValueError("Missing the required parameter `account_id` when calling `update_document_tabs`") 12414 # verify the required parameter 'document_id' is set 12415 if ('document_id' not in params) or (params['document_id'] is None): 12416 raise ValueError("Missing the required parameter `document_id` when calling `update_document_tabs`") 12417 # verify the required parameter 'envelope_id' is set 12418 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12419 raise ValueError("Missing the required parameter `envelope_id` when calling `update_document_tabs`") 12420 12421 12422 collection_formats = {} 12423 12424 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/tabs'.replace('{format}', 'json') 12425 path_params = {} 12426 if 'account_id' in params: 12427 path_params['accountId'] = params['account_id'] 12428 if 'document_id' in params: 12429 path_params['documentId'] = params['document_id'] 12430 if 'envelope_id' in params: 12431 path_params['envelopeId'] = params['envelope_id'] 12432 12433 query_params = {} 12434 12435 header_params = {} 12436 12437 form_params = [] 12438 local_var_files = {} 12439 12440 body_params = None 12441 if 'tabs' in params: 12442 body_params = params['tabs'] 12443 # HTTP header `Accept` 12444 header_params['Accept'] = self.api_client.\ 12445 select_header_accept(['application/json']) 12446 12447 # Authentication setting 12448 auth_settings = [] 12449 12450 return self.api_client.call_api(resource_path, 'PUT', 12451 path_params, 12452 query_params, 12453 header_params, 12454 body=body_params, 12455 post_params=form_params, 12456 files=local_var_files, 12457 response_type='Tabs', 12458 auth_settings=auth_settings, 12459 callback=params.get('callback'), 12460 _return_http_data_only=params.get('_return_http_data_only'), 12461 _preload_content=params.get('_preload_content', True), 12462 _request_timeout=params.get('_request_timeout'), 12463 collection_formats=collection_formats) 12464 12465 def update_documents(self, account_id, envelope_id, **kwargs): 12466 """ 12467 Adds one or more documents to an existing envelope document. 12468 Adds one or more documents to an existing envelope document. 12469 This method makes a synchronous HTTP request by default. To make an 12470 asynchronous HTTP request, please define a `callback` function 12471 to be invoked when receiving the response. 12472 >>> def callback_function(response): 12473 >>> pprint(response) 12474 >>> 12475 >>> thread = api.update_documents(account_id, envelope_id, callback=callback_function) 12476 12477 :param callback function: The callback function 12478 for asynchronous request. (optional) 12479 :param str account_id: The external account number (int) or account ID Guid. (required) 12480 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12481 :param EnvelopeDefinition envelope_definition: 12482 :return: EnvelopeDocumentsResult 12483 If the method is called asynchronously, 12484 returns the request thread. 12485 """ 12486 kwargs['_return_http_data_only'] = True 12487 if kwargs.get('callback'): 12488 return self.update_documents_with_http_info(account_id, envelope_id, **kwargs) 12489 else: 12490 (data) = self.update_documents_with_http_info(account_id, envelope_id, **kwargs) 12491 return data 12492 12493 def update_documents_with_http_info(self, account_id, envelope_id, **kwargs): 12494 """ 12495 Adds one or more documents to an existing envelope document. 12496 Adds one or more documents to an existing envelope document. 12497 This method makes a synchronous HTTP request by default. To make an 12498 asynchronous HTTP request, please define a `callback` function 12499 to be invoked when receiving the response. 12500 >>> def callback_function(response): 12501 >>> pprint(response) 12502 >>> 12503 >>> thread = api.update_documents_with_http_info(account_id, envelope_id, callback=callback_function) 12504 12505 :param callback function: The callback function 12506 for asynchronous request. (optional) 12507 :param str account_id: The external account number (int) or account ID Guid. (required) 12508 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12509 :param EnvelopeDefinition envelope_definition: 12510 :return: EnvelopeDocumentsResult 12511 If the method is called asynchronously, 12512 returns the request thread. 12513 """ 12514 12515 all_params = ['account_id', 'envelope_id', 'envelope_definition'] 12516 all_params.append('callback') 12517 all_params.append('_return_http_data_only') 12518 all_params.append('_preload_content') 12519 all_params.append('_request_timeout') 12520 12521 params = locals() 12522 for key, val in iteritems(params['kwargs']): 12523 if key not in all_params: 12524 raise TypeError( 12525 "Got an unexpected keyword argument '%s'" 12526 " to method update_documents" % key 12527 ) 12528 params[key] = val 12529 del params['kwargs'] 12530 # verify the required parameter 'account_id' is set 12531 if ('account_id' not in params) or (params['account_id'] is None): 12532 raise ValueError("Missing the required parameter `account_id` when calling `update_documents`") 12533 # verify the required parameter 'envelope_id' is set 12534 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12535 raise ValueError("Missing the required parameter `envelope_id` when calling `update_documents`") 12536 12537 12538 collection_formats = {} 12539 12540 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents'.replace('{format}', 'json') 12541 path_params = {} 12542 if 'account_id' in params: 12543 path_params['accountId'] = params['account_id'] 12544 if 'envelope_id' in params: 12545 path_params['envelopeId'] = params['envelope_id'] 12546 12547 query_params = {} 12548 12549 header_params = {} 12550 12551 form_params = [] 12552 local_var_files = {} 12553 12554 body_params = None 12555 if 'envelope_definition' in params: 12556 body_params = params['envelope_definition'] 12557 # HTTP header `Accept` 12558 header_params['Accept'] = self.api_client.\ 12559 select_header_accept(['application/json']) 12560 12561 # Authentication setting 12562 auth_settings = [] 12563 12564 return self.api_client.call_api(resource_path, 'PUT', 12565 path_params, 12566 query_params, 12567 header_params, 12568 body=body_params, 12569 post_params=form_params, 12570 files=local_var_files, 12571 response_type='EnvelopeDocumentsResult', 12572 auth_settings=auth_settings, 12573 callback=params.get('callback'), 12574 _return_http_data_only=params.get('_return_http_data_only'), 12575 _preload_content=params.get('_preload_content', True), 12576 _request_timeout=params.get('_request_timeout'), 12577 collection_formats=collection_formats) 12578 12579 def update_email_settings(self, account_id, envelope_id, **kwargs): 12580 """ 12581 Updates the email setting overrides for an envelope. 12582 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. 12583 This method makes a synchronous HTTP request by default. To make an 12584 asynchronous HTTP request, please define a `callback` function 12585 to be invoked when receiving the response. 12586 >>> def callback_function(response): 12587 >>> pprint(response) 12588 >>> 12589 >>> thread = api.update_email_settings(account_id, envelope_id, callback=callback_function) 12590 12591 :param callback function: The callback function 12592 for asynchronous request. (optional) 12593 :param str account_id: The external account number (int) or account ID Guid. (required) 12594 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12595 :param EmailSettings email_settings: 12596 :return: EmailSettings 12597 If the method is called asynchronously, 12598 returns the request thread. 12599 """ 12600 kwargs['_return_http_data_only'] = True 12601 if kwargs.get('callback'): 12602 return self.update_email_settings_with_http_info(account_id, envelope_id, **kwargs) 12603 else: 12604 (data) = self.update_email_settings_with_http_info(account_id, envelope_id, **kwargs) 12605 return data 12606 12607 def update_email_settings_with_http_info(self, account_id, envelope_id, **kwargs): 12608 """ 12609 Updates the email setting overrides for an envelope. 12610 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. 12611 This method makes a synchronous HTTP request by default. To make an 12612 asynchronous HTTP request, please define a `callback` function 12613 to be invoked when receiving the response. 12614 >>> def callback_function(response): 12615 >>> pprint(response) 12616 >>> 12617 >>> thread = api.update_email_settings_with_http_info(account_id, envelope_id, callback=callback_function) 12618 12619 :param callback function: The callback function 12620 for asynchronous request. (optional) 12621 :param str account_id: The external account number (int) or account ID Guid. (required) 12622 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12623 :param EmailSettings email_settings: 12624 :return: EmailSettings 12625 If the method is called asynchronously, 12626 returns the request thread. 12627 """ 12628 12629 all_params = ['account_id', 'envelope_id', 'email_settings'] 12630 all_params.append('callback') 12631 all_params.append('_return_http_data_only') 12632 all_params.append('_preload_content') 12633 all_params.append('_request_timeout') 12634 12635 params = locals() 12636 for key, val in iteritems(params['kwargs']): 12637 if key not in all_params: 12638 raise TypeError( 12639 "Got an unexpected keyword argument '%s'" 12640 " to method update_email_settings" % key 12641 ) 12642 params[key] = val 12643 del params['kwargs'] 12644 # verify the required parameter 'account_id' is set 12645 if ('account_id' not in params) or (params['account_id'] is None): 12646 raise ValueError("Missing the required parameter `account_id` when calling `update_email_settings`") 12647 # verify the required parameter 'envelope_id' is set 12648 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12649 raise ValueError("Missing the required parameter `envelope_id` when calling `update_email_settings`") 12650 12651 12652 collection_formats = {} 12653 12654 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/email_settings'.replace('{format}', 'json') 12655 path_params = {} 12656 if 'account_id' in params: 12657 path_params['accountId'] = params['account_id'] 12658 if 'envelope_id' in params: 12659 path_params['envelopeId'] = params['envelope_id'] 12660 12661 query_params = {} 12662 12663 header_params = {} 12664 12665 form_params = [] 12666 local_var_files = {} 12667 12668 body_params = None 12669 if 'email_settings' in params: 12670 body_params = params['email_settings'] 12671 # HTTP header `Accept` 12672 header_params['Accept'] = self.api_client.\ 12673 select_header_accept(['application/json']) 12674 12675 # Authentication setting 12676 auth_settings = [] 12677 12678 return self.api_client.call_api(resource_path, 'PUT', 12679 path_params, 12680 query_params, 12681 header_params, 12682 body=body_params, 12683 post_params=form_params, 12684 files=local_var_files, 12685 response_type='EmailSettings', 12686 auth_settings=auth_settings, 12687 callback=params.get('callback'), 12688 _return_http_data_only=params.get('_return_http_data_only'), 12689 _preload_content=params.get('_preload_content', True), 12690 _request_timeout=params.get('_request_timeout'), 12691 collection_formats=collection_formats) 12692 12693 def update_envelope_delayed_routing_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 12694 """ 12695 Updates the delayed routing rules for an envelope's workflow step definition. 12696 This method makes a synchronous HTTP request by default. To make an 12697 asynchronous HTTP request, please define a `callback` function 12698 to be invoked when receiving the response. 12699 >>> def callback_function(response): 12700 >>> pprint(response) 12701 >>> 12702 >>> thread = api.update_envelope_delayed_routing_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 12703 12704 :param callback function: The callback function 12705 for asynchronous request. (optional) 12706 :param str account_id: The external account number (int) or account ID Guid. (required) 12707 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12708 :param str workflow_step_id: (required) 12709 :param DelayedRouting delayed_routing: 12710 :return: DelayedRouting 12711 If the method is called asynchronously, 12712 returns the request thread. 12713 """ 12714 kwargs['_return_http_data_only'] = True 12715 if kwargs.get('callback'): 12716 return self.update_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 12717 else: 12718 (data) = self.update_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 12719 return data 12720 12721 def update_envelope_delayed_routing_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 12722 """ 12723 Updates the delayed routing rules for an envelope's workflow step definition. 12724 This method makes a synchronous HTTP request by default. To make an 12725 asynchronous HTTP request, please define a `callback` function 12726 to be invoked when receiving the response. 12727 >>> def callback_function(response): 12728 >>> pprint(response) 12729 >>> 12730 >>> thread = api.update_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 12731 12732 :param callback function: The callback function 12733 for asynchronous request. (optional) 12734 :param str account_id: The external account number (int) or account ID Guid. (required) 12735 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12736 :param str workflow_step_id: (required) 12737 :param DelayedRouting delayed_routing: 12738 :return: DelayedRouting 12739 If the method is called asynchronously, 12740 returns the request thread. 12741 """ 12742 12743 all_params = ['account_id', 'envelope_id', 'workflow_step_id', 'delayed_routing'] 12744 all_params.append('callback') 12745 all_params.append('_return_http_data_only') 12746 all_params.append('_preload_content') 12747 all_params.append('_request_timeout') 12748 12749 params = locals() 12750 for key, val in iteritems(params['kwargs']): 12751 if key not in all_params: 12752 raise TypeError( 12753 "Got an unexpected keyword argument '%s'" 12754 " to method update_envelope_delayed_routing_definition" % key 12755 ) 12756 params[key] = val 12757 del params['kwargs'] 12758 # verify the required parameter 'account_id' is set 12759 if ('account_id' not in params) or (params['account_id'] is None): 12760 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_delayed_routing_definition`") 12761 # verify the required parameter 'envelope_id' is set 12762 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12763 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_delayed_routing_definition`") 12764 # verify the required parameter 'workflow_step_id' is set 12765 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 12766 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_envelope_delayed_routing_definition`") 12767 12768 12769 collection_formats = {} 12770 12771 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 12772 path_params = {} 12773 if 'account_id' in params: 12774 path_params['accountId'] = params['account_id'] 12775 if 'envelope_id' in params: 12776 path_params['envelopeId'] = params['envelope_id'] 12777 if 'workflow_step_id' in params: 12778 path_params['workflowStepId'] = params['workflow_step_id'] 12779 12780 query_params = {} 12781 12782 header_params = {} 12783 12784 form_params = [] 12785 local_var_files = {} 12786 12787 body_params = None 12788 if 'delayed_routing' in params: 12789 body_params = params['delayed_routing'] 12790 # HTTP header `Accept` 12791 header_params['Accept'] = self.api_client.\ 12792 select_header_accept(['application/json']) 12793 12794 # Authentication setting 12795 auth_settings = [] 12796 12797 return self.api_client.call_api(resource_path, 'PUT', 12798 path_params, 12799 query_params, 12800 header_params, 12801 body=body_params, 12802 post_params=form_params, 12803 files=local_var_files, 12804 response_type='DelayedRouting', 12805 auth_settings=auth_settings, 12806 callback=params.get('callback'), 12807 _return_http_data_only=params.get('_return_http_data_only'), 12808 _preload_content=params.get('_preload_content', True), 12809 _request_timeout=params.get('_request_timeout'), 12810 collection_formats=collection_formats) 12811 12812 def update_envelope_doc_gen_form_fields(self, account_id, envelope_id, **kwargs): 12813 """ 12814 Updates formfields for an envelope 12815 This method makes a synchronous HTTP request by default. To make an 12816 asynchronous HTTP request, please define a `callback` function 12817 to be invoked when receiving the response. 12818 >>> def callback_function(response): 12819 >>> pprint(response) 12820 >>> 12821 >>> thread = api.update_envelope_doc_gen_form_fields(account_id, envelope_id, callback=callback_function) 12822 12823 :param callback function: The callback function 12824 for asynchronous request. (optional) 12825 :param str account_id: The external account number (int) or account ID Guid. (required) 12826 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12827 :param str update_docgen_formfields_only: 12828 :param DocGenFormFieldRequest doc_gen_form_field_request: 12829 :return: DocGenFormFieldResponse 12830 If the method is called asynchronously, 12831 returns the request thread. 12832 """ 12833 kwargs['_return_http_data_only'] = True 12834 if kwargs.get('callback'): 12835 return self.update_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, **kwargs) 12836 else: 12837 (data) = self.update_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, **kwargs) 12838 return data 12839 12840 def update_envelope_doc_gen_form_fields_with_http_info(self, account_id, envelope_id, **kwargs): 12841 """ 12842 Updates formfields for an envelope 12843 This method makes a synchronous HTTP request by default. To make an 12844 asynchronous HTTP request, please define a `callback` function 12845 to be invoked when receiving the response. 12846 >>> def callback_function(response): 12847 >>> pprint(response) 12848 >>> 12849 >>> thread = api.update_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, callback=callback_function) 12850 12851 :param callback function: The callback function 12852 for asynchronous request. (optional) 12853 :param str account_id: The external account number (int) or account ID Guid. (required) 12854 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12855 :param str update_docgen_formfields_only: 12856 :param DocGenFormFieldRequest doc_gen_form_field_request: 12857 :return: DocGenFormFieldResponse 12858 If the method is called asynchronously, 12859 returns the request thread. 12860 """ 12861 12862 all_params = ['account_id', 'envelope_id', 'update_docgen_formfields_only', 'doc_gen_form_field_request'] 12863 all_params.append('callback') 12864 all_params.append('_return_http_data_only') 12865 all_params.append('_preload_content') 12866 all_params.append('_request_timeout') 12867 12868 params = locals() 12869 for key, val in iteritems(params['kwargs']): 12870 if key not in all_params: 12871 raise TypeError( 12872 "Got an unexpected keyword argument '%s'" 12873 " to method update_envelope_doc_gen_form_fields" % key 12874 ) 12875 params[key] = val 12876 del params['kwargs'] 12877 # verify the required parameter 'account_id' is set 12878 if ('account_id' not in params) or (params['account_id'] is None): 12879 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_doc_gen_form_fields`") 12880 # verify the required parameter 'envelope_id' is set 12881 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12882 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_doc_gen_form_fields`") 12883 12884 12885 collection_formats = {} 12886 12887 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/docGenFormFields'.replace('{format}', 'json') 12888 path_params = {} 12889 if 'account_id' in params: 12890 path_params['accountId'] = params['account_id'] 12891 if 'envelope_id' in params: 12892 path_params['envelopeId'] = params['envelope_id'] 12893 12894 query_params = {} 12895 if 'update_docgen_formfields_only' in params: 12896 query_params['update_docgen_formfields_only'] = params['update_docgen_formfields_only'] 12897 12898 header_params = {} 12899 12900 form_params = [] 12901 local_var_files = {} 12902 12903 body_params = None 12904 if 'doc_gen_form_field_request' in params: 12905 body_params = params['doc_gen_form_field_request'] 12906 # HTTP header `Accept` 12907 header_params['Accept'] = self.api_client.\ 12908 select_header_accept(['application/json']) 12909 12910 # Authentication setting 12911 auth_settings = [] 12912 12913 return self.api_client.call_api(resource_path, 'PUT', 12914 path_params, 12915 query_params, 12916 header_params, 12917 body=body_params, 12918 post_params=form_params, 12919 files=local_var_files, 12920 response_type='DocGenFormFieldResponse', 12921 auth_settings=auth_settings, 12922 callback=params.get('callback'), 12923 _return_http_data_only=params.get('_return_http_data_only'), 12924 _preload_content=params.get('_preload_content', True), 12925 _request_timeout=params.get('_request_timeout'), 12926 collection_formats=collection_formats) 12927 12928 def update_envelope_scheduled_sending_definition(self, account_id, envelope_id, **kwargs): 12929 """ 12930 Updates the scheduled sending rules for an envelope's workflow definition. 12931 This method makes a synchronous HTTP request by default. To make an 12932 asynchronous HTTP request, please define a `callback` function 12933 to be invoked when receiving the response. 12934 >>> def callback_function(response): 12935 >>> pprint(response) 12936 >>> 12937 >>> thread = api.update_envelope_scheduled_sending_definition(account_id, envelope_id, callback=callback_function) 12938 12939 :param callback function: The callback function 12940 for asynchronous request. (optional) 12941 :param str account_id: The external account number (int) or account ID Guid. (required) 12942 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12943 :param ScheduledSending scheduled_sending: 12944 :return: ScheduledSending 12945 If the method is called asynchronously, 12946 returns the request thread. 12947 """ 12948 kwargs['_return_http_data_only'] = True 12949 if kwargs.get('callback'): 12950 return self.update_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 12951 else: 12952 (data) = self.update_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 12953 return data 12954 12955 def update_envelope_scheduled_sending_definition_with_http_info(self, account_id, envelope_id, **kwargs): 12956 """ 12957 Updates the scheduled sending rules for an envelope's workflow definition. 12958 This method makes a synchronous HTTP request by default. To make an 12959 asynchronous HTTP request, please define a `callback` function 12960 to be invoked when receiving the response. 12961 >>> def callback_function(response): 12962 >>> pprint(response) 12963 >>> 12964 >>> thread = api.update_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, callback=callback_function) 12965 12966 :param callback function: The callback function 12967 for asynchronous request. (optional) 12968 :param str account_id: The external account number (int) or account ID Guid. (required) 12969 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12970 :param ScheduledSending scheduled_sending: 12971 :return: ScheduledSending 12972 If the method is called asynchronously, 12973 returns the request thread. 12974 """ 12975 12976 all_params = ['account_id', 'envelope_id', 'scheduled_sending'] 12977 all_params.append('callback') 12978 all_params.append('_return_http_data_only') 12979 all_params.append('_preload_content') 12980 all_params.append('_request_timeout') 12981 12982 params = locals() 12983 for key, val in iteritems(params['kwargs']): 12984 if key not in all_params: 12985 raise TypeError( 12986 "Got an unexpected keyword argument '%s'" 12987 " to method update_envelope_scheduled_sending_definition" % key 12988 ) 12989 params[key] = val 12990 del params['kwargs'] 12991 # verify the required parameter 'account_id' is set 12992 if ('account_id' not in params) or (params['account_id'] is None): 12993 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_scheduled_sending_definition`") 12994 # verify the required parameter 'envelope_id' is set 12995 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12996 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_scheduled_sending_definition`") 12997 12998 12999 collection_formats = {} 13000 13001 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/scheduledSending'.replace('{format}', 'json') 13002 path_params = {} 13003 if 'account_id' in params: 13004 path_params['accountId'] = params['account_id'] 13005 if 'envelope_id' in params: 13006 path_params['envelopeId'] = params['envelope_id'] 13007 13008 query_params = {} 13009 13010 header_params = {} 13011 13012 form_params = [] 13013 local_var_files = {} 13014 13015 body_params = None 13016 if 'scheduled_sending' in params: 13017 body_params = params['scheduled_sending'] 13018 # HTTP header `Accept` 13019 header_params['Accept'] = self.api_client.\ 13020 select_header_accept(['application/json']) 13021 13022 # Authentication setting 13023 auth_settings = [] 13024 13025 return self.api_client.call_api(resource_path, 'PUT', 13026 path_params, 13027 query_params, 13028 header_params, 13029 body=body_params, 13030 post_params=form_params, 13031 files=local_var_files, 13032 response_type='ScheduledSending', 13033 auth_settings=auth_settings, 13034 callback=params.get('callback'), 13035 _return_http_data_only=params.get('_return_http_data_only'), 13036 _preload_content=params.get('_preload_content', True), 13037 _request_timeout=params.get('_request_timeout'), 13038 collection_formats=collection_formats) 13039 13040 def update_envelope_transfer_rule(self, account_id, envelope_transfer_rule_id, **kwargs): 13041 """ 13042 Update an envelope transfer rule for an account. 13043 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. 13044 This method makes a synchronous HTTP request by default. To make an 13045 asynchronous HTTP request, please define a `callback` function 13046 to be invoked when receiving the response. 13047 >>> def callback_function(response): 13048 >>> pprint(response) 13049 >>> 13050 >>> thread = api.update_envelope_transfer_rule(account_id, envelope_transfer_rule_id, callback=callback_function) 13051 13052 :param callback function: The callback function 13053 for asynchronous request. (optional) 13054 :param str account_id: The external account number (int) or account ID Guid. (required) 13055 :param str envelope_transfer_rule_id: (required) 13056 :param EnvelopeTransferRule envelope_transfer_rule: 13057 :return: EnvelopeTransferRule 13058 If the method is called asynchronously, 13059 returns the request thread. 13060 """ 13061 kwargs['_return_http_data_only'] = True 13062 if kwargs.get('callback'): 13063 return self.update_envelope_transfer_rule_with_http_info(account_id, envelope_transfer_rule_id, **kwargs) 13064 else: 13065 (data) = self.update_envelope_transfer_rule_with_http_info(account_id, envelope_transfer_rule_id, **kwargs) 13066 return data 13067 13068 def update_envelope_transfer_rule_with_http_info(self, account_id, envelope_transfer_rule_id, **kwargs): 13069 """ 13070 Update an envelope transfer rule for an account. 13071 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. 13072 This method makes a synchronous HTTP request by default. To make an 13073 asynchronous HTTP request, please define a `callback` function 13074 to be invoked when receiving the response. 13075 >>> def callback_function(response): 13076 >>> pprint(response) 13077 >>> 13078 >>> thread = api.update_envelope_transfer_rule_with_http_info(account_id, envelope_transfer_rule_id, callback=callback_function) 13079 13080 :param callback function: The callback function 13081 for asynchronous request. (optional) 13082 :param str account_id: The external account number (int) or account ID Guid. (required) 13083 :param str envelope_transfer_rule_id: (required) 13084 :param EnvelopeTransferRule envelope_transfer_rule: 13085 :return: EnvelopeTransferRule 13086 If the method is called asynchronously, 13087 returns the request thread. 13088 """ 13089 13090 all_params = ['account_id', 'envelope_transfer_rule_id', 'envelope_transfer_rule'] 13091 all_params.append('callback') 13092 all_params.append('_return_http_data_only') 13093 all_params.append('_preload_content') 13094 all_params.append('_request_timeout') 13095 13096 params = locals() 13097 for key, val in iteritems(params['kwargs']): 13098 if key not in all_params: 13099 raise TypeError( 13100 "Got an unexpected keyword argument '%s'" 13101 " to method update_envelope_transfer_rule" % key 13102 ) 13103 params[key] = val 13104 del params['kwargs'] 13105 # verify the required parameter 'account_id' is set 13106 if ('account_id' not in params) or (params['account_id'] is None): 13107 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_transfer_rule`") 13108 # verify the required parameter 'envelope_transfer_rule_id' is set 13109 if ('envelope_transfer_rule_id' not in params) or (params['envelope_transfer_rule_id'] is None): 13110 raise ValueError("Missing the required parameter `envelope_transfer_rule_id` when calling `update_envelope_transfer_rule`") 13111 13112 13113 collection_formats = {} 13114 13115 resource_path = '/v2.1/accounts/{accountId}/envelopes/transfer_rules/{envelopeTransferRuleId}'.replace('{format}', 'json') 13116 path_params = {} 13117 if 'account_id' in params: 13118 path_params['accountId'] = params['account_id'] 13119 if 'envelope_transfer_rule_id' in params: 13120 path_params['envelopeTransferRuleId'] = params['envelope_transfer_rule_id'] 13121 13122 query_params = {} 13123 13124 header_params = {} 13125 13126 form_params = [] 13127 local_var_files = {} 13128 13129 body_params = None 13130 if 'envelope_transfer_rule' in params: 13131 body_params = params['envelope_transfer_rule'] 13132 # HTTP header `Accept` 13133 header_params['Accept'] = self.api_client.\ 13134 select_header_accept(['application/json']) 13135 13136 # Authentication setting 13137 auth_settings = [] 13138 13139 return self.api_client.call_api(resource_path, 'PUT', 13140 path_params, 13141 query_params, 13142 header_params, 13143 body=body_params, 13144 post_params=form_params, 13145 files=local_var_files, 13146 response_type='EnvelopeTransferRule', 13147 auth_settings=auth_settings, 13148 callback=params.get('callback'), 13149 _return_http_data_only=params.get('_return_http_data_only'), 13150 _preload_content=params.get('_preload_content', True), 13151 _request_timeout=params.get('_request_timeout'), 13152 collection_formats=collection_formats) 13153 13154 def update_envelope_transfer_rules(self, account_id, **kwargs): 13155 """ 13156 Update envelope transfer rules for an account. 13157 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. 13158 This method makes a synchronous HTTP request by default. To make an 13159 asynchronous HTTP request, please define a `callback` function 13160 to be invoked when receiving the response. 13161 >>> def callback_function(response): 13162 >>> pprint(response) 13163 >>> 13164 >>> thread = api.update_envelope_transfer_rules(account_id, callback=callback_function) 13165 13166 :param callback function: The callback function 13167 for asynchronous request. (optional) 13168 :param str account_id: The external account number (int) or account ID Guid. (required) 13169 :param EnvelopeTransferRuleInformation envelope_transfer_rule_information: 13170 :return: EnvelopeTransferRuleInformation 13171 If the method is called asynchronously, 13172 returns the request thread. 13173 """ 13174 kwargs['_return_http_data_only'] = True 13175 if kwargs.get('callback'): 13176 return self.update_envelope_transfer_rules_with_http_info(account_id, **kwargs) 13177 else: 13178 (data) = self.update_envelope_transfer_rules_with_http_info(account_id, **kwargs) 13179 return data 13180 13181 def update_envelope_transfer_rules_with_http_info(self, account_id, **kwargs): 13182 """ 13183 Update envelope transfer rules for an account. 13184 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. 13185 This method makes a synchronous HTTP request by default. To make an 13186 asynchronous HTTP request, please define a `callback` function 13187 to be invoked when receiving the response. 13188 >>> def callback_function(response): 13189 >>> pprint(response) 13190 >>> 13191 >>> thread = api.update_envelope_transfer_rules_with_http_info(account_id, callback=callback_function) 13192 13193 :param callback function: The callback function 13194 for asynchronous request. (optional) 13195 :param str account_id: The external account number (int) or account ID Guid. (required) 13196 :param EnvelopeTransferRuleInformation envelope_transfer_rule_information: 13197 :return: EnvelopeTransferRuleInformation 13198 If the method is called asynchronously, 13199 returns the request thread. 13200 """ 13201 13202 all_params = ['account_id', 'envelope_transfer_rule_information'] 13203 all_params.append('callback') 13204 all_params.append('_return_http_data_only') 13205 all_params.append('_preload_content') 13206 all_params.append('_request_timeout') 13207 13208 params = locals() 13209 for key, val in iteritems(params['kwargs']): 13210 if key not in all_params: 13211 raise TypeError( 13212 "Got an unexpected keyword argument '%s'" 13213 " to method update_envelope_transfer_rules" % key 13214 ) 13215 params[key] = val 13216 del params['kwargs'] 13217 # verify the required parameter 'account_id' is set 13218 if ('account_id' not in params) or (params['account_id'] is None): 13219 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_transfer_rules`") 13220 13221 13222 collection_formats = {} 13223 13224 resource_path = '/v2.1/accounts/{accountId}/envelopes/transfer_rules'.replace('{format}', 'json') 13225 path_params = {} 13226 if 'account_id' in params: 13227 path_params['accountId'] = params['account_id'] 13228 13229 query_params = {} 13230 13231 header_params = {} 13232 13233 form_params = [] 13234 local_var_files = {} 13235 13236 body_params = None 13237 if 'envelope_transfer_rule_information' in params: 13238 body_params = params['envelope_transfer_rule_information'] 13239 # HTTP header `Accept` 13240 header_params['Accept'] = self.api_client.\ 13241 select_header_accept(['application/json']) 13242 13243 # Authentication setting 13244 auth_settings = [] 13245 13246 return self.api_client.call_api(resource_path, 'PUT', 13247 path_params, 13248 query_params, 13249 header_params, 13250 body=body_params, 13251 post_params=form_params, 13252 files=local_var_files, 13253 response_type='EnvelopeTransferRuleInformation', 13254 auth_settings=auth_settings, 13255 callback=params.get('callback'), 13256 _return_http_data_only=params.get('_return_http_data_only'), 13257 _preload_content=params.get('_preload_content', True), 13258 _request_timeout=params.get('_request_timeout'), 13259 collection_formats=collection_formats) 13260 13261 def update_envelope_workflow_definition(self, account_id, envelope_id, **kwargs): 13262 """ 13263 Updates the envelope workflow definition for an envelope. 13264 Updates the specified envelope's workflow definition if it has one. 13265 This method makes a synchronous HTTP request by default. To make an 13266 asynchronous HTTP request, please define a `callback` function 13267 to be invoked when receiving the response. 13268 >>> def callback_function(response): 13269 >>> pprint(response) 13270 >>> 13271 >>> thread = api.update_envelope_workflow_definition(account_id, envelope_id, callback=callback_function) 13272 13273 :param callback function: The callback function 13274 for asynchronous request. (optional) 13275 :param str account_id: The external account number (int) or account ID Guid. (required) 13276 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13277 :param Workflow workflow: 13278 :return: Workflow 13279 If the method is called asynchronously, 13280 returns the request thread. 13281 """ 13282 kwargs['_return_http_data_only'] = True 13283 if kwargs.get('callback'): 13284 return self.update_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 13285 else: 13286 (data) = self.update_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 13287 return data 13288 13289 def update_envelope_workflow_definition_with_http_info(self, account_id, envelope_id, **kwargs): 13290 """ 13291 Updates the envelope workflow definition for an envelope. 13292 Updates the specified envelope's workflow definition if it has one. 13293 This method makes a synchronous HTTP request by default. To make an 13294 asynchronous HTTP request, please define a `callback` function 13295 to be invoked when receiving the response. 13296 >>> def callback_function(response): 13297 >>> pprint(response) 13298 >>> 13299 >>> thread = api.update_envelope_workflow_definition_with_http_info(account_id, envelope_id, callback=callback_function) 13300 13301 :param callback function: The callback function 13302 for asynchronous request. (optional) 13303 :param str account_id: The external account number (int) or account ID Guid. (required) 13304 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13305 :param Workflow workflow: 13306 :return: Workflow 13307 If the method is called asynchronously, 13308 returns the request thread. 13309 """ 13310 13311 all_params = ['account_id', 'envelope_id', 'workflow'] 13312 all_params.append('callback') 13313 all_params.append('_return_http_data_only') 13314 all_params.append('_preload_content') 13315 all_params.append('_request_timeout') 13316 13317 params = locals() 13318 for key, val in iteritems(params['kwargs']): 13319 if key not in all_params: 13320 raise TypeError( 13321 "Got an unexpected keyword argument '%s'" 13322 " to method update_envelope_workflow_definition" % key 13323 ) 13324 params[key] = val 13325 del params['kwargs'] 13326 # verify the required parameter 'account_id' is set 13327 if ('account_id' not in params) or (params['account_id'] is None): 13328 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_workflow_definition`") 13329 # verify the required parameter 'envelope_id' is set 13330 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13331 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_workflow_definition`") 13332 13333 13334 collection_formats = {} 13335 13336 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow'.replace('{format}', 'json') 13337 path_params = {} 13338 if 'account_id' in params: 13339 path_params['accountId'] = params['account_id'] 13340 if 'envelope_id' in params: 13341 path_params['envelopeId'] = params['envelope_id'] 13342 13343 query_params = {} 13344 13345 header_params = {} 13346 13347 form_params = [] 13348 local_var_files = {} 13349 13350 body_params = None 13351 if 'workflow' in params: 13352 body_params = params['workflow'] 13353 # HTTP header `Accept` 13354 header_params['Accept'] = self.api_client.\ 13355 select_header_accept(['application/json']) 13356 13357 # Authentication setting 13358 auth_settings = [] 13359 13360 return self.api_client.call_api(resource_path, 'PUT', 13361 path_params, 13362 query_params, 13363 header_params, 13364 body=body_params, 13365 post_params=form_params, 13366 files=local_var_files, 13367 response_type='Workflow', 13368 auth_settings=auth_settings, 13369 callback=params.get('callback'), 13370 _return_http_data_only=params.get('_return_http_data_only'), 13371 _preload_content=params.get('_preload_content', True), 13372 _request_timeout=params.get('_request_timeout'), 13373 collection_formats=collection_formats) 13374 13375 def update_envelope_workflow_step_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 13376 """ 13377 Updates the envelope workflow step definition for an envelope. 13378 This method makes a synchronous HTTP request by default. To make an 13379 asynchronous HTTP request, please define a `callback` function 13380 to be invoked when receiving the response. 13381 >>> def callback_function(response): 13382 >>> pprint(response) 13383 >>> 13384 >>> thread = api.update_envelope_workflow_step_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 13385 13386 :param callback function: The callback function 13387 for asynchronous request. (optional) 13388 :param str account_id: The external account number (int) or account ID Guid. (required) 13389 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13390 :param str workflow_step_id: (required) 13391 :param WorkflowStep workflow_step: 13392 :return: WorkflowStep 13393 If the method is called asynchronously, 13394 returns the request thread. 13395 """ 13396 kwargs['_return_http_data_only'] = True 13397 if kwargs.get('callback'): 13398 return self.update_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 13399 else: 13400 (data) = self.update_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 13401 return data 13402 13403 def update_envelope_workflow_step_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 13404 """ 13405 Updates the envelope workflow step definition for an envelope. 13406 This method makes a synchronous HTTP request by default. To make an 13407 asynchronous HTTP request, please define a `callback` function 13408 to be invoked when receiving the response. 13409 >>> def callback_function(response): 13410 >>> pprint(response) 13411 >>> 13412 >>> thread = api.update_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 13413 13414 :param callback function: The callback function 13415 for asynchronous request. (optional) 13416 :param str account_id: The external account number (int) or account ID Guid. (required) 13417 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13418 :param str workflow_step_id: (required) 13419 :param WorkflowStep workflow_step: 13420 :return: WorkflowStep 13421 If the method is called asynchronously, 13422 returns the request thread. 13423 """ 13424 13425 all_params = ['account_id', 'envelope_id', 'workflow_step_id', 'workflow_step'] 13426 all_params.append('callback') 13427 all_params.append('_return_http_data_only') 13428 all_params.append('_preload_content') 13429 all_params.append('_request_timeout') 13430 13431 params = locals() 13432 for key, val in iteritems(params['kwargs']): 13433 if key not in all_params: 13434 raise TypeError( 13435 "Got an unexpected keyword argument '%s'" 13436 " to method update_envelope_workflow_step_definition" % key 13437 ) 13438 params[key] = val 13439 del params['kwargs'] 13440 # verify the required parameter 'account_id' is set 13441 if ('account_id' not in params) or (params['account_id'] is None): 13442 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_workflow_step_definition`") 13443 # verify the required parameter 'envelope_id' is set 13444 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13445 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_workflow_step_definition`") 13446 # verify the required parameter 'workflow_step_id' is set 13447 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 13448 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_envelope_workflow_step_definition`") 13449 13450 13451 collection_formats = {} 13452 13453 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 13454 path_params = {} 13455 if 'account_id' in params: 13456 path_params['accountId'] = params['account_id'] 13457 if 'envelope_id' in params: 13458 path_params['envelopeId'] = params['envelope_id'] 13459 if 'workflow_step_id' in params: 13460 path_params['workflowStepId'] = params['workflow_step_id'] 13461 13462 query_params = {} 13463 13464 header_params = {} 13465 13466 form_params = [] 13467 local_var_files = {} 13468 13469 body_params = None 13470 if 'workflow_step' in params: 13471 body_params = params['workflow_step'] 13472 # HTTP header `Accept` 13473 header_params['Accept'] = self.api_client.\ 13474 select_header_accept(['application/json']) 13475 13476 # Authentication setting 13477 auth_settings = [] 13478 13479 return self.api_client.call_api(resource_path, 'PUT', 13480 path_params, 13481 query_params, 13482 header_params, 13483 body=body_params, 13484 post_params=form_params, 13485 files=local_var_files, 13486 response_type='WorkflowStep', 13487 auth_settings=auth_settings, 13488 callback=params.get('callback'), 13489 _return_http_data_only=params.get('_return_http_data_only'), 13490 _preload_content=params.get('_preload_content', True), 13491 _request_timeout=params.get('_request_timeout'), 13492 collection_formats=collection_formats) 13493 13494 def update_lock(self, account_id, envelope_id, **kwargs): 13495 """ 13496 Updates an envelope lock. 13497 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. 13498 This method makes a synchronous HTTP request by default. To make an 13499 asynchronous HTTP request, please define a `callback` function 13500 to be invoked when receiving the response. 13501 >>> def callback_function(response): 13502 >>> pprint(response) 13503 >>> 13504 >>> thread = api.update_lock(account_id, envelope_id, callback=callback_function) 13505 13506 :param callback function: The callback function 13507 for asynchronous request. (optional) 13508 :param str account_id: The external account number (int) or account ID Guid. (required) 13509 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13510 :param LockRequest lock_request: 13511 :return: LockInformation 13512 If the method is called asynchronously, 13513 returns the request thread. 13514 """ 13515 kwargs['_return_http_data_only'] = True 13516 if kwargs.get('callback'): 13517 return self.update_lock_with_http_info(account_id, envelope_id, **kwargs) 13518 else: 13519 (data) = self.update_lock_with_http_info(account_id, envelope_id, **kwargs) 13520 return data 13521 13522 def update_lock_with_http_info(self, account_id, envelope_id, **kwargs): 13523 """ 13524 Updates an envelope lock. 13525 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. 13526 This method makes a synchronous HTTP request by default. To make an 13527 asynchronous HTTP request, please define a `callback` function 13528 to be invoked when receiving the response. 13529 >>> def callback_function(response): 13530 >>> pprint(response) 13531 >>> 13532 >>> thread = api.update_lock_with_http_info(account_id, envelope_id, callback=callback_function) 13533 13534 :param callback function: The callback function 13535 for asynchronous request. (optional) 13536 :param str account_id: The external account number (int) or account ID Guid. (required) 13537 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13538 :param LockRequest lock_request: 13539 :return: LockInformation 13540 If the method is called asynchronously, 13541 returns the request thread. 13542 """ 13543 13544 all_params = ['account_id', 'envelope_id', 'lock_request'] 13545 all_params.append('callback') 13546 all_params.append('_return_http_data_only') 13547 all_params.append('_preload_content') 13548 all_params.append('_request_timeout') 13549 13550 params = locals() 13551 for key, val in iteritems(params['kwargs']): 13552 if key not in all_params: 13553 raise TypeError( 13554 "Got an unexpected keyword argument '%s'" 13555 " to method update_lock" % key 13556 ) 13557 params[key] = val 13558 del params['kwargs'] 13559 # verify the required parameter 'account_id' is set 13560 if ('account_id' not in params) or (params['account_id'] is None): 13561 raise ValueError("Missing the required parameter `account_id` when calling `update_lock`") 13562 # verify the required parameter 'envelope_id' is set 13563 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13564 raise ValueError("Missing the required parameter `envelope_id` when calling `update_lock`") 13565 13566 13567 collection_formats = {} 13568 13569 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/lock'.replace('{format}', 'json') 13570 path_params = {} 13571 if 'account_id' in params: 13572 path_params['accountId'] = params['account_id'] 13573 if 'envelope_id' in params: 13574 path_params['envelopeId'] = params['envelope_id'] 13575 13576 query_params = {} 13577 13578 header_params = {} 13579 13580 form_params = [] 13581 local_var_files = {} 13582 13583 body_params = None 13584 if 'lock_request' in params: 13585 body_params = params['lock_request'] 13586 # HTTP header `Accept` 13587 header_params['Accept'] = self.api_client.\ 13588 select_header_accept(['application/json']) 13589 13590 # Authentication setting 13591 auth_settings = [] 13592 13593 return self.api_client.call_api(resource_path, 'PUT', 13594 path_params, 13595 query_params, 13596 header_params, 13597 body=body_params, 13598 post_params=form_params, 13599 files=local_var_files, 13600 response_type='LockInformation', 13601 auth_settings=auth_settings, 13602 callback=params.get('callback'), 13603 _return_http_data_only=params.get('_return_http_data_only'), 13604 _preload_content=params.get('_preload_content', True), 13605 _request_timeout=params.get('_request_timeout'), 13606 collection_formats=collection_formats) 13607 13608 def update_notification_settings(self, account_id, envelope_id, **kwargs): 13609 """ 13610 Sets envelope notification (Reminders/Expirations) structure for an existing envelope. 13611 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. 13612 This method makes a synchronous HTTP request by default. To make an 13613 asynchronous HTTP request, please define a `callback` function 13614 to be invoked when receiving the response. 13615 >>> def callback_function(response): 13616 >>> pprint(response) 13617 >>> 13618 >>> thread = api.update_notification_settings(account_id, envelope_id, callback=callback_function) 13619 13620 :param callback function: The callback function 13621 for asynchronous request. (optional) 13622 :param str account_id: The external account number (int) or account ID Guid. (required) 13623 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13624 :param EnvelopeNotificationRequest envelope_notification_request: 13625 :return: Notification 13626 If the method is called asynchronously, 13627 returns the request thread. 13628 """ 13629 kwargs['_return_http_data_only'] = True 13630 if kwargs.get('callback'): 13631 return self.update_notification_settings_with_http_info(account_id, envelope_id, **kwargs) 13632 else: 13633 (data) = self.update_notification_settings_with_http_info(account_id, envelope_id, **kwargs) 13634 return data 13635 13636 def update_notification_settings_with_http_info(self, account_id, envelope_id, **kwargs): 13637 """ 13638 Sets envelope notification (Reminders/Expirations) structure for an existing envelope. 13639 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. 13640 This method makes a synchronous HTTP request by default. To make an 13641 asynchronous HTTP request, please define a `callback` function 13642 to be invoked when receiving the response. 13643 >>> def callback_function(response): 13644 >>> pprint(response) 13645 >>> 13646 >>> thread = api.update_notification_settings_with_http_info(account_id, envelope_id, callback=callback_function) 13647 13648 :param callback function: The callback function 13649 for asynchronous request. (optional) 13650 :param str account_id: The external account number (int) or account ID Guid. (required) 13651 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13652 :param EnvelopeNotificationRequest envelope_notification_request: 13653 :return: Notification 13654 If the method is called asynchronously, 13655 returns the request thread. 13656 """ 13657 13658 all_params = ['account_id', 'envelope_id', 'envelope_notification_request'] 13659 all_params.append('callback') 13660 all_params.append('_return_http_data_only') 13661 all_params.append('_preload_content') 13662 all_params.append('_request_timeout') 13663 13664 params = locals() 13665 for key, val in iteritems(params['kwargs']): 13666 if key not in all_params: 13667 raise TypeError( 13668 "Got an unexpected keyword argument '%s'" 13669 " to method update_notification_settings" % key 13670 ) 13671 params[key] = val 13672 del params['kwargs'] 13673 # verify the required parameter 'account_id' is set 13674 if ('account_id' not in params) or (params['account_id'] is None): 13675 raise ValueError("Missing the required parameter `account_id` when calling `update_notification_settings`") 13676 # verify the required parameter 'envelope_id' is set 13677 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13678 raise ValueError("Missing the required parameter `envelope_id` when calling `update_notification_settings`") 13679 13680 13681 collection_formats = {} 13682 13683 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/notification'.replace('{format}', 'json') 13684 path_params = {} 13685 if 'account_id' in params: 13686 path_params['accountId'] = params['account_id'] 13687 if 'envelope_id' in params: 13688 path_params['envelopeId'] = params['envelope_id'] 13689 13690 query_params = {} 13691 13692 header_params = {} 13693 13694 form_params = [] 13695 local_var_files = {} 13696 13697 body_params = None 13698 if 'envelope_notification_request' in params: 13699 body_params = params['envelope_notification_request'] 13700 # HTTP header `Accept` 13701 header_params['Accept'] = self.api_client.\ 13702 select_header_accept(['application/json']) 13703 13704 # Authentication setting 13705 auth_settings = [] 13706 13707 return self.api_client.call_api(resource_path, 'PUT', 13708 path_params, 13709 query_params, 13710 header_params, 13711 body=body_params, 13712 post_params=form_params, 13713 files=local_var_files, 13714 response_type='Notification', 13715 auth_settings=auth_settings, 13716 callback=params.get('callback'), 13717 _return_http_data_only=params.get('_return_http_data_only'), 13718 _preload_content=params.get('_preload_content', True), 13719 _request_timeout=params.get('_request_timeout'), 13720 collection_formats=collection_formats) 13721 13722 def update_recipient_document_visibility(self, account_id, envelope_id, recipient_id, **kwargs): 13723 """ 13724 Updates document visibility for the recipients 13725 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. 13726 This method makes a synchronous HTTP request by default. To make an 13727 asynchronous HTTP request, please define a `callback` function 13728 to be invoked when receiving the response. 13729 >>> def callback_function(response): 13730 >>> pprint(response) 13731 >>> 13732 >>> thread = api.update_recipient_document_visibility(account_id, envelope_id, recipient_id, callback=callback_function) 13733 13734 :param callback function: The callback function 13735 for asynchronous request. (optional) 13736 :param str account_id: The external account number (int) or account ID Guid. (required) 13737 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13738 :param str recipient_id: The ID of the recipient being accessed. (required) 13739 :param DocumentVisibilityList document_visibility_list: 13740 :return: DocumentVisibilityList 13741 If the method is called asynchronously, 13742 returns the request thread. 13743 """ 13744 kwargs['_return_http_data_only'] = True 13745 if kwargs.get('callback'): 13746 return self.update_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13747 else: 13748 (data) = self.update_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13749 return data 13750 13751 def update_recipient_document_visibility_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 13752 """ 13753 Updates document visibility for the recipients 13754 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. 13755 This method makes a synchronous HTTP request by default. To make an 13756 asynchronous HTTP request, please define a `callback` function 13757 to be invoked when receiving the response. 13758 >>> def callback_function(response): 13759 >>> pprint(response) 13760 >>> 13761 >>> thread = api.update_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 13762 13763 :param callback function: The callback function 13764 for asynchronous request. (optional) 13765 :param str account_id: The external account number (int) or account ID Guid. (required) 13766 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13767 :param str recipient_id: The ID of the recipient being accessed. (required) 13768 :param DocumentVisibilityList document_visibility_list: 13769 :return: DocumentVisibilityList 13770 If the method is called asynchronously, 13771 returns the request thread. 13772 """ 13773 13774 all_params = ['account_id', 'envelope_id', 'recipient_id', 'document_visibility_list'] 13775 all_params.append('callback') 13776 all_params.append('_return_http_data_only') 13777 all_params.append('_preload_content') 13778 all_params.append('_request_timeout') 13779 13780 params = locals() 13781 for key, val in iteritems(params['kwargs']): 13782 if key not in all_params: 13783 raise TypeError( 13784 "Got an unexpected keyword argument '%s'" 13785 " to method update_recipient_document_visibility" % key 13786 ) 13787 params[key] = val 13788 del params['kwargs'] 13789 # verify the required parameter 'account_id' is set 13790 if ('account_id' not in params) or (params['account_id'] is None): 13791 raise ValueError("Missing the required parameter `account_id` when calling `update_recipient_document_visibility`") 13792 # verify the required parameter 'envelope_id' is set 13793 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13794 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipient_document_visibility`") 13795 # verify the required parameter 'recipient_id' is set 13796 if ('recipient_id' not in params) or (params['recipient_id'] is None): 13797 raise ValueError("Missing the required parameter `recipient_id` when calling `update_recipient_document_visibility`") 13798 13799 13800 collection_formats = {} 13801 13802 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/document_visibility'.replace('{format}', 'json') 13803 path_params = {} 13804 if 'account_id' in params: 13805 path_params['accountId'] = params['account_id'] 13806 if 'envelope_id' in params: 13807 path_params['envelopeId'] = params['envelope_id'] 13808 if 'recipient_id' in params: 13809 path_params['recipientId'] = params['recipient_id'] 13810 13811 query_params = {} 13812 13813 header_params = {} 13814 13815 form_params = [] 13816 local_var_files = {} 13817 13818 body_params = None 13819 if 'document_visibility_list' in params: 13820 body_params = params['document_visibility_list'] 13821 # HTTP header `Accept` 13822 header_params['Accept'] = self.api_client.\ 13823 select_header_accept(['application/json']) 13824 13825 # Authentication setting 13826 auth_settings = [] 13827 13828 return self.api_client.call_api(resource_path, 'PUT', 13829 path_params, 13830 query_params, 13831 header_params, 13832 body=body_params, 13833 post_params=form_params, 13834 files=local_var_files, 13835 response_type='DocumentVisibilityList', 13836 auth_settings=auth_settings, 13837 callback=params.get('callback'), 13838 _return_http_data_only=params.get('_return_http_data_only'), 13839 _preload_content=params.get('_preload_content', True), 13840 _request_timeout=params.get('_request_timeout'), 13841 collection_formats=collection_formats) 13842 13843 def update_recipient_initials_image(self, account_id, envelope_id, recipient_id, **kwargs): 13844 """ 13845 Sets the initials image for an accountless signer. 13846 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**. 13847 This method makes a synchronous HTTP request by default. To make an 13848 asynchronous HTTP request, please define a `callback` function 13849 to be invoked when receiving the response. 13850 >>> def callback_function(response): 13851 >>> pprint(response) 13852 >>> 13853 >>> thread = api.update_recipient_initials_image(account_id, envelope_id, recipient_id, callback=callback_function) 13854 13855 :param callback function: The callback function 13856 for asynchronous request. (optional) 13857 :param str account_id: The external account number (int) or account ID Guid. (required) 13858 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13859 :param str recipient_id: The ID of the recipient being accessed. (required) 13860 :return: None 13861 If the method is called asynchronously, 13862 returns the request thread. 13863 """ 13864 kwargs['_return_http_data_only'] = True 13865 if kwargs.get('callback'): 13866 return self.update_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13867 else: 13868 (data) = self.update_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13869 return data 13870 13871 def update_recipient_initials_image_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 13872 """ 13873 Sets the initials image for an accountless signer. 13874 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**. 13875 This method makes a synchronous HTTP request by default. To make an 13876 asynchronous HTTP request, please define a `callback` function 13877 to be invoked when receiving the response. 13878 >>> def callback_function(response): 13879 >>> pprint(response) 13880 >>> 13881 >>> thread = api.update_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 13882 13883 :param callback function: The callback function 13884 for asynchronous request. (optional) 13885 :param str account_id: The external account number (int) or account ID Guid. (required) 13886 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13887 :param str recipient_id: The ID of the recipient being accessed. (required) 13888 :return: None 13889 If the method is called asynchronously, 13890 returns the request thread. 13891 """ 13892 13893 all_params = ['account_id', 'envelope_id', 'recipient_id'] 13894 all_params.append('callback') 13895 all_params.append('_return_http_data_only') 13896 all_params.append('_preload_content') 13897 all_params.append('_request_timeout') 13898 13899 params = locals() 13900 for key, val in iteritems(params['kwargs']): 13901 if key not in all_params: 13902 raise TypeError( 13903 "Got an unexpected keyword argument '%s'" 13904 " to method update_recipient_initials_image" % key 13905 ) 13906 params[key] = val 13907 del params['kwargs'] 13908 # verify the required parameter 'account_id' is set 13909 if ('account_id' not in params) or (params['account_id'] is None): 13910 raise ValueError("Missing the required parameter `account_id` when calling `update_recipient_initials_image`") 13911 # verify the required parameter 'envelope_id' is set 13912 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13913 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipient_initials_image`") 13914 # verify the required parameter 'recipient_id' is set 13915 if ('recipient_id' not in params) or (params['recipient_id'] is None): 13916 raise ValueError("Missing the required parameter `recipient_id` when calling `update_recipient_initials_image`") 13917 13918 13919 collection_formats = {} 13920 13921 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/initials_image'.replace('{format}', 'json') 13922 path_params = {} 13923 if 'account_id' in params: 13924 path_params['accountId'] = params['account_id'] 13925 if 'envelope_id' in params: 13926 path_params['envelopeId'] = params['envelope_id'] 13927 if 'recipient_id' in params: 13928 path_params['recipientId'] = params['recipient_id'] 13929 13930 query_params = {} 13931 13932 header_params = {} 13933 13934 form_params = [] 13935 local_var_files = {} 13936 13937 body_params = None 13938 # HTTP header `Accept` 13939 header_params['Accept'] = self.api_client.\ 13940 select_header_accept(['application/json']) 13941 13942 # HTTP header `Content-Type` 13943 header_params['Content-Type'] = self.api_client.\ 13944 select_header_content_type(['image/gif']) 13945 13946 # Authentication setting 13947 auth_settings = [] 13948 13949 return self.api_client.call_api(resource_path, 'PUT', 13950 path_params, 13951 query_params, 13952 header_params, 13953 body=body_params, 13954 post_params=form_params, 13955 files=local_var_files, 13956 response_type=None, 13957 auth_settings=auth_settings, 13958 callback=params.get('callback'), 13959 _return_http_data_only=params.get('_return_http_data_only'), 13960 _preload_content=params.get('_preload_content', True), 13961 _request_timeout=params.get('_request_timeout'), 13962 collection_formats=collection_formats) 13963 13964 def update_recipient_signature_image(self, account_id, envelope_id, recipient_id, **kwargs): 13965 """ 13966 Sets the signature image for an accountless signer. 13967 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**. 13968 This method makes a synchronous HTTP request by default. To make an 13969 asynchronous HTTP request, please define a `callback` function 13970 to be invoked when receiving the response. 13971 >>> def callback_function(response): 13972 >>> pprint(response) 13973 >>> 13974 >>> thread = api.update_recipient_signature_image(account_id, envelope_id, recipient_id, callback=callback_function) 13975 13976 :param callback function: The callback function 13977 for asynchronous request. (optional) 13978 :param str account_id: The external account number (int) or account ID Guid. (required) 13979 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13980 :param str recipient_id: The ID of the recipient being accessed. (required) 13981 :return: None 13982 If the method is called asynchronously, 13983 returns the request thread. 13984 """ 13985 kwargs['_return_http_data_only'] = True 13986 if kwargs.get('callback'): 13987 return self.update_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13988 else: 13989 (data) = self.update_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13990 return data 13991 13992 def update_recipient_signature_image_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 13993 """ 13994 Sets the signature image for an accountless signer. 13995 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**. 13996 This method makes a synchronous HTTP request by default. To make an 13997 asynchronous HTTP request, please define a `callback` function 13998 to be invoked when receiving the response. 13999 >>> def callback_function(response): 14000 >>> pprint(response) 14001 >>> 14002 >>> thread = api.update_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 14003 14004 :param callback function: The callback function 14005 for asynchronous request. (optional) 14006 :param str account_id: The external account number (int) or account ID Guid. (required) 14007 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14008 :param str recipient_id: The ID of the recipient being accessed. (required) 14009 :return: None 14010 If the method is called asynchronously, 14011 returns the request thread. 14012 """ 14013 14014 all_params = ['account_id', 'envelope_id', 'recipient_id'] 14015 all_params.append('callback') 14016 all_params.append('_return_http_data_only') 14017 all_params.append('_preload_content') 14018 all_params.append('_request_timeout') 14019 14020 params = locals() 14021 for key, val in iteritems(params['kwargs']): 14022 if key not in all_params: 14023 raise TypeError( 14024 "Got an unexpected keyword argument '%s'" 14025 " to method update_recipient_signature_image" % key 14026 ) 14027 params[key] = val 14028 del params['kwargs'] 14029 # verify the required parameter 'account_id' is set 14030 if ('account_id' not in params) or (params['account_id'] is None): 14031 raise ValueError("Missing the required parameter `account_id` when calling `update_recipient_signature_image`") 14032 # verify the required parameter 'envelope_id' is set 14033 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14034 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipient_signature_image`") 14035 # verify the required parameter 'recipient_id' is set 14036 if ('recipient_id' not in params) or (params['recipient_id'] is None): 14037 raise ValueError("Missing the required parameter `recipient_id` when calling `update_recipient_signature_image`") 14038 14039 14040 collection_formats = {} 14041 14042 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/signature_image'.replace('{format}', 'json') 14043 path_params = {} 14044 if 'account_id' in params: 14045 path_params['accountId'] = params['account_id'] 14046 if 'envelope_id' in params: 14047 path_params['envelopeId'] = params['envelope_id'] 14048 if 'recipient_id' in params: 14049 path_params['recipientId'] = params['recipient_id'] 14050 14051 query_params = {} 14052 14053 header_params = {} 14054 14055 form_params = [] 14056 local_var_files = {} 14057 14058 body_params = None 14059 # HTTP header `Accept` 14060 header_params['Accept'] = self.api_client.\ 14061 select_header_accept(['application/json']) 14062 14063 # HTTP header `Content-Type` 14064 header_params['Content-Type'] = self.api_client.\ 14065 select_header_content_type(['image/gif']) 14066 14067 # Authentication setting 14068 auth_settings = [] 14069 14070 return self.api_client.call_api(resource_path, 'PUT', 14071 path_params, 14072 query_params, 14073 header_params, 14074 body=body_params, 14075 post_params=form_params, 14076 files=local_var_files, 14077 response_type=None, 14078 auth_settings=auth_settings, 14079 callback=params.get('callback'), 14080 _return_http_data_only=params.get('_return_http_data_only'), 14081 _preload_content=params.get('_preload_content', True), 14082 _request_timeout=params.get('_request_timeout'), 14083 collection_formats=collection_formats) 14084 14085 def update_recipients(self, account_id, envelope_id, **kwargs): 14086 """ 14087 Updates recipients in a draft envelope or corrects recipient information for an in process envelope. 14088 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). 14089 This method makes a synchronous HTTP request by default. To make an 14090 asynchronous HTTP request, please define a `callback` function 14091 to be invoked when receiving the response. 14092 >>> def callback_function(response): 14093 >>> pprint(response) 14094 >>> 14095 >>> thread = api.update_recipients(account_id, envelope_id, callback=callback_function) 14096 14097 :param callback function: The callback function 14098 for asynchronous request. (optional) 14099 :param str account_id: The external account number (int) or account ID Guid. (required) 14100 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14101 :param str combine_same_order_recipients: 14102 :param str offline_signing: 14103 :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. 14104 :param Recipients recipients: 14105 :return: RecipientsUpdateSummary 14106 If the method is called asynchronously, 14107 returns the request thread. 14108 """ 14109 kwargs['_return_http_data_only'] = True 14110 if kwargs.get('callback'): 14111 return self.update_recipients_with_http_info(account_id, envelope_id, **kwargs) 14112 else: 14113 (data) = self.update_recipients_with_http_info(account_id, envelope_id, **kwargs) 14114 return data 14115 14116 def update_recipients_with_http_info(self, account_id, envelope_id, **kwargs): 14117 """ 14118 Updates recipients in a draft envelope or corrects recipient information for an in process envelope. 14119 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). 14120 This method makes a synchronous HTTP request by default. To make an 14121 asynchronous HTTP request, please define a `callback` function 14122 to be invoked when receiving the response. 14123 >>> def callback_function(response): 14124 >>> pprint(response) 14125 >>> 14126 >>> thread = api.update_recipients_with_http_info(account_id, envelope_id, callback=callback_function) 14127 14128 :param callback function: The callback function 14129 for asynchronous request. (optional) 14130 :param str account_id: The external account number (int) or account ID Guid. (required) 14131 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14132 :param str combine_same_order_recipients: 14133 :param str offline_signing: 14134 :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. 14135 :param Recipients recipients: 14136 :return: RecipientsUpdateSummary 14137 If the method is called asynchronously, 14138 returns the request thread. 14139 """ 14140 14141 all_params = ['account_id', 'envelope_id', 'combine_same_order_recipients', 'offline_signing', 'resend_envelope', 'recipients'] 14142 all_params.append('callback') 14143 all_params.append('_return_http_data_only') 14144 all_params.append('_preload_content') 14145 all_params.append('_request_timeout') 14146 14147 params = locals() 14148 for key, val in iteritems(params['kwargs']): 14149 if key not in all_params: 14150 raise TypeError( 14151 "Got an unexpected keyword argument '%s'" 14152 " to method update_recipients" % key 14153 ) 14154 params[key] = val 14155 del params['kwargs'] 14156 # verify the required parameter 'account_id' is set 14157 if ('account_id' not in params) or (params['account_id'] is None): 14158 raise ValueError("Missing the required parameter `account_id` when calling `update_recipients`") 14159 # verify the required parameter 'envelope_id' is set 14160 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14161 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipients`") 14162 14163 14164 collection_formats = {} 14165 14166 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients'.replace('{format}', 'json') 14167 path_params = {} 14168 if 'account_id' in params: 14169 path_params['accountId'] = params['account_id'] 14170 if 'envelope_id' in params: 14171 path_params['envelopeId'] = params['envelope_id'] 14172 14173 query_params = {} 14174 if 'combine_same_order_recipients' in params: 14175 query_params['combine_same_order_recipients'] = params['combine_same_order_recipients'] 14176 if 'offline_signing' in params: 14177 query_params['offline_signing'] = params['offline_signing'] 14178 if 'resend_envelope' in params: 14179 query_params['resend_envelope'] = params['resend_envelope'] 14180 14181 header_params = {} 14182 14183 form_params = [] 14184 local_var_files = {} 14185 14186 body_params = None 14187 if 'recipients' in params: 14188 body_params = params['recipients'] 14189 # HTTP header `Accept` 14190 header_params['Accept'] = self.api_client.\ 14191 select_header_accept(['application/json']) 14192 14193 # Authentication setting 14194 auth_settings = [] 14195 14196 return self.api_client.call_api(resource_path, 'PUT', 14197 path_params, 14198 query_params, 14199 header_params, 14200 body=body_params, 14201 post_params=form_params, 14202 files=local_var_files, 14203 response_type='RecipientsUpdateSummary', 14204 auth_settings=auth_settings, 14205 callback=params.get('callback'), 14206 _return_http_data_only=params.get('_return_http_data_only'), 14207 _preload_content=params.get('_preload_content', True), 14208 _request_timeout=params.get('_request_timeout'), 14209 collection_formats=collection_formats) 14210 14211 def update_recipients_document_visibility(self, account_id, envelope_id, **kwargs): 14212 """ 14213 Updates document visibility for the recipients 14214 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. 14215 This method makes a synchronous HTTP request by default. To make an 14216 asynchronous HTTP request, please define a `callback` function 14217 to be invoked when receiving the response. 14218 >>> def callback_function(response): 14219 >>> pprint(response) 14220 >>> 14221 >>> thread = api.update_recipients_document_visibility(account_id, envelope_id, callback=callback_function) 14222 14223 :param callback function: The callback function 14224 for asynchronous request. (optional) 14225 :param str account_id: The external account number (int) or account ID Guid. (required) 14226 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14227 :param DocumentVisibilityList document_visibility_list: 14228 :return: DocumentVisibilityList 14229 If the method is called asynchronously, 14230 returns the request thread. 14231 """ 14232 kwargs['_return_http_data_only'] = True 14233 if kwargs.get('callback'): 14234 return self.update_recipients_document_visibility_with_http_info(account_id, envelope_id, **kwargs) 14235 else: 14236 (data) = self.update_recipients_document_visibility_with_http_info(account_id, envelope_id, **kwargs) 14237 return data 14238 14239 def update_recipients_document_visibility_with_http_info(self, account_id, envelope_id, **kwargs): 14240 """ 14241 Updates document visibility for the recipients 14242 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. 14243 This method makes a synchronous HTTP request by default. To make an 14244 asynchronous HTTP request, please define a `callback` function 14245 to be invoked when receiving the response. 14246 >>> def callback_function(response): 14247 >>> pprint(response) 14248 >>> 14249 >>> thread = api.update_recipients_document_visibility_with_http_info(account_id, envelope_id, callback=callback_function) 14250 14251 :param callback function: The callback function 14252 for asynchronous request. (optional) 14253 :param str account_id: The external account number (int) or account ID Guid. (required) 14254 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14255 :param DocumentVisibilityList document_visibility_list: 14256 :return: DocumentVisibilityList 14257 If the method is called asynchronously, 14258 returns the request thread. 14259 """ 14260 14261 all_params = ['account_id', 'envelope_id', 'document_visibility_list'] 14262 all_params.append('callback') 14263 all_params.append('_return_http_data_only') 14264 all_params.append('_preload_content') 14265 all_params.append('_request_timeout') 14266 14267 params = locals() 14268 for key, val in iteritems(params['kwargs']): 14269 if key not in all_params: 14270 raise TypeError( 14271 "Got an unexpected keyword argument '%s'" 14272 " to method update_recipients_document_visibility" % key 14273 ) 14274 params[key] = val 14275 del params['kwargs'] 14276 # verify the required parameter 'account_id' is set 14277 if ('account_id' not in params) or (params['account_id'] is None): 14278 raise ValueError("Missing the required parameter `account_id` when calling `update_recipients_document_visibility`") 14279 # verify the required parameter 'envelope_id' is set 14280 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14281 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipients_document_visibility`") 14282 14283 14284 collection_formats = {} 14285 14286 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/document_visibility'.replace('{format}', 'json') 14287 path_params = {} 14288 if 'account_id' in params: 14289 path_params['accountId'] = params['account_id'] 14290 if 'envelope_id' in params: 14291 path_params['envelopeId'] = params['envelope_id'] 14292 14293 query_params = {} 14294 14295 header_params = {} 14296 14297 form_params = [] 14298 local_var_files = {} 14299 14300 body_params = None 14301 if 'document_visibility_list' in params: 14302 body_params = params['document_visibility_list'] 14303 # HTTP header `Accept` 14304 header_params['Accept'] = self.api_client.\ 14305 select_header_accept(['application/json']) 14306 14307 # Authentication setting 14308 auth_settings = [] 14309 14310 return self.api_client.call_api(resource_path, 'PUT', 14311 path_params, 14312 query_params, 14313 header_params, 14314 body=body_params, 14315 post_params=form_params, 14316 files=local_var_files, 14317 response_type='DocumentVisibilityList', 14318 auth_settings=auth_settings, 14319 callback=params.get('callback'), 14320 _return_http_data_only=params.get('_return_http_data_only'), 14321 _preload_content=params.get('_preload_content', True), 14322 _request_timeout=params.get('_request_timeout'), 14323 collection_formats=collection_formats) 14324 14325 def update_tabs(self, account_id, envelope_id, recipient_id, **kwargs): 14326 """ 14327 Updates the tabs for a recipient. 14328 Updates one or more tabs for a recipient in a draft envelope. 14329 This method makes a synchronous HTTP request by default. To make an 14330 asynchronous HTTP request, please define a `callback` function 14331 to be invoked when receiving the response. 14332 >>> def callback_function(response): 14333 >>> pprint(response) 14334 >>> 14335 >>> thread = api.update_tabs(account_id, envelope_id, recipient_id, callback=callback_function) 14336 14337 :param callback function: The callback function 14338 for asynchronous request. (optional) 14339 :param str account_id: The external account number (int) or account ID Guid. (required) 14340 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14341 :param str recipient_id: The ID of the recipient being accessed. (required) 14342 :param Tabs tabs: 14343 :return: Tabs 14344 If the method is called asynchronously, 14345 returns the request thread. 14346 """ 14347 kwargs['_return_http_data_only'] = True 14348 if kwargs.get('callback'): 14349 return self.update_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 14350 else: 14351 (data) = self.update_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 14352 return data 14353 14354 def update_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 14355 """ 14356 Updates the tabs for a recipient. 14357 Updates one or more tabs for a recipient in a draft envelope. 14358 This method makes a synchronous HTTP request by default. To make an 14359 asynchronous HTTP request, please define a `callback` function 14360 to be invoked when receiving the response. 14361 >>> def callback_function(response): 14362 >>> pprint(response) 14363 >>> 14364 >>> thread = api.update_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 14365 14366 :param callback function: The callback function 14367 for asynchronous request. (optional) 14368 :param str account_id: The external account number (int) or account ID Guid. (required) 14369 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14370 :param str recipient_id: The ID of the recipient being accessed. (required) 14371 :param Tabs tabs: 14372 :return: Tabs 14373 If the method is called asynchronously, 14374 returns the request thread. 14375 """ 14376 14377 all_params = ['account_id', 'envelope_id', 'recipient_id', 'tabs'] 14378 all_params.append('callback') 14379 all_params.append('_return_http_data_only') 14380 all_params.append('_preload_content') 14381 all_params.append('_request_timeout') 14382 14383 params = locals() 14384 for key, val in iteritems(params['kwargs']): 14385 if key not in all_params: 14386 raise TypeError( 14387 "Got an unexpected keyword argument '%s'" 14388 " to method update_tabs" % key 14389 ) 14390 params[key] = val 14391 del params['kwargs'] 14392 # verify the required parameter 'account_id' is set 14393 if ('account_id' not in params) or (params['account_id'] is None): 14394 raise ValueError("Missing the required parameter `account_id` when calling `update_tabs`") 14395 # verify the required parameter 'envelope_id' is set 14396 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14397 raise ValueError("Missing the required parameter `envelope_id` when calling `update_tabs`") 14398 # verify the required parameter 'recipient_id' is set 14399 if ('recipient_id' not in params) or (params['recipient_id'] is None): 14400 raise ValueError("Missing the required parameter `recipient_id` when calling `update_tabs`") 14401 14402 14403 collection_formats = {} 14404 14405 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/tabs'.replace('{format}', 'json') 14406 path_params = {} 14407 if 'account_id' in params: 14408 path_params['accountId'] = params['account_id'] 14409 if 'envelope_id' in params: 14410 path_params['envelopeId'] = params['envelope_id'] 14411 if 'recipient_id' in params: 14412 path_params['recipientId'] = params['recipient_id'] 14413 14414 query_params = {} 14415 14416 header_params = {} 14417 14418 form_params = [] 14419 local_var_files = {} 14420 14421 body_params = None 14422 if 'tabs' in params: 14423 body_params = params['tabs'] 14424 # HTTP header `Accept` 14425 header_params['Accept'] = self.api_client.\ 14426 select_header_accept(['application/json']) 14427 14428 # Authentication setting 14429 auth_settings = [] 14430 14431 return self.api_client.call_api(resource_path, 'PUT', 14432 path_params, 14433 query_params, 14434 header_params, 14435 body=body_params, 14436 post_params=form_params, 14437 files=local_var_files, 14438 response_type='Tabs', 14439 auth_settings=auth_settings, 14440 callback=params.get('callback'), 14441 _return_http_data_only=params.get('_return_http_data_only'), 14442 _preload_content=params.get('_preload_content', True), 14443 _request_timeout=params.get('_request_timeout'), 14444 collection_formats=collection_formats) 14445 14446 def update_tabs_blob(self, account_id, envelope_id, **kwargs): 14447 """ 14448 Update encrypted tabs for envelope. 14449 14450 This method makes a synchronous HTTP request by default. To make an 14451 asynchronous HTTP request, please define a `callback` function 14452 to be invoked when receiving the response. 14453 >>> def callback_function(response): 14454 >>> pprint(response) 14455 >>> 14456 >>> thread = api.update_tabs_blob(account_id, envelope_id, callback=callback_function) 14457 14458 :param callback function: The callback function 14459 for asynchronous request. (optional) 14460 :param str account_id: The external account number (int) or account ID Guid. (required) 14461 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14462 :return: None 14463 If the method is called asynchronously, 14464 returns the request thread. 14465 """ 14466 kwargs['_return_http_data_only'] = True 14467 if kwargs.get('callback'): 14468 return self.update_tabs_blob_with_http_info(account_id, envelope_id, **kwargs) 14469 else: 14470 (data) = self.update_tabs_blob_with_http_info(account_id, envelope_id, **kwargs) 14471 return data 14472 14473 def update_tabs_blob_with_http_info(self, account_id, envelope_id, **kwargs): 14474 """ 14475 Update encrypted tabs for envelope. 14476 14477 This method makes a synchronous HTTP request by default. To make an 14478 asynchronous HTTP request, please define a `callback` function 14479 to be invoked when receiving the response. 14480 >>> def callback_function(response): 14481 >>> pprint(response) 14482 >>> 14483 >>> thread = api.update_tabs_blob_with_http_info(account_id, envelope_id, callback=callback_function) 14484 14485 :param callback function: The callback function 14486 for asynchronous request. (optional) 14487 :param str account_id: The external account number (int) or account ID Guid. (required) 14488 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14489 :return: None 14490 If the method is called asynchronously, 14491 returns the request thread. 14492 """ 14493 14494 all_params = ['account_id', 'envelope_id'] 14495 all_params.append('callback') 14496 all_params.append('_return_http_data_only') 14497 all_params.append('_preload_content') 14498 all_params.append('_request_timeout') 14499 14500 params = locals() 14501 for key, val in iteritems(params['kwargs']): 14502 if key not in all_params: 14503 raise TypeError( 14504 "Got an unexpected keyword argument '%s'" 14505 " to method update_tabs_blob" % key 14506 ) 14507 params[key] = val 14508 del params['kwargs'] 14509 # verify the required parameter 'account_id' is set 14510 if ('account_id' not in params) or (params['account_id'] is None): 14511 raise ValueError("Missing the required parameter `account_id` when calling `update_tabs_blob`") 14512 # verify the required parameter 'envelope_id' is set 14513 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14514 raise ValueError("Missing the required parameter `envelope_id` when calling `update_tabs_blob`") 14515 14516 14517 collection_formats = {} 14518 14519 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/tabs_blob'.replace('{format}', 'json') 14520 path_params = {} 14521 if 'account_id' in params: 14522 path_params['accountId'] = params['account_id'] 14523 if 'envelope_id' in params: 14524 path_params['envelopeId'] = params['envelope_id'] 14525 14526 query_params = {} 14527 14528 header_params = {} 14529 14530 form_params = [] 14531 local_var_files = {} 14532 14533 body_params = None 14534 # HTTP header `Accept` 14535 header_params['Accept'] = self.api_client.\ 14536 select_header_accept(['application/json']) 14537 14538 # Authentication setting 14539 auth_settings = [] 14540 14541 return self.api_client.call_api(resource_path, 'PUT', 14542 path_params, 14543 query_params, 14544 header_params, 14545 body=body_params, 14546 post_params=form_params, 14547 files=local_var_files, 14548 response_type=None, 14549 auth_settings=auth_settings, 14550 callback=params.get('callback'), 14551 _return_http_data_only=params.get('_return_http_data_only'), 14552 _preload_content=params.get('_preload_content', True), 14553 _request_timeout=params.get('_request_timeout'), 14554 collection_formats=collection_formats) 14555 14556 def update_template_delayed_routing_definition(self, account_id, template_id, workflow_step_id, **kwargs): 14557 """ 14558 Updates the delayed routing rules for a template's workflow step definition. 14559 This method makes a synchronous HTTP request by default. To make an 14560 asynchronous HTTP request, please define a `callback` function 14561 to be invoked when receiving the response. 14562 >>> def callback_function(response): 14563 >>> pprint(response) 14564 >>> 14565 >>> thread = api.update_template_delayed_routing_definition(account_id, template_id, workflow_step_id, callback=callback_function) 14566 14567 :param callback function: The callback function 14568 for asynchronous request. (optional) 14569 :param str account_id: The external account number (int) or account ID Guid. (required) 14570 :param str template_id: The ID of the template being accessed. (required) 14571 :param str workflow_step_id: (required) 14572 :param DelayedRouting delayed_routing: 14573 :return: DelayedRouting 14574 If the method is called asynchronously, 14575 returns the request thread. 14576 """ 14577 kwargs['_return_http_data_only'] = True 14578 if kwargs.get('callback'): 14579 return self.update_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 14580 else: 14581 (data) = self.update_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 14582 return data 14583 14584 def update_template_delayed_routing_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 14585 """ 14586 Updates the delayed routing rules for a template's workflow step definition. 14587 This method makes a synchronous HTTP request by default. To make an 14588 asynchronous HTTP request, please define a `callback` function 14589 to be invoked when receiving the response. 14590 >>> def callback_function(response): 14591 >>> pprint(response) 14592 >>> 14593 >>> thread = api.update_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 14594 14595 :param callback function: The callback function 14596 for asynchronous request. (optional) 14597 :param str account_id: The external account number (int) or account ID Guid. (required) 14598 :param str template_id: The ID of the template being accessed. (required) 14599 :param str workflow_step_id: (required) 14600 :param DelayedRouting delayed_routing: 14601 :return: DelayedRouting 14602 If the method is called asynchronously, 14603 returns the request thread. 14604 """ 14605 14606 all_params = ['account_id', 'template_id', 'workflow_step_id', 'delayed_routing'] 14607 all_params.append('callback') 14608 all_params.append('_return_http_data_only') 14609 all_params.append('_preload_content') 14610 all_params.append('_request_timeout') 14611 14612 params = locals() 14613 for key, val in iteritems(params['kwargs']): 14614 if key not in all_params: 14615 raise TypeError( 14616 "Got an unexpected keyword argument '%s'" 14617 " to method update_template_delayed_routing_definition" % key 14618 ) 14619 params[key] = val 14620 del params['kwargs'] 14621 # verify the required parameter 'account_id' is set 14622 if ('account_id' not in params) or (params['account_id'] is None): 14623 raise ValueError("Missing the required parameter `account_id` when calling `update_template_delayed_routing_definition`") 14624 # verify the required parameter 'template_id' is set 14625 if ('template_id' not in params) or (params['template_id'] is None): 14626 raise ValueError("Missing the required parameter `template_id` when calling `update_template_delayed_routing_definition`") 14627 # verify the required parameter 'workflow_step_id' is set 14628 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 14629 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_template_delayed_routing_definition`") 14630 14631 14632 collection_formats = {} 14633 14634 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 14635 path_params = {} 14636 if 'account_id' in params: 14637 path_params['accountId'] = params['account_id'] 14638 if 'template_id' in params: 14639 path_params['templateId'] = params['template_id'] 14640 if 'workflow_step_id' in params: 14641 path_params['workflowStepId'] = params['workflow_step_id'] 14642 14643 query_params = {} 14644 14645 header_params = {} 14646 14647 form_params = [] 14648 local_var_files = {} 14649 14650 body_params = None 14651 if 'delayed_routing' in params: 14652 body_params = params['delayed_routing'] 14653 # HTTP header `Accept` 14654 header_params['Accept'] = self.api_client.\ 14655 select_header_accept(['application/json']) 14656 14657 # Authentication setting 14658 auth_settings = [] 14659 14660 return self.api_client.call_api(resource_path, 'PUT', 14661 path_params, 14662 query_params, 14663 header_params, 14664 body=body_params, 14665 post_params=form_params, 14666 files=local_var_files, 14667 response_type='DelayedRouting', 14668 auth_settings=auth_settings, 14669 callback=params.get('callback'), 14670 _return_http_data_only=params.get('_return_http_data_only'), 14671 _preload_content=params.get('_preload_content', True), 14672 _request_timeout=params.get('_request_timeout'), 14673 collection_formats=collection_formats) 14674 14675 def update_template_recipient_document_visibility(self, account_id, recipient_id, template_id, **kwargs): 14676 """ 14677 Updates document visibility for the recipients 14678 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. 14679 This method makes a synchronous HTTP request by default. To make an 14680 asynchronous HTTP request, please define a `callback` function 14681 to be invoked when receiving the response. 14682 >>> def callback_function(response): 14683 >>> pprint(response) 14684 >>> 14685 >>> thread = api.update_template_recipient_document_visibility(account_id, recipient_id, template_id, callback=callback_function) 14686 14687 :param callback function: The callback function 14688 for asynchronous request. (optional) 14689 :param str account_id: The external account number (int) or account ID Guid. (required) 14690 :param str recipient_id: The ID of the recipient being accessed. (required) 14691 :param str template_id: The ID of the template being accessed. (required) 14692 :param TemplateDocumentVisibilityList template_document_visibility_list: 14693 :return: TemplateDocumentVisibilityList 14694 If the method is called asynchronously, 14695 returns the request thread. 14696 """ 14697 kwargs['_return_http_data_only'] = True 14698 if kwargs.get('callback'): 14699 return self.update_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, **kwargs) 14700 else: 14701 (data) = self.update_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, **kwargs) 14702 return data 14703 14704 def update_template_recipient_document_visibility_with_http_info(self, account_id, recipient_id, template_id, **kwargs): 14705 """ 14706 Updates document visibility for the recipients 14707 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. 14708 This method makes a synchronous HTTP request by default. To make an 14709 asynchronous HTTP request, please define a `callback` function 14710 to be invoked when receiving the response. 14711 >>> def callback_function(response): 14712 >>> pprint(response) 14713 >>> 14714 >>> thread = api.update_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, callback=callback_function) 14715 14716 :param callback function: The callback function 14717 for asynchronous request. (optional) 14718 :param str account_id: The external account number (int) or account ID Guid. (required) 14719 :param str recipient_id: The ID of the recipient being accessed. (required) 14720 :param str template_id: The ID of the template being accessed. (required) 14721 :param TemplateDocumentVisibilityList template_document_visibility_list: 14722 :return: TemplateDocumentVisibilityList 14723 If the method is called asynchronously, 14724 returns the request thread. 14725 """ 14726 14727 all_params = ['account_id', 'recipient_id', 'template_id', 'template_document_visibility_list'] 14728 all_params.append('callback') 14729 all_params.append('_return_http_data_only') 14730 all_params.append('_preload_content') 14731 all_params.append('_request_timeout') 14732 14733 params = locals() 14734 for key, val in iteritems(params['kwargs']): 14735 if key not in all_params: 14736 raise TypeError( 14737 "Got an unexpected keyword argument '%s'" 14738 " to method update_template_recipient_document_visibility" % key 14739 ) 14740 params[key] = val 14741 del params['kwargs'] 14742 # verify the required parameter 'account_id' is set 14743 if ('account_id' not in params) or (params['account_id'] is None): 14744 raise ValueError("Missing the required parameter `account_id` when calling `update_template_recipient_document_visibility`") 14745 # verify the required parameter 'recipient_id' is set 14746 if ('recipient_id' not in params) or (params['recipient_id'] is None): 14747 raise ValueError("Missing the required parameter `recipient_id` when calling `update_template_recipient_document_visibility`") 14748 # verify the required parameter 'template_id' is set 14749 if ('template_id' not in params) or (params['template_id'] is None): 14750 raise ValueError("Missing the required parameter `template_id` when calling `update_template_recipient_document_visibility`") 14751 14752 14753 collection_formats = {} 14754 14755 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/recipients/{recipientId}/document_visibility'.replace('{format}', 'json') 14756 path_params = {} 14757 if 'account_id' in params: 14758 path_params['accountId'] = params['account_id'] 14759 if 'recipient_id' in params: 14760 path_params['recipientId'] = params['recipient_id'] 14761 if 'template_id' in params: 14762 path_params['templateId'] = params['template_id'] 14763 14764 query_params = {} 14765 14766 header_params = {} 14767 14768 form_params = [] 14769 local_var_files = {} 14770 14771 body_params = None 14772 if 'template_document_visibility_list' in params: 14773 body_params = params['template_document_visibility_list'] 14774 # HTTP header `Accept` 14775 header_params['Accept'] = self.api_client.\ 14776 select_header_accept(['application/json']) 14777 14778 # Authentication setting 14779 auth_settings = [] 14780 14781 return self.api_client.call_api(resource_path, 'PUT', 14782 path_params, 14783 query_params, 14784 header_params, 14785 body=body_params, 14786 post_params=form_params, 14787 files=local_var_files, 14788 response_type='TemplateDocumentVisibilityList', 14789 auth_settings=auth_settings, 14790 callback=params.get('callback'), 14791 _return_http_data_only=params.get('_return_http_data_only'), 14792 _preload_content=params.get('_preload_content', True), 14793 _request_timeout=params.get('_request_timeout'), 14794 collection_formats=collection_formats) 14795 14796 def update_template_recipients_document_visibility(self, account_id, template_id, **kwargs): 14797 """ 14798 Updates document visibility for the recipients 14799 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. 14800 This method makes a synchronous HTTP request by default. To make an 14801 asynchronous HTTP request, please define a `callback` function 14802 to be invoked when receiving the response. 14803 >>> def callback_function(response): 14804 >>> pprint(response) 14805 >>> 14806 >>> thread = api.update_template_recipients_document_visibility(account_id, template_id, callback=callback_function) 14807 14808 :param callback function: The callback function 14809 for asynchronous request. (optional) 14810 :param str account_id: The external account number (int) or account ID Guid. (required) 14811 :param str template_id: The ID of the template being accessed. (required) 14812 :param TemplateDocumentVisibilityList template_document_visibility_list: 14813 :return: TemplateDocumentVisibilityList 14814 If the method is called asynchronously, 14815 returns the request thread. 14816 """ 14817 kwargs['_return_http_data_only'] = True 14818 if kwargs.get('callback'): 14819 return self.update_template_recipients_document_visibility_with_http_info(account_id, template_id, **kwargs) 14820 else: 14821 (data) = self.update_template_recipients_document_visibility_with_http_info(account_id, template_id, **kwargs) 14822 return data 14823 14824 def update_template_recipients_document_visibility_with_http_info(self, account_id, template_id, **kwargs): 14825 """ 14826 Updates document visibility for the recipients 14827 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. 14828 This method makes a synchronous HTTP request by default. To make an 14829 asynchronous HTTP request, please define a `callback` function 14830 to be invoked when receiving the response. 14831 >>> def callback_function(response): 14832 >>> pprint(response) 14833 >>> 14834 >>> thread = api.update_template_recipients_document_visibility_with_http_info(account_id, template_id, callback=callback_function) 14835 14836 :param callback function: The callback function 14837 for asynchronous request. (optional) 14838 :param str account_id: The external account number (int) or account ID Guid. (required) 14839 :param str template_id: The ID of the template being accessed. (required) 14840 :param TemplateDocumentVisibilityList template_document_visibility_list: 14841 :return: TemplateDocumentVisibilityList 14842 If the method is called asynchronously, 14843 returns the request thread. 14844 """ 14845 14846 all_params = ['account_id', 'template_id', 'template_document_visibility_list'] 14847 all_params.append('callback') 14848 all_params.append('_return_http_data_only') 14849 all_params.append('_preload_content') 14850 all_params.append('_request_timeout') 14851 14852 params = locals() 14853 for key, val in iteritems(params['kwargs']): 14854 if key not in all_params: 14855 raise TypeError( 14856 "Got an unexpected keyword argument '%s'" 14857 " to method update_template_recipients_document_visibility" % key 14858 ) 14859 params[key] = val 14860 del params['kwargs'] 14861 # verify the required parameter 'account_id' is set 14862 if ('account_id' not in params) or (params['account_id'] is None): 14863 raise ValueError("Missing the required parameter `account_id` when calling `update_template_recipients_document_visibility`") 14864 # verify the required parameter 'template_id' is set 14865 if ('template_id' not in params) or (params['template_id'] is None): 14866 raise ValueError("Missing the required parameter `template_id` when calling `update_template_recipients_document_visibility`") 14867 14868 14869 collection_formats = {} 14870 14871 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/recipients/document_visibility'.replace('{format}', 'json') 14872 path_params = {} 14873 if 'account_id' in params: 14874 path_params['accountId'] = params['account_id'] 14875 if 'template_id' in params: 14876 path_params['templateId'] = params['template_id'] 14877 14878 query_params = {} 14879 14880 header_params = {} 14881 14882 form_params = [] 14883 local_var_files = {} 14884 14885 body_params = None 14886 if 'template_document_visibility_list' in params: 14887 body_params = params['template_document_visibility_list'] 14888 # HTTP header `Accept` 14889 header_params['Accept'] = self.api_client.\ 14890 select_header_accept(['application/json']) 14891 14892 # Authentication setting 14893 auth_settings = [] 14894 14895 return self.api_client.call_api(resource_path, 'PUT', 14896 path_params, 14897 query_params, 14898 header_params, 14899 body=body_params, 14900 post_params=form_params, 14901 files=local_var_files, 14902 response_type='TemplateDocumentVisibilityList', 14903 auth_settings=auth_settings, 14904 callback=params.get('callback'), 14905 _return_http_data_only=params.get('_return_http_data_only'), 14906 _preload_content=params.get('_preload_content', True), 14907 _request_timeout=params.get('_request_timeout'), 14908 collection_formats=collection_formats) 14909 14910 def update_template_scheduled_sending_definition(self, account_id, template_id, **kwargs): 14911 """ 14912 Updates the scheduled sending rules for a template's workflow definition. 14913 This method makes a synchronous HTTP request by default. To make an 14914 asynchronous HTTP request, please define a `callback` function 14915 to be invoked when receiving the response. 14916 >>> def callback_function(response): 14917 >>> pprint(response) 14918 >>> 14919 >>> thread = api.update_template_scheduled_sending_definition(account_id, template_id, callback=callback_function) 14920 14921 :param callback function: The callback function 14922 for asynchronous request. (optional) 14923 :param str account_id: The external account number (int) or account ID Guid. (required) 14924 :param str template_id: The ID of the template being accessed. (required) 14925 :param ScheduledSending scheduled_sending: 14926 :return: ScheduledSending 14927 If the method is called asynchronously, 14928 returns the request thread. 14929 """ 14930 kwargs['_return_http_data_only'] = True 14931 if kwargs.get('callback'): 14932 return self.update_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 14933 else: 14934 (data) = self.update_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 14935 return data 14936 14937 def update_template_scheduled_sending_definition_with_http_info(self, account_id, template_id, **kwargs): 14938 """ 14939 Updates the scheduled sending rules for a template's workflow definition. 14940 This method makes a synchronous HTTP request by default. To make an 14941 asynchronous HTTP request, please define a `callback` function 14942 to be invoked when receiving the response. 14943 >>> def callback_function(response): 14944 >>> pprint(response) 14945 >>> 14946 >>> thread = api.update_template_scheduled_sending_definition_with_http_info(account_id, template_id, callback=callback_function) 14947 14948 :param callback function: The callback function 14949 for asynchronous request. (optional) 14950 :param str account_id: The external account number (int) or account ID Guid. (required) 14951 :param str template_id: The ID of the template being accessed. (required) 14952 :param ScheduledSending scheduled_sending: 14953 :return: ScheduledSending 14954 If the method is called asynchronously, 14955 returns the request thread. 14956 """ 14957 14958 all_params = ['account_id', 'template_id', 'scheduled_sending'] 14959 all_params.append('callback') 14960 all_params.append('_return_http_data_only') 14961 all_params.append('_preload_content') 14962 all_params.append('_request_timeout') 14963 14964 params = locals() 14965 for key, val in iteritems(params['kwargs']): 14966 if key not in all_params: 14967 raise TypeError( 14968 "Got an unexpected keyword argument '%s'" 14969 " to method update_template_scheduled_sending_definition" % key 14970 ) 14971 params[key] = val 14972 del params['kwargs'] 14973 # verify the required parameter 'account_id' is set 14974 if ('account_id' not in params) or (params['account_id'] is None): 14975 raise ValueError("Missing the required parameter `account_id` when calling `update_template_scheduled_sending_definition`") 14976 # verify the required parameter 'template_id' is set 14977 if ('template_id' not in params) or (params['template_id'] is None): 14978 raise ValueError("Missing the required parameter `template_id` when calling `update_template_scheduled_sending_definition`") 14979 14980 14981 collection_formats = {} 14982 14983 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/scheduledSending'.replace('{format}', 'json') 14984 path_params = {} 14985 if 'account_id' in params: 14986 path_params['accountId'] = params['account_id'] 14987 if 'template_id' in params: 14988 path_params['templateId'] = params['template_id'] 14989 14990 query_params = {} 14991 14992 header_params = {} 14993 14994 form_params = [] 14995 local_var_files = {} 14996 14997 body_params = None 14998 if 'scheduled_sending' in params: 14999 body_params = params['scheduled_sending'] 15000 # HTTP header `Accept` 15001 header_params['Accept'] = self.api_client.\ 15002 select_header_accept(['application/json']) 15003 15004 # Authentication setting 15005 auth_settings = [] 15006 15007 return self.api_client.call_api(resource_path, 'PUT', 15008 path_params, 15009 query_params, 15010 header_params, 15011 body=body_params, 15012 post_params=form_params, 15013 files=local_var_files, 15014 response_type='ScheduledSending', 15015 auth_settings=auth_settings, 15016 callback=params.get('callback'), 15017 _return_http_data_only=params.get('_return_http_data_only'), 15018 _preload_content=params.get('_preload_content', True), 15019 _request_timeout=params.get('_request_timeout'), 15020 collection_formats=collection_formats) 15021 15022 def update_template_workflow_definition(self, account_id, template_id, **kwargs): 15023 """ 15024 Updates the workflow definition for a template. 15025 Updates the specified template's workflow definition if it has one. 15026 This method makes a synchronous HTTP request by default. To make an 15027 asynchronous HTTP request, please define a `callback` function 15028 to be invoked when receiving the response. 15029 >>> def callback_function(response): 15030 >>> pprint(response) 15031 >>> 15032 >>> thread = api.update_template_workflow_definition(account_id, template_id, callback=callback_function) 15033 15034 :param callback function: The callback function 15035 for asynchronous request. (optional) 15036 :param str account_id: The external account number (int) or account ID Guid. (required) 15037 :param str template_id: The ID of the template being accessed. (required) 15038 :param Workflow workflow: 15039 :return: Workflow 15040 If the method is called asynchronously, 15041 returns the request thread. 15042 """ 15043 kwargs['_return_http_data_only'] = True 15044 if kwargs.get('callback'): 15045 return self.update_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 15046 else: 15047 (data) = self.update_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 15048 return data 15049 15050 def update_template_workflow_definition_with_http_info(self, account_id, template_id, **kwargs): 15051 """ 15052 Updates the workflow definition for a template. 15053 Updates the specified template's workflow definition if it has one. 15054 This method makes a synchronous HTTP request by default. To make an 15055 asynchronous HTTP request, please define a `callback` function 15056 to be invoked when receiving the response. 15057 >>> def callback_function(response): 15058 >>> pprint(response) 15059 >>> 15060 >>> thread = api.update_template_workflow_definition_with_http_info(account_id, template_id, callback=callback_function) 15061 15062 :param callback function: The callback function 15063 for asynchronous request. (optional) 15064 :param str account_id: The external account number (int) or account ID Guid. (required) 15065 :param str template_id: The ID of the template being accessed. (required) 15066 :param Workflow workflow: 15067 :return: Workflow 15068 If the method is called asynchronously, 15069 returns the request thread. 15070 """ 15071 15072 all_params = ['account_id', 'template_id', 'workflow'] 15073 all_params.append('callback') 15074 all_params.append('_return_http_data_only') 15075 all_params.append('_preload_content') 15076 all_params.append('_request_timeout') 15077 15078 params = locals() 15079 for key, val in iteritems(params['kwargs']): 15080 if key not in all_params: 15081 raise TypeError( 15082 "Got an unexpected keyword argument '%s'" 15083 " to method update_template_workflow_definition" % key 15084 ) 15085 params[key] = val 15086 del params['kwargs'] 15087 # verify the required parameter 'account_id' is set 15088 if ('account_id' not in params) or (params['account_id'] is None): 15089 raise ValueError("Missing the required parameter `account_id` when calling `update_template_workflow_definition`") 15090 # verify the required parameter 'template_id' is set 15091 if ('template_id' not in params) or (params['template_id'] is None): 15092 raise ValueError("Missing the required parameter `template_id` when calling `update_template_workflow_definition`") 15093 15094 15095 collection_formats = {} 15096 15097 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow'.replace('{format}', 'json') 15098 path_params = {} 15099 if 'account_id' in params: 15100 path_params['accountId'] = params['account_id'] 15101 if 'template_id' in params: 15102 path_params['templateId'] = params['template_id'] 15103 15104 query_params = {} 15105 15106 header_params = {} 15107 15108 form_params = [] 15109 local_var_files = {} 15110 15111 body_params = None 15112 if 'workflow' in params: 15113 body_params = params['workflow'] 15114 # HTTP header `Accept` 15115 header_params['Accept'] = self.api_client.\ 15116 select_header_accept(['application/json']) 15117 15118 # Authentication setting 15119 auth_settings = [] 15120 15121 return self.api_client.call_api(resource_path, 'PUT', 15122 path_params, 15123 query_params, 15124 header_params, 15125 body=body_params, 15126 post_params=form_params, 15127 files=local_var_files, 15128 response_type='Workflow', 15129 auth_settings=auth_settings, 15130 callback=params.get('callback'), 15131 _return_http_data_only=params.get('_return_http_data_only'), 15132 _preload_content=params.get('_preload_content', True), 15133 _request_timeout=params.get('_request_timeout'), 15134 collection_formats=collection_formats) 15135 15136 def update_template_workflow_step_definition(self, account_id, template_id, workflow_step_id, **kwargs): 15137 """ 15138 Updates the template workflow step definition for an envelope. 15139 This method makes a synchronous HTTP request by default. To make an 15140 asynchronous HTTP request, please define a `callback` function 15141 to be invoked when receiving the response. 15142 >>> def callback_function(response): 15143 >>> pprint(response) 15144 >>> 15145 >>> thread = api.update_template_workflow_step_definition(account_id, template_id, workflow_step_id, callback=callback_function) 15146 15147 :param callback function: The callback function 15148 for asynchronous request. (optional) 15149 :param str account_id: The external account number (int) or account ID Guid. (required) 15150 :param str template_id: The ID of the template being accessed. (required) 15151 :param str workflow_step_id: (required) 15152 :param WorkflowStep workflow_step: 15153 :return: WorkflowStep 15154 If the method is called asynchronously, 15155 returns the request thread. 15156 """ 15157 kwargs['_return_http_data_only'] = True 15158 if kwargs.get('callback'): 15159 return self.update_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 15160 else: 15161 (data) = self.update_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 15162 return data 15163 15164 def update_template_workflow_step_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 15165 """ 15166 Updates the template workflow step definition for an envelope. 15167 This method makes a synchronous HTTP request by default. To make an 15168 asynchronous HTTP request, please define a `callback` function 15169 to be invoked when receiving the response. 15170 >>> def callback_function(response): 15171 >>> pprint(response) 15172 >>> 15173 >>> thread = api.update_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 15174 15175 :param callback function: The callback function 15176 for asynchronous request. (optional) 15177 :param str account_id: The external account number (int) or account ID Guid. (required) 15178 :param str template_id: The ID of the template being accessed. (required) 15179 :param str workflow_step_id: (required) 15180 :param WorkflowStep workflow_step: 15181 :return: WorkflowStep 15182 If the method is called asynchronously, 15183 returns the request thread. 15184 """ 15185 15186 all_params = ['account_id', 'template_id', 'workflow_step_id', 'workflow_step'] 15187 all_params.append('callback') 15188 all_params.append('_return_http_data_only') 15189 all_params.append('_preload_content') 15190 all_params.append('_request_timeout') 15191 15192 params = locals() 15193 for key, val in iteritems(params['kwargs']): 15194 if key not in all_params: 15195 raise TypeError( 15196 "Got an unexpected keyword argument '%s'" 15197 " to method update_template_workflow_step_definition" % key 15198 ) 15199 params[key] = val 15200 del params['kwargs'] 15201 # verify the required parameter 'account_id' is set 15202 if ('account_id' not in params) or (params['account_id'] is None): 15203 raise ValueError("Missing the required parameter `account_id` when calling `update_template_workflow_step_definition`") 15204 # verify the required parameter 'template_id' is set 15205 if ('template_id' not in params) or (params['template_id'] is None): 15206 raise ValueError("Missing the required parameter `template_id` when calling `update_template_workflow_step_definition`") 15207 # verify the required parameter 'workflow_step_id' is set 15208 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 15209 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_template_workflow_step_definition`") 15210 15211 15212 collection_formats = {} 15213 15214 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 15215 path_params = {} 15216 if 'account_id' in params: 15217 path_params['accountId'] = params['account_id'] 15218 if 'template_id' in params: 15219 path_params['templateId'] = params['template_id'] 15220 if 'workflow_step_id' in params: 15221 path_params['workflowStepId'] = params['workflow_step_id'] 15222 15223 query_params = {} 15224 15225 header_params = {} 15226 15227 form_params = [] 15228 local_var_files = {} 15229 15230 body_params = None 15231 if 'workflow_step' in params: 15232 body_params = params['workflow_step'] 15233 # HTTP header `Accept` 15234 header_params['Accept'] = self.api_client.\ 15235 select_header_accept(['application/json']) 15236 15237 # Authentication setting 15238 auth_settings = [] 15239 15240 return self.api_client.call_api(resource_path, 'PUT', 15241 path_params, 15242 query_params, 15243 header_params, 15244 body=body_params, 15245 post_params=form_params, 15246 files=local_var_files, 15247 response_type='WorkflowStep', 15248 auth_settings=auth_settings, 15249 callback=params.get('callback'), 15250 _return_http_data_only=params.get('_return_http_data_only'), 15251 _preload_content=params.get('_preload_content', True), 15252 _request_timeout=params.get('_request_timeout'), 15253 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 :param str locale: Locale setting for the response, e.g., 'en-US'. 9924 :return: EnvelopeAuditEventResponse 9925 If the method is called asynchronously, 9926 returns the request thread. 9927 """ 9928 kwargs['_return_http_data_only'] = True 9929 if kwargs.get('callback'): 9930 return self.list_audit_events_with_http_info(account_id, envelope_id, **kwargs) 9931 else: 9932 (data) = self.list_audit_events_with_http_info(account_id, envelope_id, **kwargs) 9933 return data 9934 9935 def list_audit_events_with_http_info(self, account_id, envelope_id, **kwargs): 9936 """ 9937 Gets the envelope audit events for an envelope. 9938 Gets the envelope audit events for the specified envelope. 9939 This method makes a synchronous HTTP request by default. To make an 9940 asynchronous HTTP request, please define a `callback` function 9941 to be invoked when receiving the response. 9942 >>> def callback_function(response): 9943 >>> pprint(response) 9944 >>> 9945 >>> thread = api.list_audit_events_with_http_info(account_id, envelope_id, callback=callback_function) 9946 9947 :param callback function: The callback function 9948 for asynchronous request. (optional) 9949 :param str account_id: The external account number (int) or account ID Guid. (required) 9950 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9951 :param str locale: Locale setting for the response, e.g., 'en-US'. 9952 :return: EnvelopeAuditEventResponse 9953 If the method is called asynchronously, 9954 returns the request thread. 9955 """ 9956 9957 all_params = ['account_id', 'envelope_id', 'locale'] 9958 all_params.append('callback') 9959 all_params.append('_return_http_data_only') 9960 all_params.append('_preload_content') 9961 all_params.append('_request_timeout') 9962 9963 params = locals() 9964 for key, val in iteritems(params['kwargs']): 9965 if key not in all_params: 9966 raise TypeError( 9967 "Got an unexpected keyword argument '%s'" 9968 " to method list_audit_events" % key 9969 ) 9970 params[key] = val 9971 del params['kwargs'] 9972 # verify the required parameter 'account_id' is set 9973 if ('account_id' not in params) or (params['account_id'] is None): 9974 raise ValueError("Missing the required parameter `account_id` when calling `list_audit_events`") 9975 # verify the required parameter 'envelope_id' is set 9976 if ('envelope_id' not in params) or (params['envelope_id'] is None): 9977 raise ValueError("Missing the required parameter `envelope_id` when calling `list_audit_events`") 9978 9979 9980 collection_formats = {} 9981 9982 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/audit_events'.replace('{format}', 'json') 9983 path_params = {} 9984 if 'account_id' in params: 9985 path_params['accountId'] = params['account_id'] 9986 if 'envelope_id' in params: 9987 path_params['envelopeId'] = params['envelope_id'] 9988 9989 query_params = {} 9990 if 'locale' in params: 9991 query_params['locale'] = params['locale'] 9992 9993 header_params = {} 9994 9995 form_params = [] 9996 local_var_files = {} 9997 9998 body_params = None 9999 # HTTP header `Accept` 10000 header_params['Accept'] = self.api_client.\ 10001 select_header_accept(['application/json']) 10002 10003 # Authentication setting 10004 auth_settings = [] 10005 10006 return self.api_client.call_api(resource_path, 'GET', 10007 path_params, 10008 query_params, 10009 header_params, 10010 body=body_params, 10011 post_params=form_params, 10012 files=local_var_files, 10013 response_type='EnvelopeAuditEventResponse', 10014 auth_settings=auth_settings, 10015 callback=params.get('callback'), 10016 _return_http_data_only=params.get('_return_http_data_only'), 10017 _preload_content=params.get('_preload_content', True), 10018 _request_timeout=params.get('_request_timeout'), 10019 collection_formats=collection_formats) 10020 10021 def list_custom_fields(self, account_id, envelope_id, **kwargs): 10022 """ 10023 Gets the custom field information for the specified envelope. 10024 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. 10025 This method makes a synchronous HTTP request by default. To make an 10026 asynchronous HTTP request, please define a `callback` function 10027 to be invoked when receiving the response. 10028 >>> def callback_function(response): 10029 >>> pprint(response) 10030 >>> 10031 >>> thread = api.list_custom_fields(account_id, envelope_id, callback=callback_function) 10032 10033 :param callback function: The callback function 10034 for asynchronous request. (optional) 10035 :param str account_id: The external account number (int) or account ID Guid. (required) 10036 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10037 :return: CustomFieldsEnvelope 10038 If the method is called asynchronously, 10039 returns the request thread. 10040 """ 10041 kwargs['_return_http_data_only'] = True 10042 if kwargs.get('callback'): 10043 return self.list_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 10044 else: 10045 (data) = self.list_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 10046 return data 10047 10048 def list_custom_fields_with_http_info(self, account_id, envelope_id, **kwargs): 10049 """ 10050 Gets the custom field information for the specified envelope. 10051 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. 10052 This method makes a synchronous HTTP request by default. To make an 10053 asynchronous HTTP request, please define a `callback` function 10054 to be invoked when receiving the response. 10055 >>> def callback_function(response): 10056 >>> pprint(response) 10057 >>> 10058 >>> thread = api.list_custom_fields_with_http_info(account_id, envelope_id, callback=callback_function) 10059 10060 :param callback function: The callback function 10061 for asynchronous request. (optional) 10062 :param str account_id: The external account number (int) or account ID Guid. (required) 10063 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10064 :return: CustomFieldsEnvelope 10065 If the method is called asynchronously, 10066 returns the request thread. 10067 """ 10068 10069 all_params = ['account_id', 'envelope_id'] 10070 all_params.append('callback') 10071 all_params.append('_return_http_data_only') 10072 all_params.append('_preload_content') 10073 all_params.append('_request_timeout') 10074 10075 params = locals() 10076 for key, val in iteritems(params['kwargs']): 10077 if key not in all_params: 10078 raise TypeError( 10079 "Got an unexpected keyword argument '%s'" 10080 " to method list_custom_fields" % key 10081 ) 10082 params[key] = val 10083 del params['kwargs'] 10084 # verify the required parameter 'account_id' is set 10085 if ('account_id' not in params) or (params['account_id'] is None): 10086 raise ValueError("Missing the required parameter `account_id` when calling `list_custom_fields`") 10087 # verify the required parameter 'envelope_id' is set 10088 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10089 raise ValueError("Missing the required parameter `envelope_id` when calling `list_custom_fields`") 10090 10091 10092 collection_formats = {} 10093 10094 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/custom_fields'.replace('{format}', 'json') 10095 path_params = {} 10096 if 'account_id' in params: 10097 path_params['accountId'] = params['account_id'] 10098 if 'envelope_id' in params: 10099 path_params['envelopeId'] = params['envelope_id'] 10100 10101 query_params = {} 10102 10103 header_params = {} 10104 10105 form_params = [] 10106 local_var_files = {} 10107 10108 body_params = None 10109 # HTTP header `Accept` 10110 header_params['Accept'] = self.api_client.\ 10111 select_header_accept(['application/json']) 10112 10113 # Authentication setting 10114 auth_settings = [] 10115 10116 return self.api_client.call_api(resource_path, 'GET', 10117 path_params, 10118 query_params, 10119 header_params, 10120 body=body_params, 10121 post_params=form_params, 10122 files=local_var_files, 10123 response_type='CustomFieldsEnvelope', 10124 auth_settings=auth_settings, 10125 callback=params.get('callback'), 10126 _return_http_data_only=params.get('_return_http_data_only'), 10127 _preload_content=params.get('_preload_content', True), 10128 _request_timeout=params.get('_request_timeout'), 10129 collection_formats=collection_formats) 10130 10131 def list_document_fields(self, account_id, document_id, envelope_id, **kwargs): 10132 """ 10133 Gets the custom document fields from an existing envelope document. 10134 Retrieves the custom document field information from an existing envelope document. 10135 This method makes a synchronous HTTP request by default. To make an 10136 asynchronous HTTP request, please define a `callback` function 10137 to be invoked when receiving the response. 10138 >>> def callback_function(response): 10139 >>> pprint(response) 10140 >>> 10141 >>> thread = api.list_document_fields(account_id, document_id, envelope_id, callback=callback_function) 10142 10143 :param callback function: The callback function 10144 for asynchronous request. (optional) 10145 :param str account_id: The external account number (int) or account ID Guid. (required) 10146 :param str document_id: The ID of the document being accessed. (required) 10147 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10148 :return: DocumentFieldsInformation 10149 If the method is called asynchronously, 10150 returns the request thread. 10151 """ 10152 kwargs['_return_http_data_only'] = True 10153 if kwargs.get('callback'): 10154 return self.list_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 10155 else: 10156 (data) = self.list_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 10157 return data 10158 10159 def list_document_fields_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 10160 """ 10161 Gets the custom document fields from an existing envelope document. 10162 Retrieves the custom document field information from an existing envelope document. 10163 This method makes a synchronous HTTP request by default. To make an 10164 asynchronous HTTP request, please define a `callback` function 10165 to be invoked when receiving the response. 10166 >>> def callback_function(response): 10167 >>> pprint(response) 10168 >>> 10169 >>> thread = api.list_document_fields_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 10170 10171 :param callback function: The callback function 10172 for asynchronous request. (optional) 10173 :param str account_id: The external account number (int) or account ID Guid. (required) 10174 :param str document_id: The ID of the document being accessed. (required) 10175 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10176 :return: DocumentFieldsInformation 10177 If the method is called asynchronously, 10178 returns the request thread. 10179 """ 10180 10181 all_params = ['account_id', 'document_id', 'envelope_id'] 10182 all_params.append('callback') 10183 all_params.append('_return_http_data_only') 10184 all_params.append('_preload_content') 10185 all_params.append('_request_timeout') 10186 10187 params = locals() 10188 for key, val in iteritems(params['kwargs']): 10189 if key not in all_params: 10190 raise TypeError( 10191 "Got an unexpected keyword argument '%s'" 10192 " to method list_document_fields" % key 10193 ) 10194 params[key] = val 10195 del params['kwargs'] 10196 # verify the required parameter 'account_id' is set 10197 if ('account_id' not in params) or (params['account_id'] is None): 10198 raise ValueError("Missing the required parameter `account_id` when calling `list_document_fields`") 10199 # verify the required parameter 'document_id' is set 10200 if ('document_id' not in params) or (params['document_id'] is None): 10201 raise ValueError("Missing the required parameter `document_id` when calling `list_document_fields`") 10202 # verify the required parameter 'envelope_id' is set 10203 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10204 raise ValueError("Missing the required parameter `envelope_id` when calling `list_document_fields`") 10205 10206 10207 collection_formats = {} 10208 10209 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/fields'.replace('{format}', 'json') 10210 path_params = {} 10211 if 'account_id' in params: 10212 path_params['accountId'] = params['account_id'] 10213 if 'document_id' in params: 10214 path_params['documentId'] = params['document_id'] 10215 if 'envelope_id' in params: 10216 path_params['envelopeId'] = params['envelope_id'] 10217 10218 query_params = {} 10219 10220 header_params = {} 10221 10222 form_params = [] 10223 local_var_files = {} 10224 10225 body_params = None 10226 # HTTP header `Accept` 10227 header_params['Accept'] = self.api_client.\ 10228 select_header_accept(['application/json']) 10229 10230 # Authentication setting 10231 auth_settings = [] 10232 10233 return self.api_client.call_api(resource_path, 'GET', 10234 path_params, 10235 query_params, 10236 header_params, 10237 body=body_params, 10238 post_params=form_params, 10239 files=local_var_files, 10240 response_type='DocumentFieldsInformation', 10241 auth_settings=auth_settings, 10242 callback=params.get('callback'), 10243 _return_http_data_only=params.get('_return_http_data_only'), 10244 _preload_content=params.get('_preload_content', True), 10245 _request_timeout=params.get('_request_timeout'), 10246 collection_formats=collection_formats) 10247 10248 def list_documents(self, account_id, envelope_id, **kwargs): 10249 """ 10250 Gets a list of envelope documents. 10251 Retrieves a list of documents associated with the specified envelope. 10252 This method makes a synchronous HTTP request by default. To make an 10253 asynchronous HTTP request, please define a `callback` function 10254 to be invoked when receiving the response. 10255 >>> def callback_function(response): 10256 >>> pprint(response) 10257 >>> 10258 >>> thread = api.list_documents(account_id, envelope_id, callback=callback_function) 10259 10260 :param callback function: The callback function 10261 for asynchronous request. (optional) 10262 :param str account_id: The external account number (int) or account ID Guid. (required) 10263 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10264 :param str documents_by_userid: 10265 :param str include_agreement_type: 10266 :param str include_docgen_formfields: 10267 :param str include_document_size: 10268 :param str include_metadata: 10269 :param str include_tabs: 10270 :param str recipient_id: 10271 :param str shared_user_id: 10272 :return: EnvelopeDocumentsResult 10273 If the method is called asynchronously, 10274 returns the request thread. 10275 """ 10276 kwargs['_return_http_data_only'] = True 10277 if kwargs.get('callback'): 10278 return self.list_documents_with_http_info(account_id, envelope_id, **kwargs) 10279 else: 10280 (data) = self.list_documents_with_http_info(account_id, envelope_id, **kwargs) 10281 return data 10282 10283 def list_documents_with_http_info(self, account_id, envelope_id, **kwargs): 10284 """ 10285 Gets a list of envelope documents. 10286 Retrieves a list of documents associated with the specified envelope. 10287 This method makes a synchronous HTTP request by default. To make an 10288 asynchronous HTTP request, please define a `callback` function 10289 to be invoked when receiving the response. 10290 >>> def callback_function(response): 10291 >>> pprint(response) 10292 >>> 10293 >>> thread = api.list_documents_with_http_info(account_id, envelope_id, callback=callback_function) 10294 10295 :param callback function: The callback function 10296 for asynchronous request. (optional) 10297 :param str account_id: The external account number (int) or account ID Guid. (required) 10298 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10299 :param str documents_by_userid: 10300 :param str include_agreement_type: 10301 :param str include_docgen_formfields: 10302 :param str include_document_size: 10303 :param str include_metadata: 10304 :param str include_tabs: 10305 :param str recipient_id: 10306 :param str shared_user_id: 10307 :return: EnvelopeDocumentsResult 10308 If the method is called asynchronously, 10309 returns the request thread. 10310 """ 10311 10312 all_params = ['account_id', 'envelope_id', 'documents_by_userid', 'include_agreement_type', 'include_docgen_formfields', 'include_document_size', 'include_metadata', 'include_tabs', 'recipient_id', 'shared_user_id'] 10313 all_params.append('callback') 10314 all_params.append('_return_http_data_only') 10315 all_params.append('_preload_content') 10316 all_params.append('_request_timeout') 10317 10318 params = locals() 10319 for key, val in iteritems(params['kwargs']): 10320 if key not in all_params: 10321 raise TypeError( 10322 "Got an unexpected keyword argument '%s'" 10323 " to method list_documents" % key 10324 ) 10325 params[key] = val 10326 del params['kwargs'] 10327 # verify the required parameter 'account_id' is set 10328 if ('account_id' not in params) or (params['account_id'] is None): 10329 raise ValueError("Missing the required parameter `account_id` when calling `list_documents`") 10330 # verify the required parameter 'envelope_id' is set 10331 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10332 raise ValueError("Missing the required parameter `envelope_id` when calling `list_documents`") 10333 10334 10335 collection_formats = {} 10336 10337 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents'.replace('{format}', 'json') 10338 path_params = {} 10339 if 'account_id' in params: 10340 path_params['accountId'] = params['account_id'] 10341 if 'envelope_id' in params: 10342 path_params['envelopeId'] = params['envelope_id'] 10343 10344 query_params = {} 10345 if 'documents_by_userid' in params: 10346 query_params['documents_by_userid'] = params['documents_by_userid'] 10347 if 'include_agreement_type' in params: 10348 query_params['include_agreement_type'] = params['include_agreement_type'] 10349 if 'include_docgen_formfields' in params: 10350 query_params['include_docgen_formfields'] = params['include_docgen_formfields'] 10351 if 'include_document_size' in params: 10352 query_params['include_document_size'] = params['include_document_size'] 10353 if 'include_metadata' in params: 10354 query_params['include_metadata'] = params['include_metadata'] 10355 if 'include_tabs' in params: 10356 query_params['include_tabs'] = params['include_tabs'] 10357 if 'recipient_id' in params: 10358 query_params['recipient_id'] = params['recipient_id'] 10359 if 'shared_user_id' in params: 10360 query_params['shared_user_id'] = params['shared_user_id'] 10361 10362 header_params = {} 10363 10364 form_params = [] 10365 local_var_files = {} 10366 10367 body_params = None 10368 # HTTP header `Accept` 10369 header_params['Accept'] = self.api_client.\ 10370 select_header_accept(['application/json']) 10371 10372 # Authentication setting 10373 auth_settings = [] 10374 10375 return self.api_client.call_api(resource_path, 'GET', 10376 path_params, 10377 query_params, 10378 header_params, 10379 body=body_params, 10380 post_params=form_params, 10381 files=local_var_files, 10382 response_type='EnvelopeDocumentsResult', 10383 auth_settings=auth_settings, 10384 callback=params.get('callback'), 10385 _return_http_data_only=params.get('_return_http_data_only'), 10386 _preload_content=params.get('_preload_content', True), 10387 _request_timeout=params.get('_request_timeout'), 10388 collection_formats=collection_formats) 10389 10390 def list_recipients(self, account_id, envelope_id, **kwargs): 10391 """ 10392 Gets the status of recipients for an envelope. 10393 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. 10394 This method makes a synchronous HTTP request by default. To make an 10395 asynchronous HTTP request, please define a `callback` function 10396 to be invoked when receiving the response. 10397 >>> def callback_function(response): 10398 >>> pprint(response) 10399 >>> 10400 >>> thread = api.list_recipients(account_id, envelope_id, callback=callback_function) 10401 10402 :param callback function: The callback function 10403 for asynchronous request. (optional) 10404 :param str account_id: The external account number (int) or account ID Guid. (required) 10405 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10406 :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. 10407 :param str include_extended: When set to **true**, the extended properties are included in the response. 10408 :param str include_metadata: 10409 :param str include_tabs: When set to **true**, the tab information associated with the recipient is included in the response. 10410 :return: Recipients 10411 If the method is called asynchronously, 10412 returns the request thread. 10413 """ 10414 kwargs['_return_http_data_only'] = True 10415 if kwargs.get('callback'): 10416 return self.list_recipients_with_http_info(account_id, envelope_id, **kwargs) 10417 else: 10418 (data) = self.list_recipients_with_http_info(account_id, envelope_id, **kwargs) 10419 return data 10420 10421 def list_recipients_with_http_info(self, account_id, envelope_id, **kwargs): 10422 """ 10423 Gets the status of recipients for an envelope. 10424 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. 10425 This method makes a synchronous HTTP request by default. To make an 10426 asynchronous HTTP request, please define a `callback` function 10427 to be invoked when receiving the response. 10428 >>> def callback_function(response): 10429 >>> pprint(response) 10430 >>> 10431 >>> thread = api.list_recipients_with_http_info(account_id, envelope_id, callback=callback_function) 10432 10433 :param callback function: The callback function 10434 for asynchronous request. (optional) 10435 :param str account_id: The external account number (int) or account ID Guid. (required) 10436 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10437 :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. 10438 :param str include_extended: When set to **true**, the extended properties are included in the response. 10439 :param str include_metadata: 10440 :param str include_tabs: When set to **true**, the tab information associated with the recipient is included in the response. 10441 :return: Recipients 10442 If the method is called asynchronously, 10443 returns the request thread. 10444 """ 10445 10446 all_params = ['account_id', 'envelope_id', 'include_anchor_tab_locations', 'include_extended', 'include_metadata', 'include_tabs'] 10447 all_params.append('callback') 10448 all_params.append('_return_http_data_only') 10449 all_params.append('_preload_content') 10450 all_params.append('_request_timeout') 10451 10452 params = locals() 10453 for key, val in iteritems(params['kwargs']): 10454 if key not in all_params: 10455 raise TypeError( 10456 "Got an unexpected keyword argument '%s'" 10457 " to method list_recipients" % key 10458 ) 10459 params[key] = val 10460 del params['kwargs'] 10461 # verify the required parameter 'account_id' is set 10462 if ('account_id' not in params) or (params['account_id'] is None): 10463 raise ValueError("Missing the required parameter `account_id` when calling `list_recipients`") 10464 # verify the required parameter 'envelope_id' is set 10465 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10466 raise ValueError("Missing the required parameter `envelope_id` when calling `list_recipients`") 10467 10468 10469 collection_formats = {} 10470 10471 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients'.replace('{format}', 'json') 10472 path_params = {} 10473 if 'account_id' in params: 10474 path_params['accountId'] = params['account_id'] 10475 if 'envelope_id' in params: 10476 path_params['envelopeId'] = params['envelope_id'] 10477 10478 query_params = {} 10479 if 'include_anchor_tab_locations' in params: 10480 query_params['include_anchor_tab_locations'] = params['include_anchor_tab_locations'] 10481 if 'include_extended' in params: 10482 query_params['include_extended'] = params['include_extended'] 10483 if 'include_metadata' in params: 10484 query_params['include_metadata'] = params['include_metadata'] 10485 if 'include_tabs' in params: 10486 query_params['include_tabs'] = params['include_tabs'] 10487 10488 header_params = {} 10489 10490 form_params = [] 10491 local_var_files = {} 10492 10493 body_params = None 10494 # HTTP header `Accept` 10495 header_params['Accept'] = self.api_client.\ 10496 select_header_accept(['application/json']) 10497 10498 # Authentication setting 10499 auth_settings = [] 10500 10501 return self.api_client.call_api(resource_path, 'GET', 10502 path_params, 10503 query_params, 10504 header_params, 10505 body=body_params, 10506 post_params=form_params, 10507 files=local_var_files, 10508 response_type='Recipients', 10509 auth_settings=auth_settings, 10510 callback=params.get('callback'), 10511 _return_http_data_only=params.get('_return_http_data_only'), 10512 _preload_content=params.get('_preload_content', True), 10513 _request_timeout=params.get('_request_timeout'), 10514 collection_formats=collection_formats) 10515 10516 def list_status(self, account_id, **kwargs): 10517 """ 10518 Gets the envelope status for the specified envelopes. 10519 Retrieves the envelope status for the specified envelopes. 10520 This method makes a synchronous HTTP request by default. To make an 10521 asynchronous HTTP request, please define a `callback` function 10522 to be invoked when receiving the response. 10523 >>> def callback_function(response): 10524 >>> pprint(response) 10525 >>> 10526 >>> thread = api.list_status(account_id, callback=callback_function) 10527 10528 :param callback function: The callback function 10529 for asynchronous request. (optional) 10530 :param str account_id: The external account number (int) or account ID Guid. (required) 10531 :param str ac_status: 10532 :param str block: 10533 :param str count: 10534 :param str email: 10535 :param str envelope_ids: 10536 :param str from_date: 10537 :param str from_to_status: 10538 :param str start_position: 10539 :param str status: 10540 :param str to_date: 10541 :param str transaction_ids: 10542 :param str user_name: 10543 :param EnvelopeIdsRequest envelope_ids_request: 10544 :return: EnvelopesInformation 10545 If the method is called asynchronously, 10546 returns the request thread. 10547 """ 10548 kwargs['_return_http_data_only'] = True 10549 if kwargs.get('callback'): 10550 return self.list_status_with_http_info(account_id, **kwargs) 10551 else: 10552 (data) = self.list_status_with_http_info(account_id, **kwargs) 10553 return data 10554 10555 def list_status_with_http_info(self, account_id, **kwargs): 10556 """ 10557 Gets the envelope status for the specified envelopes. 10558 Retrieves the envelope status for the specified envelopes. 10559 This method makes a synchronous HTTP request by default. To make an 10560 asynchronous HTTP request, please define a `callback` function 10561 to be invoked when receiving the response. 10562 >>> def callback_function(response): 10563 >>> pprint(response) 10564 >>> 10565 >>> thread = api.list_status_with_http_info(account_id, callback=callback_function) 10566 10567 :param callback function: The callback function 10568 for asynchronous request. (optional) 10569 :param str account_id: The external account number (int) or account ID Guid. (required) 10570 :param str ac_status: 10571 :param str block: 10572 :param str count: 10573 :param str email: 10574 :param str envelope_ids: 10575 :param str from_date: 10576 :param str from_to_status: 10577 :param str start_position: 10578 :param str status: 10579 :param str to_date: 10580 :param str transaction_ids: 10581 :param str user_name: 10582 :param EnvelopeIdsRequest envelope_ids_request: 10583 :return: EnvelopesInformation 10584 If the method is called asynchronously, 10585 returns the request thread. 10586 """ 10587 10588 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'] 10589 all_params.append('callback') 10590 all_params.append('_return_http_data_only') 10591 all_params.append('_preload_content') 10592 all_params.append('_request_timeout') 10593 10594 params = locals() 10595 for key, val in iteritems(params['kwargs']): 10596 if key not in all_params: 10597 raise TypeError( 10598 "Got an unexpected keyword argument '%s'" 10599 " to method list_status" % key 10600 ) 10601 params[key] = val 10602 del params['kwargs'] 10603 # verify the required parameter 'account_id' is set 10604 if ('account_id' not in params) or (params['account_id'] is None): 10605 raise ValueError("Missing the required parameter `account_id` when calling `list_status`") 10606 10607 10608 collection_formats = {} 10609 10610 resource_path = '/v2.1/accounts/{accountId}/envelopes/status'.replace('{format}', 'json') 10611 path_params = {} 10612 if 'account_id' in params: 10613 path_params['accountId'] = params['account_id'] 10614 10615 query_params = {} 10616 if 'ac_status' in params: 10617 query_params['ac_status'] = params['ac_status'] 10618 if 'block' in params: 10619 query_params['block'] = params['block'] 10620 if 'count' in params: 10621 query_params['count'] = params['count'] 10622 if 'email' in params: 10623 query_params['email'] = params['email'] 10624 if 'envelope_ids' in params: 10625 query_params['envelope_ids'] = params['envelope_ids'] 10626 if 'from_date' in params: 10627 query_params['from_date'] = params['from_date'] 10628 if 'from_to_status' in params: 10629 query_params['from_to_status'] = params['from_to_status'] 10630 if 'start_position' in params: 10631 query_params['start_position'] = params['start_position'] 10632 if 'status' in params: 10633 query_params['status'] = params['status'] 10634 if 'to_date' in params: 10635 query_params['to_date'] = params['to_date'] 10636 if 'transaction_ids' in params: 10637 query_params['transaction_ids'] = params['transaction_ids'] 10638 if 'user_name' in params: 10639 query_params['user_name'] = params['user_name'] 10640 10641 header_params = {} 10642 10643 form_params = [] 10644 local_var_files = {} 10645 10646 body_params = None 10647 if 'envelope_ids_request' in params: 10648 body_params = params['envelope_ids_request'] 10649 # HTTP header `Accept` 10650 header_params['Accept'] = self.api_client.\ 10651 select_header_accept(['application/json']) 10652 10653 # Authentication setting 10654 auth_settings = [] 10655 10656 return self.api_client.call_api(resource_path, 'PUT', 10657 path_params, 10658 query_params, 10659 header_params, 10660 body=body_params, 10661 post_params=form_params, 10662 files=local_var_files, 10663 response_type='EnvelopesInformation', 10664 auth_settings=auth_settings, 10665 callback=params.get('callback'), 10666 _return_http_data_only=params.get('_return_http_data_only'), 10667 _preload_content=params.get('_preload_content', True), 10668 _request_timeout=params.get('_request_timeout'), 10669 collection_formats=collection_formats) 10670 10671 def list_status_changes(self, account_id, **kwargs): 10672 """ 10673 Gets status changes for one or more envelopes. 10674 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. 10675 This method makes a synchronous HTTP request by default. To make an 10676 asynchronous HTTP request, please define a `callback` function 10677 to be invoked when receiving the response. 10678 >>> def callback_function(response): 10679 >>> pprint(response) 10680 >>> 10681 >>> thread = api.list_status_changes(account_id, callback=callback_function) 10682 10683 :param callback function: The callback function 10684 for asynchronous request. (optional) 10685 :param str account_id: The external account number (int) or account ID Guid. (required) 10686 :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. 10687 :param str block: 10688 :param str cdse_mode: 10689 :param str continuation_token: 10690 :param str count: 10691 :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.\" 10692 :param str email: 10693 :param str envelope_ids: 10694 :param str exclude: 10695 :param str folder_ids: 10696 :param str folder_types: 10697 :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. 10698 :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. 10699 :param str include: 10700 :param str include_purge_information: 10701 :param str intersecting_folder_ids: 10702 :param str last_queried_date: 10703 :param str order: 10704 :param str order_by: 10705 :param str powerformids: 10706 :param str query_budget: 10707 :param str requester_date_format: 10708 :param str search_mode: 10709 :param str search_text: 10710 :param str start_position: 10711 :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. 10712 :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`. 10713 :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. 10714 :param str user_filter: 10715 :param str user_id: 10716 :param str user_name: 10717 :return: EnvelopesInformation 10718 If the method is called asynchronously, 10719 returns the request thread. 10720 """ 10721 kwargs['_return_http_data_only'] = True 10722 if kwargs.get('callback'): 10723 return self.list_status_changes_with_http_info(account_id, **kwargs) 10724 else: 10725 (data) = self.list_status_changes_with_http_info(account_id, **kwargs) 10726 return data 10727 10728 def list_status_changes_with_http_info(self, account_id, **kwargs): 10729 """ 10730 Gets status changes for one or more envelopes. 10731 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. 10732 This method makes a synchronous HTTP request by default. To make an 10733 asynchronous HTTP request, please define a `callback` function 10734 to be invoked when receiving the response. 10735 >>> def callback_function(response): 10736 >>> pprint(response) 10737 >>> 10738 >>> thread = api.list_status_changes_with_http_info(account_id, callback=callback_function) 10739 10740 :param callback function: The callback function 10741 for asynchronous request. (optional) 10742 :param str account_id: The external account number (int) or account ID Guid. (required) 10743 :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. 10744 :param str block: 10745 :param str cdse_mode: 10746 :param str continuation_token: 10747 :param str count: 10748 :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.\" 10749 :param str email: 10750 :param str envelope_ids: 10751 :param str exclude: 10752 :param str folder_ids: 10753 :param str folder_types: 10754 :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. 10755 :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. 10756 :param str include: 10757 :param str include_purge_information: 10758 :param str intersecting_folder_ids: 10759 :param str last_queried_date: 10760 :param str order: 10761 :param str order_by: 10762 :param str powerformids: 10763 :param str query_budget: 10764 :param str requester_date_format: 10765 :param str search_mode: 10766 :param str search_text: 10767 :param str start_position: 10768 :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. 10769 :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`. 10770 :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. 10771 :param str user_filter: 10772 :param str user_id: 10773 :param str user_name: 10774 :return: EnvelopesInformation 10775 If the method is called asynchronously, 10776 returns the request thread. 10777 """ 10778 10779 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'] 10780 all_params.append('callback') 10781 all_params.append('_return_http_data_only') 10782 all_params.append('_preload_content') 10783 all_params.append('_request_timeout') 10784 10785 params = locals() 10786 for key, val in iteritems(params['kwargs']): 10787 if key not in all_params: 10788 raise TypeError( 10789 "Got an unexpected keyword argument '%s'" 10790 " to method list_status_changes" % key 10791 ) 10792 params[key] = val 10793 del params['kwargs'] 10794 # verify the required parameter 'account_id' is set 10795 if ('account_id' not in params) or (params['account_id'] is None): 10796 raise ValueError("Missing the required parameter `account_id` when calling `list_status_changes`") 10797 10798 10799 collection_formats = {} 10800 10801 resource_path = '/v2.1/accounts/{accountId}/envelopes'.replace('{format}', 'json') 10802 path_params = {} 10803 if 'account_id' in params: 10804 path_params['accountId'] = params['account_id'] 10805 10806 query_params = {} 10807 if 'ac_status' in params: 10808 query_params['ac_status'] = params['ac_status'] 10809 if 'block' in params: 10810 query_params['block'] = params['block'] 10811 if 'cdse_mode' in params: 10812 query_params['cdse_mode'] = params['cdse_mode'] 10813 if 'continuation_token' in params: 10814 query_params['continuation_token'] = params['continuation_token'] 10815 if 'count' in params: 10816 query_params['count'] = params['count'] 10817 if 'custom_field' in params: 10818 query_params['custom_field'] = params['custom_field'] 10819 if 'email' in params: 10820 query_params['email'] = params['email'] 10821 if 'envelope_ids' in params: 10822 query_params['envelope_ids'] = params['envelope_ids'] 10823 if 'exclude' in params: 10824 query_params['exclude'] = params['exclude'] 10825 if 'folder_ids' in params: 10826 query_params['folder_ids'] = params['folder_ids'] 10827 if 'folder_types' in params: 10828 query_params['folder_types'] = params['folder_types'] 10829 if 'from_date' in params: 10830 query_params['from_date'] = params['from_date'] 10831 if 'from_to_status' in params: 10832 query_params['from_to_status'] = params['from_to_status'] 10833 if 'include' in params: 10834 query_params['include'] = params['include'] 10835 if 'include_purge_information' in params: 10836 query_params['include_purge_information'] = params['include_purge_information'] 10837 if 'intersecting_folder_ids' in params: 10838 query_params['intersecting_folder_ids'] = params['intersecting_folder_ids'] 10839 if 'last_queried_date' in params: 10840 query_params['last_queried_date'] = params['last_queried_date'] 10841 if 'order' in params: 10842 query_params['order'] = params['order'] 10843 if 'order_by' in params: 10844 query_params['order_by'] = params['order_by'] 10845 if 'powerformids' in params: 10846 query_params['powerformids'] = params['powerformids'] 10847 if 'query_budget' in params: 10848 query_params['query_budget'] = params['query_budget'] 10849 if 'requester_date_format' in params: 10850 query_params['requester_date_format'] = params['requester_date_format'] 10851 if 'search_mode' in params: 10852 query_params['search_mode'] = params['search_mode'] 10853 if 'search_text' in params: 10854 query_params['search_text'] = params['search_text'] 10855 if 'start_position' in params: 10856 query_params['start_position'] = params['start_position'] 10857 if 'status' in params: 10858 query_params['status'] = params['status'] 10859 if 'to_date' in params: 10860 query_params['to_date'] = params['to_date'] 10861 if 'transaction_ids' in params: 10862 query_params['transaction_ids'] = params['transaction_ids'] 10863 if 'user_filter' in params: 10864 query_params['user_filter'] = params['user_filter'] 10865 if 'user_id' in params: 10866 query_params['user_id'] = params['user_id'] 10867 if 'user_name' in params: 10868 query_params['user_name'] = params['user_name'] 10869 10870 header_params = {} 10871 10872 form_params = [] 10873 local_var_files = {} 10874 10875 body_params = None 10876 # HTTP header `Accept` 10877 header_params['Accept'] = self.api_client.\ 10878 select_header_accept(['application/json']) 10879 10880 # Authentication setting 10881 auth_settings = [] 10882 10883 return self.api_client.call_api(resource_path, 'GET', 10884 path_params, 10885 query_params, 10886 header_params, 10887 body=body_params, 10888 post_params=form_params, 10889 files=local_var_files, 10890 response_type='EnvelopesInformation', 10891 auth_settings=auth_settings, 10892 callback=params.get('callback'), 10893 _return_http_data_only=params.get('_return_http_data_only'), 10894 _preload_content=params.get('_preload_content', True), 10895 _request_timeout=params.get('_request_timeout'), 10896 collection_formats=collection_formats) 10897 10898 def list_tabs(self, account_id, envelope_id, recipient_id, **kwargs): 10899 """ 10900 Gets the tabs information for a signer or sign-in-person recipient in an envelope. 10901 Retrieves information about the tabs associated with a recipient in a draft envelope. 10902 This method makes a synchronous HTTP request by default. To make an 10903 asynchronous HTTP request, please define a `callback` function 10904 to be invoked when receiving the response. 10905 >>> def callback_function(response): 10906 >>> pprint(response) 10907 >>> 10908 >>> thread = api.list_tabs(account_id, envelope_id, recipient_id, callback=callback_function) 10909 10910 :param callback function: The callback function 10911 for asynchronous request. (optional) 10912 :param str account_id: The external account number (int) or account ID Guid. (required) 10913 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10914 :param str recipient_id: The ID of the recipient being accessed. (required) 10915 :param str include_anchor_tab_locations: When set to **true**, all tabs with anchor tab properties are included in the response. 10916 :param str include_metadata: 10917 :return: Tabs 10918 If the method is called asynchronously, 10919 returns the request thread. 10920 """ 10921 kwargs['_return_http_data_only'] = True 10922 if kwargs.get('callback'): 10923 return self.list_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 10924 else: 10925 (data) = self.list_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 10926 return data 10927 10928 def list_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 10929 """ 10930 Gets the tabs information for a signer or sign-in-person recipient in an envelope. 10931 Retrieves information about the tabs associated with a recipient in a draft envelope. 10932 This method makes a synchronous HTTP request by default. To make an 10933 asynchronous HTTP request, please define a `callback` function 10934 to be invoked when receiving the response. 10935 >>> def callback_function(response): 10936 >>> pprint(response) 10937 >>> 10938 >>> thread = api.list_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 10939 10940 :param callback function: The callback function 10941 for asynchronous request. (optional) 10942 :param str account_id: The external account number (int) or account ID Guid. (required) 10943 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10944 :param str recipient_id: The ID of the recipient being accessed. (required) 10945 :param str include_anchor_tab_locations: When set to **true**, all tabs with anchor tab properties are included in the response. 10946 :param str include_metadata: 10947 :return: Tabs 10948 If the method is called asynchronously, 10949 returns the request thread. 10950 """ 10951 10952 all_params = ['account_id', 'envelope_id', 'recipient_id', 'include_anchor_tab_locations', 'include_metadata'] 10953 all_params.append('callback') 10954 all_params.append('_return_http_data_only') 10955 all_params.append('_preload_content') 10956 all_params.append('_request_timeout') 10957 10958 params = locals() 10959 for key, val in iteritems(params['kwargs']): 10960 if key not in all_params: 10961 raise TypeError( 10962 "Got an unexpected keyword argument '%s'" 10963 " to method list_tabs" % key 10964 ) 10965 params[key] = val 10966 del params['kwargs'] 10967 # verify the required parameter 'account_id' is set 10968 if ('account_id' not in params) or (params['account_id'] is None): 10969 raise ValueError("Missing the required parameter `account_id` when calling `list_tabs`") 10970 # verify the required parameter 'envelope_id' is set 10971 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10972 raise ValueError("Missing the required parameter `envelope_id` when calling `list_tabs`") 10973 # verify the required parameter 'recipient_id' is set 10974 if ('recipient_id' not in params) or (params['recipient_id'] is None): 10975 raise ValueError("Missing the required parameter `recipient_id` when calling `list_tabs`") 10976 10977 10978 collection_formats = {} 10979 10980 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/tabs'.replace('{format}', 'json') 10981 path_params = {} 10982 if 'account_id' in params: 10983 path_params['accountId'] = params['account_id'] 10984 if 'envelope_id' in params: 10985 path_params['envelopeId'] = params['envelope_id'] 10986 if 'recipient_id' in params: 10987 path_params['recipientId'] = params['recipient_id'] 10988 10989 query_params = {} 10990 if 'include_anchor_tab_locations' in params: 10991 query_params['include_anchor_tab_locations'] = params['include_anchor_tab_locations'] 10992 if 'include_metadata' in params: 10993 query_params['include_metadata'] = params['include_metadata'] 10994 10995 header_params = {} 10996 10997 form_params = [] 10998 local_var_files = {} 10999 11000 body_params = None 11001 # HTTP header `Accept` 11002 header_params['Accept'] = self.api_client.\ 11003 select_header_accept(['application/json']) 11004 11005 # Authentication setting 11006 auth_settings = [] 11007 11008 return self.api_client.call_api(resource_path, 'GET', 11009 path_params, 11010 query_params, 11011 header_params, 11012 body=body_params, 11013 post_params=form_params, 11014 files=local_var_files, 11015 response_type='Tabs', 11016 auth_settings=auth_settings, 11017 callback=params.get('callback'), 11018 _return_http_data_only=params.get('_return_http_data_only'), 11019 _preload_content=params.get('_preload_content', True), 11020 _request_timeout=params.get('_request_timeout'), 11021 collection_formats=collection_formats) 11022 11023 def list_templates(self, account_id, envelope_id, **kwargs): 11024 """ 11025 Get List of Templates used in an Envelope 11026 This returns a list of the server-side templates, their name and ID, used in an envelope. 11027 This method makes a synchronous HTTP request by default. To make an 11028 asynchronous HTTP request, please define a `callback` function 11029 to be invoked when receiving the response. 11030 >>> def callback_function(response): 11031 >>> pprint(response) 11032 >>> 11033 >>> thread = api.list_templates(account_id, envelope_id, callback=callback_function) 11034 11035 :param callback function: The callback function 11036 for asynchronous request. (optional) 11037 :param str account_id: The external account number (int) or account ID Guid. (required) 11038 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11039 :param str include: The possible values are: matching_applied - This returns template matching information for the template. 11040 :return: TemplateInformation 11041 If the method is called asynchronously, 11042 returns the request thread. 11043 """ 11044 kwargs['_return_http_data_only'] = True 11045 if kwargs.get('callback'): 11046 return self.list_templates_with_http_info(account_id, envelope_id, **kwargs) 11047 else: 11048 (data) = self.list_templates_with_http_info(account_id, envelope_id, **kwargs) 11049 return data 11050 11051 def list_templates_with_http_info(self, account_id, envelope_id, **kwargs): 11052 """ 11053 Get List of Templates used in an Envelope 11054 This returns a list of the server-side templates, their name and ID, used in an envelope. 11055 This method makes a synchronous HTTP request by default. To make an 11056 asynchronous HTTP request, please define a `callback` function 11057 to be invoked when receiving the response. 11058 >>> def callback_function(response): 11059 >>> pprint(response) 11060 >>> 11061 >>> thread = api.list_templates_with_http_info(account_id, envelope_id, callback=callback_function) 11062 11063 :param callback function: The callback function 11064 for asynchronous request. (optional) 11065 :param str account_id: The external account number (int) or account ID Guid. (required) 11066 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11067 :param str include: The possible values are: matching_applied - This returns template matching information for the template. 11068 :return: TemplateInformation 11069 If the method is called asynchronously, 11070 returns the request thread. 11071 """ 11072 11073 all_params = ['account_id', 'envelope_id', 'include'] 11074 all_params.append('callback') 11075 all_params.append('_return_http_data_only') 11076 all_params.append('_preload_content') 11077 all_params.append('_request_timeout') 11078 11079 params = locals() 11080 for key, val in iteritems(params['kwargs']): 11081 if key not in all_params: 11082 raise TypeError( 11083 "Got an unexpected keyword argument '%s'" 11084 " to method list_templates" % key 11085 ) 11086 params[key] = val 11087 del params['kwargs'] 11088 # verify the required parameter 'account_id' is set 11089 if ('account_id' not in params) or (params['account_id'] is None): 11090 raise ValueError("Missing the required parameter `account_id` when calling `list_templates`") 11091 # verify the required parameter 'envelope_id' is set 11092 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11093 raise ValueError("Missing the required parameter `envelope_id` when calling `list_templates`") 11094 11095 11096 collection_formats = {} 11097 11098 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/templates'.replace('{format}', 'json') 11099 path_params = {} 11100 if 'account_id' in params: 11101 path_params['accountId'] = params['account_id'] 11102 if 'envelope_id' in params: 11103 path_params['envelopeId'] = params['envelope_id'] 11104 11105 query_params = {} 11106 if 'include' in params: 11107 query_params['include'] = params['include'] 11108 11109 header_params = {} 11110 11111 form_params = [] 11112 local_var_files = {} 11113 11114 body_params = None 11115 # HTTP header `Accept` 11116 header_params['Accept'] = self.api_client.\ 11117 select_header_accept(['application/json']) 11118 11119 # Authentication setting 11120 auth_settings = [] 11121 11122 return self.api_client.call_api(resource_path, 'GET', 11123 path_params, 11124 query_params, 11125 header_params, 11126 body=body_params, 11127 post_params=form_params, 11128 files=local_var_files, 11129 response_type='TemplateInformation', 11130 auth_settings=auth_settings, 11131 callback=params.get('callback'), 11132 _return_http_data_only=params.get('_return_http_data_only'), 11133 _preload_content=params.get('_preload_content', True), 11134 _request_timeout=params.get('_request_timeout'), 11135 collection_formats=collection_formats) 11136 11137 def list_templates_for_document(self, account_id, document_id, envelope_id, **kwargs): 11138 """ 11139 Gets the templates associated with a document in an existing envelope. 11140 Retrieves the templates associated with a document in the specified envelope. 11141 This method makes a synchronous HTTP request by default. To make an 11142 asynchronous HTTP request, please define a `callback` function 11143 to be invoked when receiving the response. 11144 >>> def callback_function(response): 11145 >>> pprint(response) 11146 >>> 11147 >>> thread = api.list_templates_for_document(account_id, document_id, envelope_id, callback=callback_function) 11148 11149 :param callback function: The callback function 11150 for asynchronous request. (optional) 11151 :param str account_id: The external account number (int) or account ID Guid. (required) 11152 :param str document_id: The ID of the document being accessed. (required) 11153 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11154 :param str include: 11155 :return: TemplateInformation 11156 If the method is called asynchronously, 11157 returns the request thread. 11158 """ 11159 kwargs['_return_http_data_only'] = True 11160 if kwargs.get('callback'): 11161 return self.list_templates_for_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 11162 else: 11163 (data) = self.list_templates_for_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 11164 return data 11165 11166 def list_templates_for_document_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 11167 """ 11168 Gets the templates associated with a document in an existing envelope. 11169 Retrieves the templates associated with a document in the specified envelope. 11170 This method makes a synchronous HTTP request by default. To make an 11171 asynchronous HTTP request, please define a `callback` function 11172 to be invoked when receiving the response. 11173 >>> def callback_function(response): 11174 >>> pprint(response) 11175 >>> 11176 >>> thread = api.list_templates_for_document_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 11177 11178 :param callback function: The callback function 11179 for asynchronous request. (optional) 11180 :param str account_id: The external account number (int) or account ID Guid. (required) 11181 :param str document_id: The ID of the document being accessed. (required) 11182 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11183 :param str include: 11184 :return: TemplateInformation 11185 If the method is called asynchronously, 11186 returns the request thread. 11187 """ 11188 11189 all_params = ['account_id', 'document_id', 'envelope_id', 'include'] 11190 all_params.append('callback') 11191 all_params.append('_return_http_data_only') 11192 all_params.append('_preload_content') 11193 all_params.append('_request_timeout') 11194 11195 params = locals() 11196 for key, val in iteritems(params['kwargs']): 11197 if key not in all_params: 11198 raise TypeError( 11199 "Got an unexpected keyword argument '%s'" 11200 " to method list_templates_for_document" % key 11201 ) 11202 params[key] = val 11203 del params['kwargs'] 11204 # verify the required parameter 'account_id' is set 11205 if ('account_id' not in params) or (params['account_id'] is None): 11206 raise ValueError("Missing the required parameter `account_id` when calling `list_templates_for_document`") 11207 # verify the required parameter 'document_id' is set 11208 if ('document_id' not in params) or (params['document_id'] is None): 11209 raise ValueError("Missing the required parameter `document_id` when calling `list_templates_for_document`") 11210 # verify the required parameter 'envelope_id' is set 11211 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11212 raise ValueError("Missing the required parameter `envelope_id` when calling `list_templates_for_document`") 11213 11214 11215 collection_formats = {} 11216 11217 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/templates'.replace('{format}', 'json') 11218 path_params = {} 11219 if 'account_id' in params: 11220 path_params['accountId'] = params['account_id'] 11221 if 'document_id' in params: 11222 path_params['documentId'] = params['document_id'] 11223 if 'envelope_id' in params: 11224 path_params['envelopeId'] = params['envelope_id'] 11225 11226 query_params = {} 11227 if 'include' in params: 11228 query_params['include'] = params['include'] 11229 11230 header_params = {} 11231 11232 form_params = [] 11233 local_var_files = {} 11234 11235 body_params = None 11236 # HTTP header `Accept` 11237 header_params['Accept'] = self.api_client.\ 11238 select_header_accept(['application/json']) 11239 11240 # Authentication setting 11241 auth_settings = [] 11242 11243 return self.api_client.call_api(resource_path, 'GET', 11244 path_params, 11245 query_params, 11246 header_params, 11247 body=body_params, 11248 post_params=form_params, 11249 files=local_var_files, 11250 response_type='TemplateInformation', 11251 auth_settings=auth_settings, 11252 callback=params.get('callback'), 11253 _return_http_data_only=params.get('_return_http_data_only'), 11254 _preload_content=params.get('_preload_content', True), 11255 _request_timeout=params.get('_request_timeout'), 11256 collection_formats=collection_formats) 11257 11258 def put_attachment(self, account_id, attachment_id, envelope_id, **kwargs): 11259 """ 11260 Add an attachment to a DRAFT or IN-PROCESS envelope. 11261 Adds an attachment to a draft or in-process envelope. 11262 This method makes a synchronous HTTP request by default. To make an 11263 asynchronous HTTP request, please define a `callback` function 11264 to be invoked when receiving the response. 11265 >>> def callback_function(response): 11266 >>> pprint(response) 11267 >>> 11268 >>> thread = api.put_attachment(account_id, attachment_id, envelope_id, callback=callback_function) 11269 11270 :param callback function: The callback function 11271 for asynchronous request. (optional) 11272 :param str account_id: The external account number (int) or account ID Guid. (required) 11273 :param str attachment_id: (required) 11274 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11275 :param Attachment attachment: 11276 :return: EnvelopeAttachmentsResult 11277 If the method is called asynchronously, 11278 returns the request thread. 11279 """ 11280 kwargs['_return_http_data_only'] = True 11281 if kwargs.get('callback'): 11282 return self.put_attachment_with_http_info(account_id, attachment_id, envelope_id, **kwargs) 11283 else: 11284 (data) = self.put_attachment_with_http_info(account_id, attachment_id, envelope_id, **kwargs) 11285 return data 11286 11287 def put_attachment_with_http_info(self, account_id, attachment_id, envelope_id, **kwargs): 11288 """ 11289 Add an attachment to a DRAFT or IN-PROCESS envelope. 11290 Adds an attachment to a draft or in-process envelope. 11291 This method makes a synchronous HTTP request by default. To make an 11292 asynchronous HTTP request, please define a `callback` function 11293 to be invoked when receiving the response. 11294 >>> def callback_function(response): 11295 >>> pprint(response) 11296 >>> 11297 >>> thread = api.put_attachment_with_http_info(account_id, attachment_id, envelope_id, callback=callback_function) 11298 11299 :param callback function: The callback function 11300 for asynchronous request. (optional) 11301 :param str account_id: The external account number (int) or account ID Guid. (required) 11302 :param str attachment_id: (required) 11303 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11304 :param Attachment attachment: 11305 :return: EnvelopeAttachmentsResult 11306 If the method is called asynchronously, 11307 returns the request thread. 11308 """ 11309 11310 all_params = ['account_id', 'attachment_id', 'envelope_id', 'attachment'] 11311 all_params.append('callback') 11312 all_params.append('_return_http_data_only') 11313 all_params.append('_preload_content') 11314 all_params.append('_request_timeout') 11315 11316 params = locals() 11317 for key, val in iteritems(params['kwargs']): 11318 if key not in all_params: 11319 raise TypeError( 11320 "Got an unexpected keyword argument '%s'" 11321 " to method put_attachment" % key 11322 ) 11323 params[key] = val 11324 del params['kwargs'] 11325 # verify the required parameter 'account_id' is set 11326 if ('account_id' not in params) or (params['account_id'] is None): 11327 raise ValueError("Missing the required parameter `account_id` when calling `put_attachment`") 11328 # verify the required parameter 'attachment_id' is set 11329 if ('attachment_id' not in params) or (params['attachment_id'] is None): 11330 raise ValueError("Missing the required parameter `attachment_id` when calling `put_attachment`") 11331 # verify the required parameter 'envelope_id' is set 11332 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11333 raise ValueError("Missing the required parameter `envelope_id` when calling `put_attachment`") 11334 11335 11336 collection_formats = {} 11337 11338 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments/{attachmentId}'.replace('{format}', 'json') 11339 path_params = {} 11340 if 'account_id' in params: 11341 path_params['accountId'] = params['account_id'] 11342 if 'attachment_id' in params: 11343 path_params['attachmentId'] = params['attachment_id'] 11344 if 'envelope_id' in params: 11345 path_params['envelopeId'] = params['envelope_id'] 11346 11347 query_params = {} 11348 11349 header_params = {} 11350 11351 form_params = [] 11352 local_var_files = {} 11353 11354 body_params = None 11355 if 'attachment' in params: 11356 body_params = params['attachment'] 11357 # HTTP header `Accept` 11358 header_params['Accept'] = self.api_client.\ 11359 select_header_accept(['application/json']) 11360 11361 # Authentication setting 11362 auth_settings = [] 11363 11364 return self.api_client.call_api(resource_path, 'PUT', 11365 path_params, 11366 query_params, 11367 header_params, 11368 body=body_params, 11369 post_params=form_params, 11370 files=local_var_files, 11371 response_type='EnvelopeAttachmentsResult', 11372 auth_settings=auth_settings, 11373 callback=params.get('callback'), 11374 _return_http_data_only=params.get('_return_http_data_only'), 11375 _preload_content=params.get('_preload_content', True), 11376 _request_timeout=params.get('_request_timeout'), 11377 collection_formats=collection_formats) 11378 11379 def put_attachments(self, account_id, envelope_id, **kwargs): 11380 """ 11381 Add one or more attachments to a DRAFT or IN-PROCESS envelope. 11382 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). 11383 This method makes a synchronous HTTP request by default. To make an 11384 asynchronous HTTP request, please define a `callback` function 11385 to be invoked when receiving the response. 11386 >>> def callback_function(response): 11387 >>> pprint(response) 11388 >>> 11389 >>> thread = api.put_attachments(account_id, envelope_id, callback=callback_function) 11390 11391 :param callback function: The callback function 11392 for asynchronous request. (optional) 11393 :param str account_id: The external account number (int) or account ID Guid. (required) 11394 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11395 :param EnvelopeAttachmentsRequest envelope_attachments_request: 11396 :return: EnvelopeAttachmentsResult 11397 If the method is called asynchronously, 11398 returns the request thread. 11399 """ 11400 kwargs['_return_http_data_only'] = True 11401 if kwargs.get('callback'): 11402 return self.put_attachments_with_http_info(account_id, envelope_id, **kwargs) 11403 else: 11404 (data) = self.put_attachments_with_http_info(account_id, envelope_id, **kwargs) 11405 return data 11406 11407 def put_attachments_with_http_info(self, account_id, envelope_id, **kwargs): 11408 """ 11409 Add one or more attachments to a DRAFT or IN-PROCESS envelope. 11410 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). 11411 This method makes a synchronous HTTP request by default. To make an 11412 asynchronous HTTP request, please define a `callback` function 11413 to be invoked when receiving the response. 11414 >>> def callback_function(response): 11415 >>> pprint(response) 11416 >>> 11417 >>> thread = api.put_attachments_with_http_info(account_id, envelope_id, callback=callback_function) 11418 11419 :param callback function: The callback function 11420 for asynchronous request. (optional) 11421 :param str account_id: The external account number (int) or account ID Guid. (required) 11422 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11423 :param EnvelopeAttachmentsRequest envelope_attachments_request: 11424 :return: EnvelopeAttachmentsResult 11425 If the method is called asynchronously, 11426 returns the request thread. 11427 """ 11428 11429 all_params = ['account_id', 'envelope_id', 'envelope_attachments_request'] 11430 all_params.append('callback') 11431 all_params.append('_return_http_data_only') 11432 all_params.append('_preload_content') 11433 all_params.append('_request_timeout') 11434 11435 params = locals() 11436 for key, val in iteritems(params['kwargs']): 11437 if key not in all_params: 11438 raise TypeError( 11439 "Got an unexpected keyword argument '%s'" 11440 " to method put_attachments" % key 11441 ) 11442 params[key] = val 11443 del params['kwargs'] 11444 # verify the required parameter 'account_id' is set 11445 if ('account_id' not in params) or (params['account_id'] is None): 11446 raise ValueError("Missing the required parameter `account_id` when calling `put_attachments`") 11447 # verify the required parameter 'envelope_id' is set 11448 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11449 raise ValueError("Missing the required parameter `envelope_id` when calling `put_attachments`") 11450 11451 11452 collection_formats = {} 11453 11454 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments'.replace('{format}', 'json') 11455 path_params = {} 11456 if 'account_id' in params: 11457 path_params['accountId'] = params['account_id'] 11458 if 'envelope_id' in params: 11459 path_params['envelopeId'] = params['envelope_id'] 11460 11461 query_params = {} 11462 11463 header_params = {} 11464 11465 form_params = [] 11466 local_var_files = {} 11467 11468 body_params = None 11469 if 'envelope_attachments_request' in params: 11470 body_params = params['envelope_attachments_request'] 11471 # HTTP header `Accept` 11472 header_params['Accept'] = self.api_client.\ 11473 select_header_accept(['application/json']) 11474 11475 # Authentication setting 11476 auth_settings = [] 11477 11478 return self.api_client.call_api(resource_path, 'PUT', 11479 path_params, 11480 query_params, 11481 header_params, 11482 body=body_params, 11483 post_params=form_params, 11484 files=local_var_files, 11485 response_type='EnvelopeAttachmentsResult', 11486 auth_settings=auth_settings, 11487 callback=params.get('callback'), 11488 _return_http_data_only=params.get('_return_http_data_only'), 11489 _preload_content=params.get('_preload_content', True), 11490 _request_timeout=params.get('_request_timeout'), 11491 collection_formats=collection_formats) 11492 11493 def rotate_document_page(self, account_id, document_id, envelope_id, page_number, **kwargs): 11494 """ 11495 Rotates page image from an envelope for display. 11496 Rotates page image from an envelope for display. The page image can be rotated to the left or right. 11497 This method makes a synchronous HTTP request by default. To make an 11498 asynchronous HTTP request, please define a `callback` function 11499 to be invoked when receiving the response. 11500 >>> def callback_function(response): 11501 >>> pprint(response) 11502 >>> 11503 >>> thread = api.rotate_document_page(account_id, document_id, envelope_id, page_number, callback=callback_function) 11504 11505 :param callback function: The callback function 11506 for asynchronous request. (optional) 11507 :param str account_id: The external account number (int) or account ID Guid. (required) 11508 :param str document_id: The ID of the document being accessed. (required) 11509 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11510 :param str page_number: The page number being accessed. (required) 11511 :param PageRequest page_request: 11512 :return: None 11513 If the method is called asynchronously, 11514 returns the request thread. 11515 """ 11516 kwargs['_return_http_data_only'] = True 11517 if kwargs.get('callback'): 11518 return self.rotate_document_page_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 11519 else: 11520 (data) = self.rotate_document_page_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 11521 return data 11522 11523 def rotate_document_page_with_http_info(self, account_id, document_id, envelope_id, page_number, **kwargs): 11524 """ 11525 Rotates page image from an envelope for display. 11526 Rotates page image from an envelope for display. The page image can be rotated to the left or right. 11527 This method makes a synchronous HTTP request by default. To make an 11528 asynchronous HTTP request, please define a `callback` function 11529 to be invoked when receiving the response. 11530 >>> def callback_function(response): 11531 >>> pprint(response) 11532 >>> 11533 >>> thread = api.rotate_document_page_with_http_info(account_id, document_id, envelope_id, page_number, callback=callback_function) 11534 11535 :param callback function: The callback function 11536 for asynchronous request. (optional) 11537 :param str account_id: The external account number (int) or account ID Guid. (required) 11538 :param str document_id: The ID of the document being accessed. (required) 11539 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11540 :param str page_number: The page number being accessed. (required) 11541 :param PageRequest page_request: 11542 :return: None 11543 If the method is called asynchronously, 11544 returns the request thread. 11545 """ 11546 11547 all_params = ['account_id', 'document_id', 'envelope_id', 'page_number', 'page_request'] 11548 all_params.append('callback') 11549 all_params.append('_return_http_data_only') 11550 all_params.append('_preload_content') 11551 all_params.append('_request_timeout') 11552 11553 params = locals() 11554 for key, val in iteritems(params['kwargs']): 11555 if key not in all_params: 11556 raise TypeError( 11557 "Got an unexpected keyword argument '%s'" 11558 " to method rotate_document_page" % key 11559 ) 11560 params[key] = val 11561 del params['kwargs'] 11562 # verify the required parameter 'account_id' is set 11563 if ('account_id' not in params) or (params['account_id'] is None): 11564 raise ValueError("Missing the required parameter `account_id` when calling `rotate_document_page`") 11565 # verify the required parameter 'document_id' is set 11566 if ('document_id' not in params) or (params['document_id'] is None): 11567 raise ValueError("Missing the required parameter `document_id` when calling `rotate_document_page`") 11568 # verify the required parameter 'envelope_id' is set 11569 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11570 raise ValueError("Missing the required parameter `envelope_id` when calling `rotate_document_page`") 11571 # verify the required parameter 'page_number' is set 11572 if ('page_number' not in params) or (params['page_number'] is None): 11573 raise ValueError("Missing the required parameter `page_number` when calling `rotate_document_page`") 11574 11575 11576 collection_formats = {} 11577 11578 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/pages/{pageNumber}/page_image'.replace('{format}', 'json') 11579 path_params = {} 11580 if 'account_id' in params: 11581 path_params['accountId'] = params['account_id'] 11582 if 'document_id' in params: 11583 path_params['documentId'] = params['document_id'] 11584 if 'envelope_id' in params: 11585 path_params['envelopeId'] = params['envelope_id'] 11586 if 'page_number' in params: 11587 path_params['pageNumber'] = params['page_number'] 11588 11589 query_params = {} 11590 11591 header_params = {} 11592 11593 form_params = [] 11594 local_var_files = {} 11595 11596 body_params = None 11597 if 'page_request' in params: 11598 body_params = params['page_request'] 11599 # HTTP header `Accept` 11600 header_params['Accept'] = self.api_client.\ 11601 select_header_accept(['application/json']) 11602 11603 # Authentication setting 11604 auth_settings = [] 11605 11606 return self.api_client.call_api(resource_path, 'PUT', 11607 path_params, 11608 query_params, 11609 header_params, 11610 body=body_params, 11611 post_params=form_params, 11612 files=local_var_files, 11613 response_type=None, 11614 auth_settings=auth_settings, 11615 callback=params.get('callback'), 11616 _return_http_data_only=params.get('_return_http_data_only'), 11617 _preload_content=params.get('_preload_content', True), 11618 _request_timeout=params.get('_request_timeout'), 11619 collection_formats=collection_formats) 11620 11621 def update(self, account_id, envelope_id, **kwargs): 11622 """ 11623 Send Draft Envelope/Void Envelope/Move/Purge Envelope/Modify draft 11624 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. 11625 This method makes a synchronous HTTP request by default. To make an 11626 asynchronous HTTP request, please define a `callback` function 11627 to be invoked when receiving the response. 11628 >>> def callback_function(response): 11629 >>> pprint(response) 11630 >>> 11631 >>> thread = api.update(account_id, envelope_id, callback=callback_function) 11632 11633 :param callback function: The callback function 11634 for asynchronous request. (optional) 11635 :param str account_id: The external account number (int) or account ID Guid. (required) 11636 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11637 :param str advanced_update: When set to **true**, allows the caller to update recipients, tabs, custom fields, notification, email settings and other envelope attributes. 11638 :param str recycle_on_void: 11639 :param str resend_envelope: When set to **true**, sends the specified envelope again. 11640 :param Envelope envelope: 11641 :return: EnvelopeUpdateSummary 11642 If the method is called asynchronously, 11643 returns the request thread. 11644 """ 11645 kwargs['_return_http_data_only'] = True 11646 if kwargs.get('callback'): 11647 return self.update_with_http_info(account_id, envelope_id, **kwargs) 11648 else: 11649 (data) = self.update_with_http_info(account_id, envelope_id, **kwargs) 11650 return data 11651 11652 def update_with_http_info(self, account_id, envelope_id, **kwargs): 11653 """ 11654 Send Draft Envelope/Void Envelope/Move/Purge Envelope/Modify draft 11655 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. 11656 This method makes a synchronous HTTP request by default. To make an 11657 asynchronous HTTP request, please define a `callback` function 11658 to be invoked when receiving the response. 11659 >>> def callback_function(response): 11660 >>> pprint(response) 11661 >>> 11662 >>> thread = api.update_with_http_info(account_id, envelope_id, callback=callback_function) 11663 11664 :param callback function: The callback function 11665 for asynchronous request. (optional) 11666 :param str account_id: The external account number (int) or account ID Guid. (required) 11667 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11668 :param str advanced_update: When set to **true**, allows the caller to update recipients, tabs, custom fields, notification, email settings and other envelope attributes. 11669 :param str recycle_on_void: 11670 :param str resend_envelope: When set to **true**, sends the specified envelope again. 11671 :param Envelope envelope: 11672 :return: EnvelopeUpdateSummary 11673 If the method is called asynchronously, 11674 returns the request thread. 11675 """ 11676 11677 all_params = ['account_id', 'envelope_id', 'advanced_update', 'recycle_on_void', 'resend_envelope', 'envelope'] 11678 all_params.append('callback') 11679 all_params.append('_return_http_data_only') 11680 all_params.append('_preload_content') 11681 all_params.append('_request_timeout') 11682 11683 params = locals() 11684 for key, val in iteritems(params['kwargs']): 11685 if key not in all_params: 11686 raise TypeError( 11687 "Got an unexpected keyword argument '%s'" 11688 " to method update" % key 11689 ) 11690 params[key] = val 11691 del params['kwargs'] 11692 # verify the required parameter 'account_id' is set 11693 if ('account_id' not in params) or (params['account_id'] is None): 11694 raise ValueError("Missing the required parameter `account_id` when calling `update`") 11695 # verify the required parameter 'envelope_id' is set 11696 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11697 raise ValueError("Missing the required parameter `envelope_id` when calling `update`") 11698 11699 11700 collection_formats = {} 11701 11702 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}'.replace('{format}', 'json') 11703 path_params = {} 11704 if 'account_id' in params: 11705 path_params['accountId'] = params['account_id'] 11706 if 'envelope_id' in params: 11707 path_params['envelopeId'] = params['envelope_id'] 11708 11709 query_params = {} 11710 if 'advanced_update' in params: 11711 query_params['advanced_update'] = params['advanced_update'] 11712 if 'recycle_on_void' in params: 11713 query_params['recycle_on_void'] = params['recycle_on_void'] 11714 if 'resend_envelope' in params: 11715 query_params['resend_envelope'] = params['resend_envelope'] 11716 11717 header_params = {} 11718 11719 form_params = [] 11720 local_var_files = {} 11721 11722 body_params = None 11723 if 'envelope' in params: 11724 body_params = params['envelope'] 11725 # HTTP header `Accept` 11726 header_params['Accept'] = self.api_client.\ 11727 select_header_accept(['application/json']) 11728 11729 # Authentication setting 11730 auth_settings = [] 11731 11732 return self.api_client.call_api(resource_path, 'PUT', 11733 path_params, 11734 query_params, 11735 header_params, 11736 body=body_params, 11737 post_params=form_params, 11738 files=local_var_files, 11739 response_type='EnvelopeUpdateSummary', 11740 auth_settings=auth_settings, 11741 callback=params.get('callback'), 11742 _return_http_data_only=params.get('_return_http_data_only'), 11743 _preload_content=params.get('_preload_content', True), 11744 _request_timeout=params.get('_request_timeout'), 11745 collection_formats=collection_formats) 11746 11747 def update_chunked_upload(self, account_id, chunked_upload_id, **kwargs): 11748 """ 11749 Integrity-Check and Commit a ChunkedUpload, readying it for use elsewhere. 11750 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. 11751 This method makes a synchronous HTTP request by default. To make an 11752 asynchronous HTTP request, please define a `callback` function 11753 to be invoked when receiving the response. 11754 >>> def callback_function(response): 11755 >>> pprint(response) 11756 >>> 11757 >>> thread = api.update_chunked_upload(account_id, chunked_upload_id, callback=callback_function) 11758 11759 :param callback function: The callback function 11760 for asynchronous request. (optional) 11761 :param str account_id: The external account number (int) or account ID Guid. (required) 11762 :param str chunked_upload_id: (required) 11763 :param str action: 11764 :return: ChunkedUploadResponse 11765 If the method is called asynchronously, 11766 returns the request thread. 11767 """ 11768 kwargs['_return_http_data_only'] = True 11769 if kwargs.get('callback'): 11770 return self.update_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 11771 else: 11772 (data) = self.update_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 11773 return data 11774 11775 def update_chunked_upload_with_http_info(self, account_id, chunked_upload_id, **kwargs): 11776 """ 11777 Integrity-Check and Commit a ChunkedUpload, readying it for use elsewhere. 11778 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. 11779 This method makes a synchronous HTTP request by default. To make an 11780 asynchronous HTTP request, please define a `callback` function 11781 to be invoked when receiving the response. 11782 >>> def callback_function(response): 11783 >>> pprint(response) 11784 >>> 11785 >>> thread = api.update_chunked_upload_with_http_info(account_id, chunked_upload_id, callback=callback_function) 11786 11787 :param callback function: The callback function 11788 for asynchronous request. (optional) 11789 :param str account_id: The external account number (int) or account ID Guid. (required) 11790 :param str chunked_upload_id: (required) 11791 :param str action: 11792 :return: ChunkedUploadResponse 11793 If the method is called asynchronously, 11794 returns the request thread. 11795 """ 11796 11797 all_params = ['account_id', 'chunked_upload_id', 'action'] 11798 all_params.append('callback') 11799 all_params.append('_return_http_data_only') 11800 all_params.append('_preload_content') 11801 all_params.append('_request_timeout') 11802 11803 params = locals() 11804 for key, val in iteritems(params['kwargs']): 11805 if key not in all_params: 11806 raise TypeError( 11807 "Got an unexpected keyword argument '%s'" 11808 " to method update_chunked_upload" % key 11809 ) 11810 params[key] = val 11811 del params['kwargs'] 11812 # verify the required parameter 'account_id' is set 11813 if ('account_id' not in params) or (params['account_id'] is None): 11814 raise ValueError("Missing the required parameter `account_id` when calling `update_chunked_upload`") 11815 # verify the required parameter 'chunked_upload_id' is set 11816 if ('chunked_upload_id' not in params) or (params['chunked_upload_id'] is None): 11817 raise ValueError("Missing the required parameter `chunked_upload_id` when calling `update_chunked_upload`") 11818 11819 11820 collection_formats = {} 11821 11822 resource_path = '/v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}'.replace('{format}', 'json') 11823 path_params = {} 11824 if 'account_id' in params: 11825 path_params['accountId'] = params['account_id'] 11826 if 'chunked_upload_id' in params: 11827 path_params['chunkedUploadId'] = params['chunked_upload_id'] 11828 11829 query_params = {} 11830 if 'action' in params: 11831 query_params['action'] = params['action'] 11832 11833 header_params = {} 11834 11835 form_params = [] 11836 local_var_files = {} 11837 11838 body_params = None 11839 # HTTP header `Accept` 11840 header_params['Accept'] = self.api_client.\ 11841 select_header_accept(['application/json']) 11842 11843 # Authentication setting 11844 auth_settings = [] 11845 11846 return self.api_client.call_api(resource_path, 'PUT', 11847 path_params, 11848 query_params, 11849 header_params, 11850 body=body_params, 11851 post_params=form_params, 11852 files=local_var_files, 11853 response_type='ChunkedUploadResponse', 11854 auth_settings=auth_settings, 11855 callback=params.get('callback'), 11856 _return_http_data_only=params.get('_return_http_data_only'), 11857 _preload_content=params.get('_preload_content', True), 11858 _request_timeout=params.get('_request_timeout'), 11859 collection_formats=collection_formats) 11860 11861 def update_chunked_upload_part(self, account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs): 11862 """ 11863 Add a chunk, a chunk 'part', to an existing ChunkedUpload. 11864 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. 11865 This method makes a synchronous HTTP request by default. To make an 11866 asynchronous HTTP request, please define a `callback` function 11867 to be invoked when receiving the response. 11868 >>> def callback_function(response): 11869 >>> pprint(response) 11870 >>> 11871 >>> thread = api.update_chunked_upload_part(account_id, chunked_upload_id, chunked_upload_part_seq, callback=callback_function) 11872 11873 :param callback function: The callback function 11874 for asynchronous request. (optional) 11875 :param str account_id: The external account number (int) or account ID Guid. (required) 11876 :param str chunked_upload_id: (required) 11877 :param str chunked_upload_part_seq: (required) 11878 :param ChunkedUploadRequest chunked_upload_request: 11879 :return: ChunkedUploadResponse 11880 If the method is called asynchronously, 11881 returns the request thread. 11882 """ 11883 kwargs['_return_http_data_only'] = True 11884 if kwargs.get('callback'): 11885 return self.update_chunked_upload_part_with_http_info(account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs) 11886 else: 11887 (data) = self.update_chunked_upload_part_with_http_info(account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs) 11888 return data 11889 11890 def update_chunked_upload_part_with_http_info(self, account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs): 11891 """ 11892 Add a chunk, a chunk 'part', to an existing ChunkedUpload. 11893 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. 11894 This method makes a synchronous HTTP request by default. To make an 11895 asynchronous HTTP request, please define a `callback` function 11896 to be invoked when receiving the response. 11897 >>> def callback_function(response): 11898 >>> pprint(response) 11899 >>> 11900 >>> thread = api.update_chunked_upload_part_with_http_info(account_id, chunked_upload_id, chunked_upload_part_seq, callback=callback_function) 11901 11902 :param callback function: The callback function 11903 for asynchronous request. (optional) 11904 :param str account_id: The external account number (int) or account ID Guid. (required) 11905 :param str chunked_upload_id: (required) 11906 :param str chunked_upload_part_seq: (required) 11907 :param ChunkedUploadRequest chunked_upload_request: 11908 :return: ChunkedUploadResponse 11909 If the method is called asynchronously, 11910 returns the request thread. 11911 """ 11912 11913 all_params = ['account_id', 'chunked_upload_id', 'chunked_upload_part_seq', 'chunked_upload_request'] 11914 all_params.append('callback') 11915 all_params.append('_return_http_data_only') 11916 all_params.append('_preload_content') 11917 all_params.append('_request_timeout') 11918 11919 params = locals() 11920 for key, val in iteritems(params['kwargs']): 11921 if key not in all_params: 11922 raise TypeError( 11923 "Got an unexpected keyword argument '%s'" 11924 " to method update_chunked_upload_part" % key 11925 ) 11926 params[key] = val 11927 del params['kwargs'] 11928 # verify the required parameter 'account_id' is set 11929 if ('account_id' not in params) or (params['account_id'] is None): 11930 raise ValueError("Missing the required parameter `account_id` when calling `update_chunked_upload_part`") 11931 # verify the required parameter 'chunked_upload_id' is set 11932 if ('chunked_upload_id' not in params) or (params['chunked_upload_id'] is None): 11933 raise ValueError("Missing the required parameter `chunked_upload_id` when calling `update_chunked_upload_part`") 11934 # verify the required parameter 'chunked_upload_part_seq' is set 11935 if ('chunked_upload_part_seq' not in params) or (params['chunked_upload_part_seq'] is None): 11936 raise ValueError("Missing the required parameter `chunked_upload_part_seq` when calling `update_chunked_upload_part`") 11937 11938 11939 collection_formats = {} 11940 11941 resource_path = '/v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}/{chunkedUploadPartSeq}'.replace('{format}', 'json') 11942 path_params = {} 11943 if 'account_id' in params: 11944 path_params['accountId'] = params['account_id'] 11945 if 'chunked_upload_id' in params: 11946 path_params['chunkedUploadId'] = params['chunked_upload_id'] 11947 if 'chunked_upload_part_seq' in params: 11948 path_params['chunkedUploadPartSeq'] = params['chunked_upload_part_seq'] 11949 11950 query_params = {} 11951 11952 header_params = {} 11953 11954 form_params = [] 11955 local_var_files = {} 11956 11957 body_params = None 11958 if 'chunked_upload_request' in params: 11959 body_params = params['chunked_upload_request'] 11960 # HTTP header `Accept` 11961 header_params['Accept'] = self.api_client.\ 11962 select_header_accept(['application/json']) 11963 11964 # Authentication setting 11965 auth_settings = [] 11966 11967 return self.api_client.call_api(resource_path, 'PUT', 11968 path_params, 11969 query_params, 11970 header_params, 11971 body=body_params, 11972 post_params=form_params, 11973 files=local_var_files, 11974 response_type='ChunkedUploadResponse', 11975 auth_settings=auth_settings, 11976 callback=params.get('callback'), 11977 _return_http_data_only=params.get('_return_http_data_only'), 11978 _preload_content=params.get('_preload_content', True), 11979 _request_timeout=params.get('_request_timeout'), 11980 collection_formats=collection_formats) 11981 11982 def update_custom_fields(self, account_id, envelope_id, **kwargs): 11983 """ 11984 Updates envelope custom fields in an envelope. 11985 Updates the envelope custom fields in draft and in-process envelopes. Each custom field used in an envelope must have a unique name. 11986 This method makes a synchronous HTTP request by default. To make an 11987 asynchronous HTTP request, please define a `callback` function 11988 to be invoked when receiving the response. 11989 >>> def callback_function(response): 11990 >>> pprint(response) 11991 >>> 11992 >>> thread = api.update_custom_fields(account_id, envelope_id, callback=callback_function) 11993 11994 :param callback function: The callback function 11995 for asynchronous request. (optional) 11996 :param str account_id: The external account number (int) or account ID Guid. (required) 11997 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11998 :param CustomFields custom_fields: 11999 :return: CustomFields 12000 If the method is called asynchronously, 12001 returns the request thread. 12002 """ 12003 kwargs['_return_http_data_only'] = True 12004 if kwargs.get('callback'): 12005 return self.update_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 12006 else: 12007 (data) = self.update_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 12008 return data 12009 12010 def update_custom_fields_with_http_info(self, account_id, envelope_id, **kwargs): 12011 """ 12012 Updates envelope custom fields in an envelope. 12013 Updates the envelope custom fields in draft and in-process envelopes. Each custom field used in an envelope must have a unique name. 12014 This method makes a synchronous HTTP request by default. To make an 12015 asynchronous HTTP request, please define a `callback` function 12016 to be invoked when receiving the response. 12017 >>> def callback_function(response): 12018 >>> pprint(response) 12019 >>> 12020 >>> thread = api.update_custom_fields_with_http_info(account_id, envelope_id, callback=callback_function) 12021 12022 :param callback function: The callback function 12023 for asynchronous request. (optional) 12024 :param str account_id: The external account number (int) or account ID Guid. (required) 12025 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12026 :param CustomFields custom_fields: 12027 :return: CustomFields 12028 If the method is called asynchronously, 12029 returns the request thread. 12030 """ 12031 12032 all_params = ['account_id', 'envelope_id', 'custom_fields'] 12033 all_params.append('callback') 12034 all_params.append('_return_http_data_only') 12035 all_params.append('_preload_content') 12036 all_params.append('_request_timeout') 12037 12038 params = locals() 12039 for key, val in iteritems(params['kwargs']): 12040 if key not in all_params: 12041 raise TypeError( 12042 "Got an unexpected keyword argument '%s'" 12043 " to method update_custom_fields" % key 12044 ) 12045 params[key] = val 12046 del params['kwargs'] 12047 # verify the required parameter 'account_id' is set 12048 if ('account_id' not in params) or (params['account_id'] is None): 12049 raise ValueError("Missing the required parameter `account_id` when calling `update_custom_fields`") 12050 # verify the required parameter 'envelope_id' is set 12051 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12052 raise ValueError("Missing the required parameter `envelope_id` when calling `update_custom_fields`") 12053 12054 12055 collection_formats = {} 12056 12057 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/custom_fields'.replace('{format}', 'json') 12058 path_params = {} 12059 if 'account_id' in params: 12060 path_params['accountId'] = params['account_id'] 12061 if 'envelope_id' in params: 12062 path_params['envelopeId'] = params['envelope_id'] 12063 12064 query_params = {} 12065 12066 header_params = {} 12067 12068 form_params = [] 12069 local_var_files = {} 12070 12071 body_params = None 12072 if 'custom_fields' in params: 12073 body_params = params['custom_fields'] 12074 # HTTP header `Accept` 12075 header_params['Accept'] = self.api_client.\ 12076 select_header_accept(['application/json']) 12077 12078 # Authentication setting 12079 auth_settings = [] 12080 12081 return self.api_client.call_api(resource_path, 'PUT', 12082 path_params, 12083 query_params, 12084 header_params, 12085 body=body_params, 12086 post_params=form_params, 12087 files=local_var_files, 12088 response_type='CustomFields', 12089 auth_settings=auth_settings, 12090 callback=params.get('callback'), 12091 _return_http_data_only=params.get('_return_http_data_only'), 12092 _preload_content=params.get('_preload_content', True), 12093 _request_timeout=params.get('_request_timeout'), 12094 collection_formats=collection_formats) 12095 12096 def update_document(self, account_id, document_id, envelope_id, document_file_bytes, **kwargs): 12097 """ 12098 Adds a document to an existing draft envelope. 12099 Adds a document to an existing draft envelope. 12100 This method makes a synchronous HTTP request by default. To make an 12101 asynchronous HTTP request, please define a `callback` function 12102 to be invoked when receiving the response. 12103 >>> def callback_function(response): 12104 >>> pprint(response) 12105 >>> 12106 >>> thread = api.update_document(account_id, document_id, envelope_id, document_file_bytes, callback=callback_function) 12107 12108 :param callback function: The callback function 12109 for asynchronous request. (optional) 12110 :param str account_id: The external account number (int) or account ID Guid. (required) 12111 :param str document_id: The ID of the document being accessed. (required) 12112 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12113 :param str document_file_bytes: Updated document content. (required) 12114 :return: EnvelopeDocument 12115 If the method is called asynchronously, 12116 returns the request thread. 12117 """ 12118 kwargs['_return_http_data_only'] = True 12119 if kwargs.get('callback'): 12120 return self.update_document_with_http_info(account_id, document_id, envelope_id, document_file_bytes, **kwargs) 12121 else: 12122 (data) = self.update_document_with_http_info(account_id, document_id, envelope_id, document_file_bytes, **kwargs) 12123 return data 12124 12125 def update_document_with_http_info(self, account_id, document_id, envelope_id, document_file_bytes, **kwargs): 12126 """ 12127 Adds a document to an existing draft envelope. 12128 Adds a document to an existing draft envelope. 12129 This method makes a synchronous HTTP request by default. To make an 12130 asynchronous HTTP request, please define a `callback` function 12131 to be invoked when receiving the response. 12132 >>> def callback_function(response): 12133 >>> pprint(response) 12134 >>> 12135 >>> thread = api.update_document_with_http_info(account_id, document_id, envelope_id, document_file_bytes, callback=callback_function) 12136 12137 :param callback function: The callback function 12138 for asynchronous request. (optional) 12139 :param str account_id: The external account number (int) or account ID Guid. (required) 12140 :param str document_id: The ID of the document being accessed. (required) 12141 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12142 :param str document_file_bytes: Updated document content. (required) 12143 :return: EnvelopeDocument 12144 If the method is called asynchronously, 12145 returns the request thread. 12146 """ 12147 12148 all_params = ['account_id', 'document_id', 'envelope_id', 'document_file_bytes'] 12149 all_params.append('callback') 12150 all_params.append('_return_http_data_only') 12151 all_params.append('_preload_content') 12152 all_params.append('_request_timeout') 12153 12154 params = locals() 12155 for key, val in iteritems(params['kwargs']): 12156 if key not in all_params: 12157 raise TypeError( 12158 "Got an unexpected keyword argument '%s'" 12159 " to method update_document" % key 12160 ) 12161 params[key] = val 12162 del params['kwargs'] 12163 # verify the required parameter 'account_id' is set 12164 if ('account_id' not in params) or (params['account_id'] is None): 12165 raise ValueError("Missing the required parameter `account_id` when calling `update_document`") 12166 # verify the required parameter 'document_id' is set 12167 if ('document_id' not in params) or (params['document_id'] is None): 12168 raise ValueError("Missing the required parameter `document_id` when calling `update_document`") 12169 # verify the required parameter 'envelope_id' is set 12170 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12171 raise ValueError("Missing the required parameter `envelope_id` when calling `update_document`") 12172 # verify the required parameter 'document_file_bytes' is set 12173 if ('document_file_bytes' not in params) or (params['document_file_bytes'] is None): 12174 raise ValueError("Missing the required parameter `document_file_bytes` when calling `update_document`") 12175 12176 12177 collection_formats = {} 12178 12179 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}'.replace('{format}', 'json') 12180 path_params = {} 12181 if 'account_id' in params: 12182 path_params['accountId'] = params['account_id'] 12183 if 'document_id' in params: 12184 path_params['documentId'] = params['document_id'] 12185 if 'envelope_id' in params: 12186 path_params['envelopeId'] = params['envelope_id'] 12187 12188 query_params = {} 12189 12190 header_params = {} 12191 12192 form_params = [] 12193 local_var_files = {} 12194 12195 body_params = None 12196 if 'document_file_bytes' in params: 12197 body_params = params['document_file_bytes'] 12198 # HTTP header `Accept` 12199 header_params['Accept'] = self.api_client.\ 12200 select_header_accept(['application/json']) 12201 12202 # HTTP header `Content-Type` 12203 header_params['Content-Type'] = self.api_client.\ 12204 select_header_content_type(['application/pdf']) 12205 12206 # Authentication setting 12207 auth_settings = [] 12208 12209 return self.api_client.call_api(resource_path, 'PUT', 12210 path_params, 12211 query_params, 12212 header_params, 12213 body=body_params, 12214 post_params=form_params, 12215 files=local_var_files, 12216 response_type='EnvelopeDocument', 12217 auth_settings=auth_settings, 12218 callback=params.get('callback'), 12219 _return_http_data_only=params.get('_return_http_data_only'), 12220 _preload_content=params.get('_preload_content', True), 12221 _request_timeout=params.get('_request_timeout'), 12222 collection_formats=collection_formats) 12223 12224 def update_document_fields(self, account_id, document_id, envelope_id, **kwargs): 12225 """ 12226 Updates existing custom document fields in an existing envelope document. 12227 Updates existing custom document fields in an existing envelope document. 12228 This method makes a synchronous HTTP request by default. To make an 12229 asynchronous HTTP request, please define a `callback` function 12230 to be invoked when receiving the response. 12231 >>> def callback_function(response): 12232 >>> pprint(response) 12233 >>> 12234 >>> thread = api.update_document_fields(account_id, document_id, envelope_id, callback=callback_function) 12235 12236 :param callback function: The callback function 12237 for asynchronous request. (optional) 12238 :param str account_id: The external account number (int) or account ID Guid. (required) 12239 :param str document_id: The ID of the document being accessed. (required) 12240 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12241 :param DocumentFieldsInformation document_fields_information: 12242 :return: DocumentFieldsInformation 12243 If the method is called asynchronously, 12244 returns the request thread. 12245 """ 12246 kwargs['_return_http_data_only'] = True 12247 if kwargs.get('callback'): 12248 return self.update_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 12249 else: 12250 (data) = self.update_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 12251 return data 12252 12253 def update_document_fields_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 12254 """ 12255 Updates existing custom document fields in an existing envelope document. 12256 Updates existing custom document fields in an existing envelope document. 12257 This method makes a synchronous HTTP request by default. To make an 12258 asynchronous HTTP request, please define a `callback` function 12259 to be invoked when receiving the response. 12260 >>> def callback_function(response): 12261 >>> pprint(response) 12262 >>> 12263 >>> thread = api.update_document_fields_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 12264 12265 :param callback function: The callback function 12266 for asynchronous request. (optional) 12267 :param str account_id: The external account number (int) or account ID Guid. (required) 12268 :param str document_id: The ID of the document being accessed. (required) 12269 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12270 :param DocumentFieldsInformation document_fields_information: 12271 :return: DocumentFieldsInformation 12272 If the method is called asynchronously, 12273 returns the request thread. 12274 """ 12275 12276 all_params = ['account_id', 'document_id', 'envelope_id', 'document_fields_information'] 12277 all_params.append('callback') 12278 all_params.append('_return_http_data_only') 12279 all_params.append('_preload_content') 12280 all_params.append('_request_timeout') 12281 12282 params = locals() 12283 for key, val in iteritems(params['kwargs']): 12284 if key not in all_params: 12285 raise TypeError( 12286 "Got an unexpected keyword argument '%s'" 12287 " to method update_document_fields" % key 12288 ) 12289 params[key] = val 12290 del params['kwargs'] 12291 # verify the required parameter 'account_id' is set 12292 if ('account_id' not in params) or (params['account_id'] is None): 12293 raise ValueError("Missing the required parameter `account_id` when calling `update_document_fields`") 12294 # verify the required parameter 'document_id' is set 12295 if ('document_id' not in params) or (params['document_id'] is None): 12296 raise ValueError("Missing the required parameter `document_id` when calling `update_document_fields`") 12297 # verify the required parameter 'envelope_id' is set 12298 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12299 raise ValueError("Missing the required parameter `envelope_id` when calling `update_document_fields`") 12300 12301 12302 collection_formats = {} 12303 12304 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/fields'.replace('{format}', 'json') 12305 path_params = {} 12306 if 'account_id' in params: 12307 path_params['accountId'] = params['account_id'] 12308 if 'document_id' in params: 12309 path_params['documentId'] = params['document_id'] 12310 if 'envelope_id' in params: 12311 path_params['envelopeId'] = params['envelope_id'] 12312 12313 query_params = {} 12314 12315 header_params = {} 12316 12317 form_params = [] 12318 local_var_files = {} 12319 12320 body_params = None 12321 if 'document_fields_information' in params: 12322 body_params = params['document_fields_information'] 12323 # HTTP header `Accept` 12324 header_params['Accept'] = self.api_client.\ 12325 select_header_accept(['application/json']) 12326 12327 # Authentication setting 12328 auth_settings = [] 12329 12330 return self.api_client.call_api(resource_path, 'PUT', 12331 path_params, 12332 query_params, 12333 header_params, 12334 body=body_params, 12335 post_params=form_params, 12336 files=local_var_files, 12337 response_type='DocumentFieldsInformation', 12338 auth_settings=auth_settings, 12339 callback=params.get('callback'), 12340 _return_http_data_only=params.get('_return_http_data_only'), 12341 _preload_content=params.get('_preload_content', True), 12342 _request_timeout=params.get('_request_timeout'), 12343 collection_formats=collection_formats) 12344 12345 def update_document_tabs(self, account_id, document_id, envelope_id, **kwargs): 12346 """ 12347 Updates the tabs for an envelope document 12348 Updates tabs in the document specified by `documentId` in the envelope specified by `envelopeId`. 12349 This method makes a synchronous HTTP request by default. To make an 12350 asynchronous HTTP request, please define a `callback` function 12351 to be invoked when receiving the response. 12352 >>> def callback_function(response): 12353 >>> pprint(response) 12354 >>> 12355 >>> thread = api.update_document_tabs(account_id, document_id, envelope_id, callback=callback_function) 12356 12357 :param callback function: The callback function 12358 for asynchronous request. (optional) 12359 :param str account_id: The external account number (int) or account ID Guid. (required) 12360 :param str document_id: The ID of the document being accessed. (required) 12361 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12362 :param Tabs tabs: 12363 :return: Tabs 12364 If the method is called asynchronously, 12365 returns the request thread. 12366 """ 12367 kwargs['_return_http_data_only'] = True 12368 if kwargs.get('callback'): 12369 return self.update_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 12370 else: 12371 (data) = self.update_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 12372 return data 12373 12374 def update_document_tabs_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 12375 """ 12376 Updates the tabs for an envelope document 12377 Updates tabs in the document specified by `documentId` in the envelope specified by `envelopeId`. 12378 This method makes a synchronous HTTP request by default. To make an 12379 asynchronous HTTP request, please define a `callback` function 12380 to be invoked when receiving the response. 12381 >>> def callback_function(response): 12382 >>> pprint(response) 12383 >>> 12384 >>> thread = api.update_document_tabs_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 12385 12386 :param callback function: The callback function 12387 for asynchronous request. (optional) 12388 :param str account_id: The external account number (int) or account ID Guid. (required) 12389 :param str document_id: The ID of the document being accessed. (required) 12390 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12391 :param Tabs tabs: 12392 :return: Tabs 12393 If the method is called asynchronously, 12394 returns the request thread. 12395 """ 12396 12397 all_params = ['account_id', 'document_id', 'envelope_id', 'tabs'] 12398 all_params.append('callback') 12399 all_params.append('_return_http_data_only') 12400 all_params.append('_preload_content') 12401 all_params.append('_request_timeout') 12402 12403 params = locals() 12404 for key, val in iteritems(params['kwargs']): 12405 if key not in all_params: 12406 raise TypeError( 12407 "Got an unexpected keyword argument '%s'" 12408 " to method update_document_tabs" % key 12409 ) 12410 params[key] = val 12411 del params['kwargs'] 12412 # verify the required parameter 'account_id' is set 12413 if ('account_id' not in params) or (params['account_id'] is None): 12414 raise ValueError("Missing the required parameter `account_id` when calling `update_document_tabs`") 12415 # verify the required parameter 'document_id' is set 12416 if ('document_id' not in params) or (params['document_id'] is None): 12417 raise ValueError("Missing the required parameter `document_id` when calling `update_document_tabs`") 12418 # verify the required parameter 'envelope_id' is set 12419 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12420 raise ValueError("Missing the required parameter `envelope_id` when calling `update_document_tabs`") 12421 12422 12423 collection_formats = {} 12424 12425 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/tabs'.replace('{format}', 'json') 12426 path_params = {} 12427 if 'account_id' in params: 12428 path_params['accountId'] = params['account_id'] 12429 if 'document_id' in params: 12430 path_params['documentId'] = params['document_id'] 12431 if 'envelope_id' in params: 12432 path_params['envelopeId'] = params['envelope_id'] 12433 12434 query_params = {} 12435 12436 header_params = {} 12437 12438 form_params = [] 12439 local_var_files = {} 12440 12441 body_params = None 12442 if 'tabs' in params: 12443 body_params = params['tabs'] 12444 # HTTP header `Accept` 12445 header_params['Accept'] = self.api_client.\ 12446 select_header_accept(['application/json']) 12447 12448 # Authentication setting 12449 auth_settings = [] 12450 12451 return self.api_client.call_api(resource_path, 'PUT', 12452 path_params, 12453 query_params, 12454 header_params, 12455 body=body_params, 12456 post_params=form_params, 12457 files=local_var_files, 12458 response_type='Tabs', 12459 auth_settings=auth_settings, 12460 callback=params.get('callback'), 12461 _return_http_data_only=params.get('_return_http_data_only'), 12462 _preload_content=params.get('_preload_content', True), 12463 _request_timeout=params.get('_request_timeout'), 12464 collection_formats=collection_formats) 12465 12466 def update_documents(self, account_id, envelope_id, **kwargs): 12467 """ 12468 Adds one or more documents to an existing envelope document. 12469 Adds one or more documents to an existing envelope document. 12470 This method makes a synchronous HTTP request by default. To make an 12471 asynchronous HTTP request, please define a `callback` function 12472 to be invoked when receiving the response. 12473 >>> def callback_function(response): 12474 >>> pprint(response) 12475 >>> 12476 >>> thread = api.update_documents(account_id, envelope_id, callback=callback_function) 12477 12478 :param callback function: The callback function 12479 for asynchronous request. (optional) 12480 :param str account_id: The external account number (int) or account ID Guid. (required) 12481 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12482 :param EnvelopeDefinition envelope_definition: 12483 :return: EnvelopeDocumentsResult 12484 If the method is called asynchronously, 12485 returns the request thread. 12486 """ 12487 kwargs['_return_http_data_only'] = True 12488 if kwargs.get('callback'): 12489 return self.update_documents_with_http_info(account_id, envelope_id, **kwargs) 12490 else: 12491 (data) = self.update_documents_with_http_info(account_id, envelope_id, **kwargs) 12492 return data 12493 12494 def update_documents_with_http_info(self, account_id, envelope_id, **kwargs): 12495 """ 12496 Adds one or more documents to an existing envelope document. 12497 Adds one or more documents to an existing envelope document. 12498 This method makes a synchronous HTTP request by default. To make an 12499 asynchronous HTTP request, please define a `callback` function 12500 to be invoked when receiving the response. 12501 >>> def callback_function(response): 12502 >>> pprint(response) 12503 >>> 12504 >>> thread = api.update_documents_with_http_info(account_id, envelope_id, callback=callback_function) 12505 12506 :param callback function: The callback function 12507 for asynchronous request. (optional) 12508 :param str account_id: The external account number (int) or account ID Guid. (required) 12509 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12510 :param EnvelopeDefinition envelope_definition: 12511 :return: EnvelopeDocumentsResult 12512 If the method is called asynchronously, 12513 returns the request thread. 12514 """ 12515 12516 all_params = ['account_id', 'envelope_id', 'envelope_definition'] 12517 all_params.append('callback') 12518 all_params.append('_return_http_data_only') 12519 all_params.append('_preload_content') 12520 all_params.append('_request_timeout') 12521 12522 params = locals() 12523 for key, val in iteritems(params['kwargs']): 12524 if key not in all_params: 12525 raise TypeError( 12526 "Got an unexpected keyword argument '%s'" 12527 " to method update_documents" % key 12528 ) 12529 params[key] = val 12530 del params['kwargs'] 12531 # verify the required parameter 'account_id' is set 12532 if ('account_id' not in params) or (params['account_id'] is None): 12533 raise ValueError("Missing the required parameter `account_id` when calling `update_documents`") 12534 # verify the required parameter 'envelope_id' is set 12535 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12536 raise ValueError("Missing the required parameter `envelope_id` when calling `update_documents`") 12537 12538 12539 collection_formats = {} 12540 12541 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents'.replace('{format}', 'json') 12542 path_params = {} 12543 if 'account_id' in params: 12544 path_params['accountId'] = params['account_id'] 12545 if 'envelope_id' in params: 12546 path_params['envelopeId'] = params['envelope_id'] 12547 12548 query_params = {} 12549 12550 header_params = {} 12551 12552 form_params = [] 12553 local_var_files = {} 12554 12555 body_params = None 12556 if 'envelope_definition' in params: 12557 body_params = params['envelope_definition'] 12558 # HTTP header `Accept` 12559 header_params['Accept'] = self.api_client.\ 12560 select_header_accept(['application/json']) 12561 12562 # Authentication setting 12563 auth_settings = [] 12564 12565 return self.api_client.call_api(resource_path, 'PUT', 12566 path_params, 12567 query_params, 12568 header_params, 12569 body=body_params, 12570 post_params=form_params, 12571 files=local_var_files, 12572 response_type='EnvelopeDocumentsResult', 12573 auth_settings=auth_settings, 12574 callback=params.get('callback'), 12575 _return_http_data_only=params.get('_return_http_data_only'), 12576 _preload_content=params.get('_preload_content', True), 12577 _request_timeout=params.get('_request_timeout'), 12578 collection_formats=collection_formats) 12579 12580 def update_email_settings(self, account_id, envelope_id, **kwargs): 12581 """ 12582 Updates the email setting overrides for an envelope. 12583 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. 12584 This method makes a synchronous HTTP request by default. To make an 12585 asynchronous HTTP request, please define a `callback` function 12586 to be invoked when receiving the response. 12587 >>> def callback_function(response): 12588 >>> pprint(response) 12589 >>> 12590 >>> thread = api.update_email_settings(account_id, envelope_id, callback=callback_function) 12591 12592 :param callback function: The callback function 12593 for asynchronous request. (optional) 12594 :param str account_id: The external account number (int) or account ID Guid. (required) 12595 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12596 :param EmailSettings email_settings: 12597 :return: EmailSettings 12598 If the method is called asynchronously, 12599 returns the request thread. 12600 """ 12601 kwargs['_return_http_data_only'] = True 12602 if kwargs.get('callback'): 12603 return self.update_email_settings_with_http_info(account_id, envelope_id, **kwargs) 12604 else: 12605 (data) = self.update_email_settings_with_http_info(account_id, envelope_id, **kwargs) 12606 return data 12607 12608 def update_email_settings_with_http_info(self, account_id, envelope_id, **kwargs): 12609 """ 12610 Updates the email setting overrides for an envelope. 12611 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. 12612 This method makes a synchronous HTTP request by default. To make an 12613 asynchronous HTTP request, please define a `callback` function 12614 to be invoked when receiving the response. 12615 >>> def callback_function(response): 12616 >>> pprint(response) 12617 >>> 12618 >>> thread = api.update_email_settings_with_http_info(account_id, envelope_id, callback=callback_function) 12619 12620 :param callback function: The callback function 12621 for asynchronous request. (optional) 12622 :param str account_id: The external account number (int) or account ID Guid. (required) 12623 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12624 :param EmailSettings email_settings: 12625 :return: EmailSettings 12626 If the method is called asynchronously, 12627 returns the request thread. 12628 """ 12629 12630 all_params = ['account_id', 'envelope_id', 'email_settings'] 12631 all_params.append('callback') 12632 all_params.append('_return_http_data_only') 12633 all_params.append('_preload_content') 12634 all_params.append('_request_timeout') 12635 12636 params = locals() 12637 for key, val in iteritems(params['kwargs']): 12638 if key not in all_params: 12639 raise TypeError( 12640 "Got an unexpected keyword argument '%s'" 12641 " to method update_email_settings" % key 12642 ) 12643 params[key] = val 12644 del params['kwargs'] 12645 # verify the required parameter 'account_id' is set 12646 if ('account_id' not in params) or (params['account_id'] is None): 12647 raise ValueError("Missing the required parameter `account_id` when calling `update_email_settings`") 12648 # verify the required parameter 'envelope_id' is set 12649 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12650 raise ValueError("Missing the required parameter `envelope_id` when calling `update_email_settings`") 12651 12652 12653 collection_formats = {} 12654 12655 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/email_settings'.replace('{format}', 'json') 12656 path_params = {} 12657 if 'account_id' in params: 12658 path_params['accountId'] = params['account_id'] 12659 if 'envelope_id' in params: 12660 path_params['envelopeId'] = params['envelope_id'] 12661 12662 query_params = {} 12663 12664 header_params = {} 12665 12666 form_params = [] 12667 local_var_files = {} 12668 12669 body_params = None 12670 if 'email_settings' in params: 12671 body_params = params['email_settings'] 12672 # HTTP header `Accept` 12673 header_params['Accept'] = self.api_client.\ 12674 select_header_accept(['application/json']) 12675 12676 # Authentication setting 12677 auth_settings = [] 12678 12679 return self.api_client.call_api(resource_path, 'PUT', 12680 path_params, 12681 query_params, 12682 header_params, 12683 body=body_params, 12684 post_params=form_params, 12685 files=local_var_files, 12686 response_type='EmailSettings', 12687 auth_settings=auth_settings, 12688 callback=params.get('callback'), 12689 _return_http_data_only=params.get('_return_http_data_only'), 12690 _preload_content=params.get('_preload_content', True), 12691 _request_timeout=params.get('_request_timeout'), 12692 collection_formats=collection_formats) 12693 12694 def update_envelope_delayed_routing_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 12695 """ 12696 Updates the delayed routing rules for an envelope's workflow step definition. 12697 This method makes a synchronous HTTP request by default. To make an 12698 asynchronous HTTP request, please define a `callback` function 12699 to be invoked when receiving the response. 12700 >>> def callback_function(response): 12701 >>> pprint(response) 12702 >>> 12703 >>> thread = api.update_envelope_delayed_routing_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 12704 12705 :param callback function: The callback function 12706 for asynchronous request. (optional) 12707 :param str account_id: The external account number (int) or account ID Guid. (required) 12708 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12709 :param str workflow_step_id: (required) 12710 :param DelayedRouting delayed_routing: 12711 :return: DelayedRouting 12712 If the method is called asynchronously, 12713 returns the request thread. 12714 """ 12715 kwargs['_return_http_data_only'] = True 12716 if kwargs.get('callback'): 12717 return self.update_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 12718 else: 12719 (data) = self.update_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 12720 return data 12721 12722 def update_envelope_delayed_routing_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 12723 """ 12724 Updates the delayed routing rules for an envelope's workflow step definition. 12725 This method makes a synchronous HTTP request by default. To make an 12726 asynchronous HTTP request, please define a `callback` function 12727 to be invoked when receiving the response. 12728 >>> def callback_function(response): 12729 >>> pprint(response) 12730 >>> 12731 >>> thread = api.update_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 12732 12733 :param callback function: The callback function 12734 for asynchronous request. (optional) 12735 :param str account_id: The external account number (int) or account ID Guid. (required) 12736 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12737 :param str workflow_step_id: (required) 12738 :param DelayedRouting delayed_routing: 12739 :return: DelayedRouting 12740 If the method is called asynchronously, 12741 returns the request thread. 12742 """ 12743 12744 all_params = ['account_id', 'envelope_id', 'workflow_step_id', 'delayed_routing'] 12745 all_params.append('callback') 12746 all_params.append('_return_http_data_only') 12747 all_params.append('_preload_content') 12748 all_params.append('_request_timeout') 12749 12750 params = locals() 12751 for key, val in iteritems(params['kwargs']): 12752 if key not in all_params: 12753 raise TypeError( 12754 "Got an unexpected keyword argument '%s'" 12755 " to method update_envelope_delayed_routing_definition" % key 12756 ) 12757 params[key] = val 12758 del params['kwargs'] 12759 # verify the required parameter 'account_id' is set 12760 if ('account_id' not in params) or (params['account_id'] is None): 12761 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_delayed_routing_definition`") 12762 # verify the required parameter 'envelope_id' is set 12763 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12764 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_delayed_routing_definition`") 12765 # verify the required parameter 'workflow_step_id' is set 12766 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 12767 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_envelope_delayed_routing_definition`") 12768 12769 12770 collection_formats = {} 12771 12772 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 12773 path_params = {} 12774 if 'account_id' in params: 12775 path_params['accountId'] = params['account_id'] 12776 if 'envelope_id' in params: 12777 path_params['envelopeId'] = params['envelope_id'] 12778 if 'workflow_step_id' in params: 12779 path_params['workflowStepId'] = params['workflow_step_id'] 12780 12781 query_params = {} 12782 12783 header_params = {} 12784 12785 form_params = [] 12786 local_var_files = {} 12787 12788 body_params = None 12789 if 'delayed_routing' in params: 12790 body_params = params['delayed_routing'] 12791 # HTTP header `Accept` 12792 header_params['Accept'] = self.api_client.\ 12793 select_header_accept(['application/json']) 12794 12795 # Authentication setting 12796 auth_settings = [] 12797 12798 return self.api_client.call_api(resource_path, 'PUT', 12799 path_params, 12800 query_params, 12801 header_params, 12802 body=body_params, 12803 post_params=form_params, 12804 files=local_var_files, 12805 response_type='DelayedRouting', 12806 auth_settings=auth_settings, 12807 callback=params.get('callback'), 12808 _return_http_data_only=params.get('_return_http_data_only'), 12809 _preload_content=params.get('_preload_content', True), 12810 _request_timeout=params.get('_request_timeout'), 12811 collection_formats=collection_formats) 12812 12813 def update_envelope_doc_gen_form_fields(self, account_id, envelope_id, **kwargs): 12814 """ 12815 Updates formfields for an envelope 12816 This method makes a synchronous HTTP request by default. To make an 12817 asynchronous HTTP request, please define a `callback` function 12818 to be invoked when receiving the response. 12819 >>> def callback_function(response): 12820 >>> pprint(response) 12821 >>> 12822 >>> thread = api.update_envelope_doc_gen_form_fields(account_id, envelope_id, callback=callback_function) 12823 12824 :param callback function: The callback function 12825 for asynchronous request. (optional) 12826 :param str account_id: The external account number (int) or account ID Guid. (required) 12827 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12828 :param str update_docgen_formfields_only: 12829 :param DocGenFormFieldRequest doc_gen_form_field_request: 12830 :return: DocGenFormFieldResponse 12831 If the method is called asynchronously, 12832 returns the request thread. 12833 """ 12834 kwargs['_return_http_data_only'] = True 12835 if kwargs.get('callback'): 12836 return self.update_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, **kwargs) 12837 else: 12838 (data) = self.update_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, **kwargs) 12839 return data 12840 12841 def update_envelope_doc_gen_form_fields_with_http_info(self, account_id, envelope_id, **kwargs): 12842 """ 12843 Updates formfields for an envelope 12844 This method makes a synchronous HTTP request by default. To make an 12845 asynchronous HTTP request, please define a `callback` function 12846 to be invoked when receiving the response. 12847 >>> def callback_function(response): 12848 >>> pprint(response) 12849 >>> 12850 >>> thread = api.update_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, callback=callback_function) 12851 12852 :param callback function: The callback function 12853 for asynchronous request. (optional) 12854 :param str account_id: The external account number (int) or account ID Guid. (required) 12855 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12856 :param str update_docgen_formfields_only: 12857 :param DocGenFormFieldRequest doc_gen_form_field_request: 12858 :return: DocGenFormFieldResponse 12859 If the method is called asynchronously, 12860 returns the request thread. 12861 """ 12862 12863 all_params = ['account_id', 'envelope_id', 'update_docgen_formfields_only', 'doc_gen_form_field_request'] 12864 all_params.append('callback') 12865 all_params.append('_return_http_data_only') 12866 all_params.append('_preload_content') 12867 all_params.append('_request_timeout') 12868 12869 params = locals() 12870 for key, val in iteritems(params['kwargs']): 12871 if key not in all_params: 12872 raise TypeError( 12873 "Got an unexpected keyword argument '%s'" 12874 " to method update_envelope_doc_gen_form_fields" % key 12875 ) 12876 params[key] = val 12877 del params['kwargs'] 12878 # verify the required parameter 'account_id' is set 12879 if ('account_id' not in params) or (params['account_id'] is None): 12880 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_doc_gen_form_fields`") 12881 # verify the required parameter 'envelope_id' is set 12882 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12883 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_doc_gen_form_fields`") 12884 12885 12886 collection_formats = {} 12887 12888 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/docGenFormFields'.replace('{format}', 'json') 12889 path_params = {} 12890 if 'account_id' in params: 12891 path_params['accountId'] = params['account_id'] 12892 if 'envelope_id' in params: 12893 path_params['envelopeId'] = params['envelope_id'] 12894 12895 query_params = {} 12896 if 'update_docgen_formfields_only' in params: 12897 query_params['update_docgen_formfields_only'] = params['update_docgen_formfields_only'] 12898 12899 header_params = {} 12900 12901 form_params = [] 12902 local_var_files = {} 12903 12904 body_params = None 12905 if 'doc_gen_form_field_request' in params: 12906 body_params = params['doc_gen_form_field_request'] 12907 # HTTP header `Accept` 12908 header_params['Accept'] = self.api_client.\ 12909 select_header_accept(['application/json']) 12910 12911 # Authentication setting 12912 auth_settings = [] 12913 12914 return self.api_client.call_api(resource_path, 'PUT', 12915 path_params, 12916 query_params, 12917 header_params, 12918 body=body_params, 12919 post_params=form_params, 12920 files=local_var_files, 12921 response_type='DocGenFormFieldResponse', 12922 auth_settings=auth_settings, 12923 callback=params.get('callback'), 12924 _return_http_data_only=params.get('_return_http_data_only'), 12925 _preload_content=params.get('_preload_content', True), 12926 _request_timeout=params.get('_request_timeout'), 12927 collection_formats=collection_formats) 12928 12929 def update_envelope_scheduled_sending_definition(self, account_id, envelope_id, **kwargs): 12930 """ 12931 Updates the scheduled sending rules for an envelope's workflow definition. 12932 This method makes a synchronous HTTP request by default. To make an 12933 asynchronous HTTP request, please define a `callback` function 12934 to be invoked when receiving the response. 12935 >>> def callback_function(response): 12936 >>> pprint(response) 12937 >>> 12938 >>> thread = api.update_envelope_scheduled_sending_definition(account_id, envelope_id, callback=callback_function) 12939 12940 :param callback function: The callback function 12941 for asynchronous request. (optional) 12942 :param str account_id: The external account number (int) or account ID Guid. (required) 12943 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12944 :param ScheduledSending scheduled_sending: 12945 :return: ScheduledSending 12946 If the method is called asynchronously, 12947 returns the request thread. 12948 """ 12949 kwargs['_return_http_data_only'] = True 12950 if kwargs.get('callback'): 12951 return self.update_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 12952 else: 12953 (data) = self.update_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 12954 return data 12955 12956 def update_envelope_scheduled_sending_definition_with_http_info(self, account_id, envelope_id, **kwargs): 12957 """ 12958 Updates the scheduled sending rules for an envelope's workflow definition. 12959 This method makes a synchronous HTTP request by default. To make an 12960 asynchronous HTTP request, please define a `callback` function 12961 to be invoked when receiving the response. 12962 >>> def callback_function(response): 12963 >>> pprint(response) 12964 >>> 12965 >>> thread = api.update_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, callback=callback_function) 12966 12967 :param callback function: The callback function 12968 for asynchronous request. (optional) 12969 :param str account_id: The external account number (int) or account ID Guid. (required) 12970 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12971 :param ScheduledSending scheduled_sending: 12972 :return: ScheduledSending 12973 If the method is called asynchronously, 12974 returns the request thread. 12975 """ 12976 12977 all_params = ['account_id', 'envelope_id', 'scheduled_sending'] 12978 all_params.append('callback') 12979 all_params.append('_return_http_data_only') 12980 all_params.append('_preload_content') 12981 all_params.append('_request_timeout') 12982 12983 params = locals() 12984 for key, val in iteritems(params['kwargs']): 12985 if key not in all_params: 12986 raise TypeError( 12987 "Got an unexpected keyword argument '%s'" 12988 " to method update_envelope_scheduled_sending_definition" % key 12989 ) 12990 params[key] = val 12991 del params['kwargs'] 12992 # verify the required parameter 'account_id' is set 12993 if ('account_id' not in params) or (params['account_id'] is None): 12994 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_scheduled_sending_definition`") 12995 # verify the required parameter 'envelope_id' is set 12996 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12997 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_scheduled_sending_definition`") 12998 12999 13000 collection_formats = {} 13001 13002 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/scheduledSending'.replace('{format}', 'json') 13003 path_params = {} 13004 if 'account_id' in params: 13005 path_params['accountId'] = params['account_id'] 13006 if 'envelope_id' in params: 13007 path_params['envelopeId'] = params['envelope_id'] 13008 13009 query_params = {} 13010 13011 header_params = {} 13012 13013 form_params = [] 13014 local_var_files = {} 13015 13016 body_params = None 13017 if 'scheduled_sending' in params: 13018 body_params = params['scheduled_sending'] 13019 # HTTP header `Accept` 13020 header_params['Accept'] = self.api_client.\ 13021 select_header_accept(['application/json']) 13022 13023 # Authentication setting 13024 auth_settings = [] 13025 13026 return self.api_client.call_api(resource_path, 'PUT', 13027 path_params, 13028 query_params, 13029 header_params, 13030 body=body_params, 13031 post_params=form_params, 13032 files=local_var_files, 13033 response_type='ScheduledSending', 13034 auth_settings=auth_settings, 13035 callback=params.get('callback'), 13036 _return_http_data_only=params.get('_return_http_data_only'), 13037 _preload_content=params.get('_preload_content', True), 13038 _request_timeout=params.get('_request_timeout'), 13039 collection_formats=collection_formats) 13040 13041 def update_envelope_transfer_rule(self, account_id, envelope_transfer_rule_id, **kwargs): 13042 """ 13043 Update an envelope transfer rule for an account. 13044 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. 13045 This method makes a synchronous HTTP request by default. To make an 13046 asynchronous HTTP request, please define a `callback` function 13047 to be invoked when receiving the response. 13048 >>> def callback_function(response): 13049 >>> pprint(response) 13050 >>> 13051 >>> thread = api.update_envelope_transfer_rule(account_id, envelope_transfer_rule_id, callback=callback_function) 13052 13053 :param callback function: The callback function 13054 for asynchronous request. (optional) 13055 :param str account_id: The external account number (int) or account ID Guid. (required) 13056 :param str envelope_transfer_rule_id: (required) 13057 :param EnvelopeTransferRule envelope_transfer_rule: 13058 :return: EnvelopeTransferRule 13059 If the method is called asynchronously, 13060 returns the request thread. 13061 """ 13062 kwargs['_return_http_data_only'] = True 13063 if kwargs.get('callback'): 13064 return self.update_envelope_transfer_rule_with_http_info(account_id, envelope_transfer_rule_id, **kwargs) 13065 else: 13066 (data) = self.update_envelope_transfer_rule_with_http_info(account_id, envelope_transfer_rule_id, **kwargs) 13067 return data 13068 13069 def update_envelope_transfer_rule_with_http_info(self, account_id, envelope_transfer_rule_id, **kwargs): 13070 """ 13071 Update an envelope transfer rule for an account. 13072 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. 13073 This method makes a synchronous HTTP request by default. To make an 13074 asynchronous HTTP request, please define a `callback` function 13075 to be invoked when receiving the response. 13076 >>> def callback_function(response): 13077 >>> pprint(response) 13078 >>> 13079 >>> thread = api.update_envelope_transfer_rule_with_http_info(account_id, envelope_transfer_rule_id, callback=callback_function) 13080 13081 :param callback function: The callback function 13082 for asynchronous request. (optional) 13083 :param str account_id: The external account number (int) or account ID Guid. (required) 13084 :param str envelope_transfer_rule_id: (required) 13085 :param EnvelopeTransferRule envelope_transfer_rule: 13086 :return: EnvelopeTransferRule 13087 If the method is called asynchronously, 13088 returns the request thread. 13089 """ 13090 13091 all_params = ['account_id', 'envelope_transfer_rule_id', 'envelope_transfer_rule'] 13092 all_params.append('callback') 13093 all_params.append('_return_http_data_only') 13094 all_params.append('_preload_content') 13095 all_params.append('_request_timeout') 13096 13097 params = locals() 13098 for key, val in iteritems(params['kwargs']): 13099 if key not in all_params: 13100 raise TypeError( 13101 "Got an unexpected keyword argument '%s'" 13102 " to method update_envelope_transfer_rule" % key 13103 ) 13104 params[key] = val 13105 del params['kwargs'] 13106 # verify the required parameter 'account_id' is set 13107 if ('account_id' not in params) or (params['account_id'] is None): 13108 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_transfer_rule`") 13109 # verify the required parameter 'envelope_transfer_rule_id' is set 13110 if ('envelope_transfer_rule_id' not in params) or (params['envelope_transfer_rule_id'] is None): 13111 raise ValueError("Missing the required parameter `envelope_transfer_rule_id` when calling `update_envelope_transfer_rule`") 13112 13113 13114 collection_formats = {} 13115 13116 resource_path = '/v2.1/accounts/{accountId}/envelopes/transfer_rules/{envelopeTransferRuleId}'.replace('{format}', 'json') 13117 path_params = {} 13118 if 'account_id' in params: 13119 path_params['accountId'] = params['account_id'] 13120 if 'envelope_transfer_rule_id' in params: 13121 path_params['envelopeTransferRuleId'] = params['envelope_transfer_rule_id'] 13122 13123 query_params = {} 13124 13125 header_params = {} 13126 13127 form_params = [] 13128 local_var_files = {} 13129 13130 body_params = None 13131 if 'envelope_transfer_rule' in params: 13132 body_params = params['envelope_transfer_rule'] 13133 # HTTP header `Accept` 13134 header_params['Accept'] = self.api_client.\ 13135 select_header_accept(['application/json']) 13136 13137 # Authentication setting 13138 auth_settings = [] 13139 13140 return self.api_client.call_api(resource_path, 'PUT', 13141 path_params, 13142 query_params, 13143 header_params, 13144 body=body_params, 13145 post_params=form_params, 13146 files=local_var_files, 13147 response_type='EnvelopeTransferRule', 13148 auth_settings=auth_settings, 13149 callback=params.get('callback'), 13150 _return_http_data_only=params.get('_return_http_data_only'), 13151 _preload_content=params.get('_preload_content', True), 13152 _request_timeout=params.get('_request_timeout'), 13153 collection_formats=collection_formats) 13154 13155 def update_envelope_transfer_rules(self, account_id, **kwargs): 13156 """ 13157 Update envelope transfer rules for an account. 13158 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. 13159 This method makes a synchronous HTTP request by default. To make an 13160 asynchronous HTTP request, please define a `callback` function 13161 to be invoked when receiving the response. 13162 >>> def callback_function(response): 13163 >>> pprint(response) 13164 >>> 13165 >>> thread = api.update_envelope_transfer_rules(account_id, callback=callback_function) 13166 13167 :param callback function: The callback function 13168 for asynchronous request. (optional) 13169 :param str account_id: The external account number (int) or account ID Guid. (required) 13170 :param EnvelopeTransferRuleInformation envelope_transfer_rule_information: 13171 :return: EnvelopeTransferRuleInformation 13172 If the method is called asynchronously, 13173 returns the request thread. 13174 """ 13175 kwargs['_return_http_data_only'] = True 13176 if kwargs.get('callback'): 13177 return self.update_envelope_transfer_rules_with_http_info(account_id, **kwargs) 13178 else: 13179 (data) = self.update_envelope_transfer_rules_with_http_info(account_id, **kwargs) 13180 return data 13181 13182 def update_envelope_transfer_rules_with_http_info(self, account_id, **kwargs): 13183 """ 13184 Update envelope transfer rules for an account. 13185 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. 13186 This method makes a synchronous HTTP request by default. To make an 13187 asynchronous HTTP request, please define a `callback` function 13188 to be invoked when receiving the response. 13189 >>> def callback_function(response): 13190 >>> pprint(response) 13191 >>> 13192 >>> thread = api.update_envelope_transfer_rules_with_http_info(account_id, callback=callback_function) 13193 13194 :param callback function: The callback function 13195 for asynchronous request. (optional) 13196 :param str account_id: The external account number (int) or account ID Guid. (required) 13197 :param EnvelopeTransferRuleInformation envelope_transfer_rule_information: 13198 :return: EnvelopeTransferRuleInformation 13199 If the method is called asynchronously, 13200 returns the request thread. 13201 """ 13202 13203 all_params = ['account_id', 'envelope_transfer_rule_information'] 13204 all_params.append('callback') 13205 all_params.append('_return_http_data_only') 13206 all_params.append('_preload_content') 13207 all_params.append('_request_timeout') 13208 13209 params = locals() 13210 for key, val in iteritems(params['kwargs']): 13211 if key not in all_params: 13212 raise TypeError( 13213 "Got an unexpected keyword argument '%s'" 13214 " to method update_envelope_transfer_rules" % key 13215 ) 13216 params[key] = val 13217 del params['kwargs'] 13218 # verify the required parameter 'account_id' is set 13219 if ('account_id' not in params) or (params['account_id'] is None): 13220 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_transfer_rules`") 13221 13222 13223 collection_formats = {} 13224 13225 resource_path = '/v2.1/accounts/{accountId}/envelopes/transfer_rules'.replace('{format}', 'json') 13226 path_params = {} 13227 if 'account_id' in params: 13228 path_params['accountId'] = params['account_id'] 13229 13230 query_params = {} 13231 13232 header_params = {} 13233 13234 form_params = [] 13235 local_var_files = {} 13236 13237 body_params = None 13238 if 'envelope_transfer_rule_information' in params: 13239 body_params = params['envelope_transfer_rule_information'] 13240 # HTTP header `Accept` 13241 header_params['Accept'] = self.api_client.\ 13242 select_header_accept(['application/json']) 13243 13244 # Authentication setting 13245 auth_settings = [] 13246 13247 return self.api_client.call_api(resource_path, 'PUT', 13248 path_params, 13249 query_params, 13250 header_params, 13251 body=body_params, 13252 post_params=form_params, 13253 files=local_var_files, 13254 response_type='EnvelopeTransferRuleInformation', 13255 auth_settings=auth_settings, 13256 callback=params.get('callback'), 13257 _return_http_data_only=params.get('_return_http_data_only'), 13258 _preload_content=params.get('_preload_content', True), 13259 _request_timeout=params.get('_request_timeout'), 13260 collection_formats=collection_formats) 13261 13262 def update_envelope_workflow_definition(self, account_id, envelope_id, **kwargs): 13263 """ 13264 Updates the envelope workflow definition for an envelope. 13265 Updates the specified envelope's workflow definition if it has one. 13266 This method makes a synchronous HTTP request by default. To make an 13267 asynchronous HTTP request, please define a `callback` function 13268 to be invoked when receiving the response. 13269 >>> def callback_function(response): 13270 >>> pprint(response) 13271 >>> 13272 >>> thread = api.update_envelope_workflow_definition(account_id, envelope_id, callback=callback_function) 13273 13274 :param callback function: The callback function 13275 for asynchronous request. (optional) 13276 :param str account_id: The external account number (int) or account ID Guid. (required) 13277 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13278 :param Workflow workflow: 13279 :return: Workflow 13280 If the method is called asynchronously, 13281 returns the request thread. 13282 """ 13283 kwargs['_return_http_data_only'] = True 13284 if kwargs.get('callback'): 13285 return self.update_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 13286 else: 13287 (data) = self.update_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 13288 return data 13289 13290 def update_envelope_workflow_definition_with_http_info(self, account_id, envelope_id, **kwargs): 13291 """ 13292 Updates the envelope workflow definition for an envelope. 13293 Updates the specified envelope's workflow definition if it has one. 13294 This method makes a synchronous HTTP request by default. To make an 13295 asynchronous HTTP request, please define a `callback` function 13296 to be invoked when receiving the response. 13297 >>> def callback_function(response): 13298 >>> pprint(response) 13299 >>> 13300 >>> thread = api.update_envelope_workflow_definition_with_http_info(account_id, envelope_id, callback=callback_function) 13301 13302 :param callback function: The callback function 13303 for asynchronous request. (optional) 13304 :param str account_id: The external account number (int) or account ID Guid. (required) 13305 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13306 :param Workflow workflow: 13307 :return: Workflow 13308 If the method is called asynchronously, 13309 returns the request thread. 13310 """ 13311 13312 all_params = ['account_id', 'envelope_id', 'workflow'] 13313 all_params.append('callback') 13314 all_params.append('_return_http_data_only') 13315 all_params.append('_preload_content') 13316 all_params.append('_request_timeout') 13317 13318 params = locals() 13319 for key, val in iteritems(params['kwargs']): 13320 if key not in all_params: 13321 raise TypeError( 13322 "Got an unexpected keyword argument '%s'" 13323 " to method update_envelope_workflow_definition" % key 13324 ) 13325 params[key] = val 13326 del params['kwargs'] 13327 # verify the required parameter 'account_id' is set 13328 if ('account_id' not in params) or (params['account_id'] is None): 13329 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_workflow_definition`") 13330 # verify the required parameter 'envelope_id' is set 13331 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13332 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_workflow_definition`") 13333 13334 13335 collection_formats = {} 13336 13337 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow'.replace('{format}', 'json') 13338 path_params = {} 13339 if 'account_id' in params: 13340 path_params['accountId'] = params['account_id'] 13341 if 'envelope_id' in params: 13342 path_params['envelopeId'] = params['envelope_id'] 13343 13344 query_params = {} 13345 13346 header_params = {} 13347 13348 form_params = [] 13349 local_var_files = {} 13350 13351 body_params = None 13352 if 'workflow' in params: 13353 body_params = params['workflow'] 13354 # HTTP header `Accept` 13355 header_params['Accept'] = self.api_client.\ 13356 select_header_accept(['application/json']) 13357 13358 # Authentication setting 13359 auth_settings = [] 13360 13361 return self.api_client.call_api(resource_path, 'PUT', 13362 path_params, 13363 query_params, 13364 header_params, 13365 body=body_params, 13366 post_params=form_params, 13367 files=local_var_files, 13368 response_type='Workflow', 13369 auth_settings=auth_settings, 13370 callback=params.get('callback'), 13371 _return_http_data_only=params.get('_return_http_data_only'), 13372 _preload_content=params.get('_preload_content', True), 13373 _request_timeout=params.get('_request_timeout'), 13374 collection_formats=collection_formats) 13375 13376 def update_envelope_workflow_step_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 13377 """ 13378 Updates the envelope workflow step definition for an envelope. 13379 This method makes a synchronous HTTP request by default. To make an 13380 asynchronous HTTP request, please define a `callback` function 13381 to be invoked when receiving the response. 13382 >>> def callback_function(response): 13383 >>> pprint(response) 13384 >>> 13385 >>> thread = api.update_envelope_workflow_step_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 13386 13387 :param callback function: The callback function 13388 for asynchronous request. (optional) 13389 :param str account_id: The external account number (int) or account ID Guid. (required) 13390 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13391 :param str workflow_step_id: (required) 13392 :param WorkflowStep workflow_step: 13393 :return: WorkflowStep 13394 If the method is called asynchronously, 13395 returns the request thread. 13396 """ 13397 kwargs['_return_http_data_only'] = True 13398 if kwargs.get('callback'): 13399 return self.update_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 13400 else: 13401 (data) = self.update_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 13402 return data 13403 13404 def update_envelope_workflow_step_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 13405 """ 13406 Updates the envelope workflow step definition for an envelope. 13407 This method makes a synchronous HTTP request by default. To make an 13408 asynchronous HTTP request, please define a `callback` function 13409 to be invoked when receiving the response. 13410 >>> def callback_function(response): 13411 >>> pprint(response) 13412 >>> 13413 >>> thread = api.update_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 13414 13415 :param callback function: The callback function 13416 for asynchronous request. (optional) 13417 :param str account_id: The external account number (int) or account ID Guid. (required) 13418 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13419 :param str workflow_step_id: (required) 13420 :param WorkflowStep workflow_step: 13421 :return: WorkflowStep 13422 If the method is called asynchronously, 13423 returns the request thread. 13424 """ 13425 13426 all_params = ['account_id', 'envelope_id', 'workflow_step_id', 'workflow_step'] 13427 all_params.append('callback') 13428 all_params.append('_return_http_data_only') 13429 all_params.append('_preload_content') 13430 all_params.append('_request_timeout') 13431 13432 params = locals() 13433 for key, val in iteritems(params['kwargs']): 13434 if key not in all_params: 13435 raise TypeError( 13436 "Got an unexpected keyword argument '%s'" 13437 " to method update_envelope_workflow_step_definition" % key 13438 ) 13439 params[key] = val 13440 del params['kwargs'] 13441 # verify the required parameter 'account_id' is set 13442 if ('account_id' not in params) or (params['account_id'] is None): 13443 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_workflow_step_definition`") 13444 # verify the required parameter 'envelope_id' is set 13445 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13446 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_workflow_step_definition`") 13447 # verify the required parameter 'workflow_step_id' is set 13448 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 13449 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_envelope_workflow_step_definition`") 13450 13451 13452 collection_formats = {} 13453 13454 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 13455 path_params = {} 13456 if 'account_id' in params: 13457 path_params['accountId'] = params['account_id'] 13458 if 'envelope_id' in params: 13459 path_params['envelopeId'] = params['envelope_id'] 13460 if 'workflow_step_id' in params: 13461 path_params['workflowStepId'] = params['workflow_step_id'] 13462 13463 query_params = {} 13464 13465 header_params = {} 13466 13467 form_params = [] 13468 local_var_files = {} 13469 13470 body_params = None 13471 if 'workflow_step' in params: 13472 body_params = params['workflow_step'] 13473 # HTTP header `Accept` 13474 header_params['Accept'] = self.api_client.\ 13475 select_header_accept(['application/json']) 13476 13477 # Authentication setting 13478 auth_settings = [] 13479 13480 return self.api_client.call_api(resource_path, 'PUT', 13481 path_params, 13482 query_params, 13483 header_params, 13484 body=body_params, 13485 post_params=form_params, 13486 files=local_var_files, 13487 response_type='WorkflowStep', 13488 auth_settings=auth_settings, 13489 callback=params.get('callback'), 13490 _return_http_data_only=params.get('_return_http_data_only'), 13491 _preload_content=params.get('_preload_content', True), 13492 _request_timeout=params.get('_request_timeout'), 13493 collection_formats=collection_formats) 13494 13495 def update_lock(self, account_id, envelope_id, **kwargs): 13496 """ 13497 Updates an envelope lock. 13498 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. 13499 This method makes a synchronous HTTP request by default. To make an 13500 asynchronous HTTP request, please define a `callback` function 13501 to be invoked when receiving the response. 13502 >>> def callback_function(response): 13503 >>> pprint(response) 13504 >>> 13505 >>> thread = api.update_lock(account_id, envelope_id, callback=callback_function) 13506 13507 :param callback function: The callback function 13508 for asynchronous request. (optional) 13509 :param str account_id: The external account number (int) or account ID Guid. (required) 13510 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13511 :param LockRequest lock_request: 13512 :return: LockInformation 13513 If the method is called asynchronously, 13514 returns the request thread. 13515 """ 13516 kwargs['_return_http_data_only'] = True 13517 if kwargs.get('callback'): 13518 return self.update_lock_with_http_info(account_id, envelope_id, **kwargs) 13519 else: 13520 (data) = self.update_lock_with_http_info(account_id, envelope_id, **kwargs) 13521 return data 13522 13523 def update_lock_with_http_info(self, account_id, envelope_id, **kwargs): 13524 """ 13525 Updates an envelope lock. 13526 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. 13527 This method makes a synchronous HTTP request by default. To make an 13528 asynchronous HTTP request, please define a `callback` function 13529 to be invoked when receiving the response. 13530 >>> def callback_function(response): 13531 >>> pprint(response) 13532 >>> 13533 >>> thread = api.update_lock_with_http_info(account_id, envelope_id, callback=callback_function) 13534 13535 :param callback function: The callback function 13536 for asynchronous request. (optional) 13537 :param str account_id: The external account number (int) or account ID Guid. (required) 13538 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13539 :param LockRequest lock_request: 13540 :return: LockInformation 13541 If the method is called asynchronously, 13542 returns the request thread. 13543 """ 13544 13545 all_params = ['account_id', 'envelope_id', 'lock_request'] 13546 all_params.append('callback') 13547 all_params.append('_return_http_data_only') 13548 all_params.append('_preload_content') 13549 all_params.append('_request_timeout') 13550 13551 params = locals() 13552 for key, val in iteritems(params['kwargs']): 13553 if key not in all_params: 13554 raise TypeError( 13555 "Got an unexpected keyword argument '%s'" 13556 " to method update_lock" % key 13557 ) 13558 params[key] = val 13559 del params['kwargs'] 13560 # verify the required parameter 'account_id' is set 13561 if ('account_id' not in params) or (params['account_id'] is None): 13562 raise ValueError("Missing the required parameter `account_id` when calling `update_lock`") 13563 # verify the required parameter 'envelope_id' is set 13564 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13565 raise ValueError("Missing the required parameter `envelope_id` when calling `update_lock`") 13566 13567 13568 collection_formats = {} 13569 13570 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/lock'.replace('{format}', 'json') 13571 path_params = {} 13572 if 'account_id' in params: 13573 path_params['accountId'] = params['account_id'] 13574 if 'envelope_id' in params: 13575 path_params['envelopeId'] = params['envelope_id'] 13576 13577 query_params = {} 13578 13579 header_params = {} 13580 13581 form_params = [] 13582 local_var_files = {} 13583 13584 body_params = None 13585 if 'lock_request' in params: 13586 body_params = params['lock_request'] 13587 # HTTP header `Accept` 13588 header_params['Accept'] = self.api_client.\ 13589 select_header_accept(['application/json']) 13590 13591 # Authentication setting 13592 auth_settings = [] 13593 13594 return self.api_client.call_api(resource_path, 'PUT', 13595 path_params, 13596 query_params, 13597 header_params, 13598 body=body_params, 13599 post_params=form_params, 13600 files=local_var_files, 13601 response_type='LockInformation', 13602 auth_settings=auth_settings, 13603 callback=params.get('callback'), 13604 _return_http_data_only=params.get('_return_http_data_only'), 13605 _preload_content=params.get('_preload_content', True), 13606 _request_timeout=params.get('_request_timeout'), 13607 collection_formats=collection_formats) 13608 13609 def update_notification_settings(self, account_id, envelope_id, **kwargs): 13610 """ 13611 Sets envelope notification (Reminders/Expirations) structure for an existing envelope. 13612 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. 13613 This method makes a synchronous HTTP request by default. To make an 13614 asynchronous HTTP request, please define a `callback` function 13615 to be invoked when receiving the response. 13616 >>> def callback_function(response): 13617 >>> pprint(response) 13618 >>> 13619 >>> thread = api.update_notification_settings(account_id, envelope_id, callback=callback_function) 13620 13621 :param callback function: The callback function 13622 for asynchronous request. (optional) 13623 :param str account_id: The external account number (int) or account ID Guid. (required) 13624 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13625 :param EnvelopeNotificationRequest envelope_notification_request: 13626 :return: Notification 13627 If the method is called asynchronously, 13628 returns the request thread. 13629 """ 13630 kwargs['_return_http_data_only'] = True 13631 if kwargs.get('callback'): 13632 return self.update_notification_settings_with_http_info(account_id, envelope_id, **kwargs) 13633 else: 13634 (data) = self.update_notification_settings_with_http_info(account_id, envelope_id, **kwargs) 13635 return data 13636 13637 def update_notification_settings_with_http_info(self, account_id, envelope_id, **kwargs): 13638 """ 13639 Sets envelope notification (Reminders/Expirations) structure for an existing envelope. 13640 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. 13641 This method makes a synchronous HTTP request by default. To make an 13642 asynchronous HTTP request, please define a `callback` function 13643 to be invoked when receiving the response. 13644 >>> def callback_function(response): 13645 >>> pprint(response) 13646 >>> 13647 >>> thread = api.update_notification_settings_with_http_info(account_id, envelope_id, callback=callback_function) 13648 13649 :param callback function: The callback function 13650 for asynchronous request. (optional) 13651 :param str account_id: The external account number (int) or account ID Guid. (required) 13652 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13653 :param EnvelopeNotificationRequest envelope_notification_request: 13654 :return: Notification 13655 If the method is called asynchronously, 13656 returns the request thread. 13657 """ 13658 13659 all_params = ['account_id', 'envelope_id', 'envelope_notification_request'] 13660 all_params.append('callback') 13661 all_params.append('_return_http_data_only') 13662 all_params.append('_preload_content') 13663 all_params.append('_request_timeout') 13664 13665 params = locals() 13666 for key, val in iteritems(params['kwargs']): 13667 if key not in all_params: 13668 raise TypeError( 13669 "Got an unexpected keyword argument '%s'" 13670 " to method update_notification_settings" % key 13671 ) 13672 params[key] = val 13673 del params['kwargs'] 13674 # verify the required parameter 'account_id' is set 13675 if ('account_id' not in params) or (params['account_id'] is None): 13676 raise ValueError("Missing the required parameter `account_id` when calling `update_notification_settings`") 13677 # verify the required parameter 'envelope_id' is set 13678 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13679 raise ValueError("Missing the required parameter `envelope_id` when calling `update_notification_settings`") 13680 13681 13682 collection_formats = {} 13683 13684 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/notification'.replace('{format}', 'json') 13685 path_params = {} 13686 if 'account_id' in params: 13687 path_params['accountId'] = params['account_id'] 13688 if 'envelope_id' in params: 13689 path_params['envelopeId'] = params['envelope_id'] 13690 13691 query_params = {} 13692 13693 header_params = {} 13694 13695 form_params = [] 13696 local_var_files = {} 13697 13698 body_params = None 13699 if 'envelope_notification_request' in params: 13700 body_params = params['envelope_notification_request'] 13701 # HTTP header `Accept` 13702 header_params['Accept'] = self.api_client.\ 13703 select_header_accept(['application/json']) 13704 13705 # Authentication setting 13706 auth_settings = [] 13707 13708 return self.api_client.call_api(resource_path, 'PUT', 13709 path_params, 13710 query_params, 13711 header_params, 13712 body=body_params, 13713 post_params=form_params, 13714 files=local_var_files, 13715 response_type='Notification', 13716 auth_settings=auth_settings, 13717 callback=params.get('callback'), 13718 _return_http_data_only=params.get('_return_http_data_only'), 13719 _preload_content=params.get('_preload_content', True), 13720 _request_timeout=params.get('_request_timeout'), 13721 collection_formats=collection_formats) 13722 13723 def update_recipient_document_visibility(self, account_id, envelope_id, recipient_id, **kwargs): 13724 """ 13725 Updates document visibility for the recipients 13726 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. 13727 This method makes a synchronous HTTP request by default. To make an 13728 asynchronous HTTP request, please define a `callback` function 13729 to be invoked when receiving the response. 13730 >>> def callback_function(response): 13731 >>> pprint(response) 13732 >>> 13733 >>> thread = api.update_recipient_document_visibility(account_id, envelope_id, recipient_id, callback=callback_function) 13734 13735 :param callback function: The callback function 13736 for asynchronous request. (optional) 13737 :param str account_id: The external account number (int) or account ID Guid. (required) 13738 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13739 :param str recipient_id: The ID of the recipient being accessed. (required) 13740 :param DocumentVisibilityList document_visibility_list: 13741 :return: DocumentVisibilityList 13742 If the method is called asynchronously, 13743 returns the request thread. 13744 """ 13745 kwargs['_return_http_data_only'] = True 13746 if kwargs.get('callback'): 13747 return self.update_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13748 else: 13749 (data) = self.update_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13750 return data 13751 13752 def update_recipient_document_visibility_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 13753 """ 13754 Updates document visibility for the recipients 13755 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. 13756 This method makes a synchronous HTTP request by default. To make an 13757 asynchronous HTTP request, please define a `callback` function 13758 to be invoked when receiving the response. 13759 >>> def callback_function(response): 13760 >>> pprint(response) 13761 >>> 13762 >>> thread = api.update_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 13763 13764 :param callback function: The callback function 13765 for asynchronous request. (optional) 13766 :param str account_id: The external account number (int) or account ID Guid. (required) 13767 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13768 :param str recipient_id: The ID of the recipient being accessed. (required) 13769 :param DocumentVisibilityList document_visibility_list: 13770 :return: DocumentVisibilityList 13771 If the method is called asynchronously, 13772 returns the request thread. 13773 """ 13774 13775 all_params = ['account_id', 'envelope_id', 'recipient_id', 'document_visibility_list'] 13776 all_params.append('callback') 13777 all_params.append('_return_http_data_only') 13778 all_params.append('_preload_content') 13779 all_params.append('_request_timeout') 13780 13781 params = locals() 13782 for key, val in iteritems(params['kwargs']): 13783 if key not in all_params: 13784 raise TypeError( 13785 "Got an unexpected keyword argument '%s'" 13786 " to method update_recipient_document_visibility" % key 13787 ) 13788 params[key] = val 13789 del params['kwargs'] 13790 # verify the required parameter 'account_id' is set 13791 if ('account_id' not in params) or (params['account_id'] is None): 13792 raise ValueError("Missing the required parameter `account_id` when calling `update_recipient_document_visibility`") 13793 # verify the required parameter 'envelope_id' is set 13794 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13795 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipient_document_visibility`") 13796 # verify the required parameter 'recipient_id' is set 13797 if ('recipient_id' not in params) or (params['recipient_id'] is None): 13798 raise ValueError("Missing the required parameter `recipient_id` when calling `update_recipient_document_visibility`") 13799 13800 13801 collection_formats = {} 13802 13803 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/document_visibility'.replace('{format}', 'json') 13804 path_params = {} 13805 if 'account_id' in params: 13806 path_params['accountId'] = params['account_id'] 13807 if 'envelope_id' in params: 13808 path_params['envelopeId'] = params['envelope_id'] 13809 if 'recipient_id' in params: 13810 path_params['recipientId'] = params['recipient_id'] 13811 13812 query_params = {} 13813 13814 header_params = {} 13815 13816 form_params = [] 13817 local_var_files = {} 13818 13819 body_params = None 13820 if 'document_visibility_list' in params: 13821 body_params = params['document_visibility_list'] 13822 # HTTP header `Accept` 13823 header_params['Accept'] = self.api_client.\ 13824 select_header_accept(['application/json']) 13825 13826 # Authentication setting 13827 auth_settings = [] 13828 13829 return self.api_client.call_api(resource_path, 'PUT', 13830 path_params, 13831 query_params, 13832 header_params, 13833 body=body_params, 13834 post_params=form_params, 13835 files=local_var_files, 13836 response_type='DocumentVisibilityList', 13837 auth_settings=auth_settings, 13838 callback=params.get('callback'), 13839 _return_http_data_only=params.get('_return_http_data_only'), 13840 _preload_content=params.get('_preload_content', True), 13841 _request_timeout=params.get('_request_timeout'), 13842 collection_formats=collection_formats) 13843 13844 def update_recipient_initials_image(self, account_id, envelope_id, recipient_id, **kwargs): 13845 """ 13846 Sets the initials image for an accountless signer. 13847 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**. 13848 This method makes a synchronous HTTP request by default. To make an 13849 asynchronous HTTP request, please define a `callback` function 13850 to be invoked when receiving the response. 13851 >>> def callback_function(response): 13852 >>> pprint(response) 13853 >>> 13854 >>> thread = api.update_recipient_initials_image(account_id, envelope_id, recipient_id, callback=callback_function) 13855 13856 :param callback function: The callback function 13857 for asynchronous request. (optional) 13858 :param str account_id: The external account number (int) or account ID Guid. (required) 13859 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13860 :param str recipient_id: The ID of the recipient being accessed. (required) 13861 :return: None 13862 If the method is called asynchronously, 13863 returns the request thread. 13864 """ 13865 kwargs['_return_http_data_only'] = True 13866 if kwargs.get('callback'): 13867 return self.update_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13868 else: 13869 (data) = self.update_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13870 return data 13871 13872 def update_recipient_initials_image_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 13873 """ 13874 Sets the initials image for an accountless signer. 13875 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**. 13876 This method makes a synchronous HTTP request by default. To make an 13877 asynchronous HTTP request, please define a `callback` function 13878 to be invoked when receiving the response. 13879 >>> def callback_function(response): 13880 >>> pprint(response) 13881 >>> 13882 >>> thread = api.update_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 13883 13884 :param callback function: The callback function 13885 for asynchronous request. (optional) 13886 :param str account_id: The external account number (int) or account ID Guid. (required) 13887 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13888 :param str recipient_id: The ID of the recipient being accessed. (required) 13889 :return: None 13890 If the method is called asynchronously, 13891 returns the request thread. 13892 """ 13893 13894 all_params = ['account_id', 'envelope_id', 'recipient_id'] 13895 all_params.append('callback') 13896 all_params.append('_return_http_data_only') 13897 all_params.append('_preload_content') 13898 all_params.append('_request_timeout') 13899 13900 params = locals() 13901 for key, val in iteritems(params['kwargs']): 13902 if key not in all_params: 13903 raise TypeError( 13904 "Got an unexpected keyword argument '%s'" 13905 " to method update_recipient_initials_image" % key 13906 ) 13907 params[key] = val 13908 del params['kwargs'] 13909 # verify the required parameter 'account_id' is set 13910 if ('account_id' not in params) or (params['account_id'] is None): 13911 raise ValueError("Missing the required parameter `account_id` when calling `update_recipient_initials_image`") 13912 # verify the required parameter 'envelope_id' is set 13913 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13914 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipient_initials_image`") 13915 # verify the required parameter 'recipient_id' is set 13916 if ('recipient_id' not in params) or (params['recipient_id'] is None): 13917 raise ValueError("Missing the required parameter `recipient_id` when calling `update_recipient_initials_image`") 13918 13919 13920 collection_formats = {} 13921 13922 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/initials_image'.replace('{format}', 'json') 13923 path_params = {} 13924 if 'account_id' in params: 13925 path_params['accountId'] = params['account_id'] 13926 if 'envelope_id' in params: 13927 path_params['envelopeId'] = params['envelope_id'] 13928 if 'recipient_id' in params: 13929 path_params['recipientId'] = params['recipient_id'] 13930 13931 query_params = {} 13932 13933 header_params = {} 13934 13935 form_params = [] 13936 local_var_files = {} 13937 13938 body_params = None 13939 # HTTP header `Accept` 13940 header_params['Accept'] = self.api_client.\ 13941 select_header_accept(['application/json']) 13942 13943 # HTTP header `Content-Type` 13944 header_params['Content-Type'] = self.api_client.\ 13945 select_header_content_type(['image/gif']) 13946 13947 # Authentication setting 13948 auth_settings = [] 13949 13950 return self.api_client.call_api(resource_path, 'PUT', 13951 path_params, 13952 query_params, 13953 header_params, 13954 body=body_params, 13955 post_params=form_params, 13956 files=local_var_files, 13957 response_type=None, 13958 auth_settings=auth_settings, 13959 callback=params.get('callback'), 13960 _return_http_data_only=params.get('_return_http_data_only'), 13961 _preload_content=params.get('_preload_content', True), 13962 _request_timeout=params.get('_request_timeout'), 13963 collection_formats=collection_formats) 13964 13965 def update_recipient_signature_image(self, account_id, envelope_id, recipient_id, **kwargs): 13966 """ 13967 Sets the signature image for an accountless signer. 13968 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**. 13969 This method makes a synchronous HTTP request by default. To make an 13970 asynchronous HTTP request, please define a `callback` function 13971 to be invoked when receiving the response. 13972 >>> def callback_function(response): 13973 >>> pprint(response) 13974 >>> 13975 >>> thread = api.update_recipient_signature_image(account_id, envelope_id, recipient_id, callback=callback_function) 13976 13977 :param callback function: The callback function 13978 for asynchronous request. (optional) 13979 :param str account_id: The external account number (int) or account ID Guid. (required) 13980 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13981 :param str recipient_id: The ID of the recipient being accessed. (required) 13982 :return: None 13983 If the method is called asynchronously, 13984 returns the request thread. 13985 """ 13986 kwargs['_return_http_data_only'] = True 13987 if kwargs.get('callback'): 13988 return self.update_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13989 else: 13990 (data) = self.update_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13991 return data 13992 13993 def update_recipient_signature_image_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 13994 """ 13995 Sets the signature image for an accountless signer. 13996 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**. 13997 This method makes a synchronous HTTP request by default. To make an 13998 asynchronous HTTP request, please define a `callback` function 13999 to be invoked when receiving the response. 14000 >>> def callback_function(response): 14001 >>> pprint(response) 14002 >>> 14003 >>> thread = api.update_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 14004 14005 :param callback function: The callback function 14006 for asynchronous request. (optional) 14007 :param str account_id: The external account number (int) or account ID Guid. (required) 14008 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14009 :param str recipient_id: The ID of the recipient being accessed. (required) 14010 :return: None 14011 If the method is called asynchronously, 14012 returns the request thread. 14013 """ 14014 14015 all_params = ['account_id', 'envelope_id', 'recipient_id'] 14016 all_params.append('callback') 14017 all_params.append('_return_http_data_only') 14018 all_params.append('_preload_content') 14019 all_params.append('_request_timeout') 14020 14021 params = locals() 14022 for key, val in iteritems(params['kwargs']): 14023 if key not in all_params: 14024 raise TypeError( 14025 "Got an unexpected keyword argument '%s'" 14026 " to method update_recipient_signature_image" % key 14027 ) 14028 params[key] = val 14029 del params['kwargs'] 14030 # verify the required parameter 'account_id' is set 14031 if ('account_id' not in params) or (params['account_id'] is None): 14032 raise ValueError("Missing the required parameter `account_id` when calling `update_recipient_signature_image`") 14033 # verify the required parameter 'envelope_id' is set 14034 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14035 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipient_signature_image`") 14036 # verify the required parameter 'recipient_id' is set 14037 if ('recipient_id' not in params) or (params['recipient_id'] is None): 14038 raise ValueError("Missing the required parameter `recipient_id` when calling `update_recipient_signature_image`") 14039 14040 14041 collection_formats = {} 14042 14043 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/signature_image'.replace('{format}', 'json') 14044 path_params = {} 14045 if 'account_id' in params: 14046 path_params['accountId'] = params['account_id'] 14047 if 'envelope_id' in params: 14048 path_params['envelopeId'] = params['envelope_id'] 14049 if 'recipient_id' in params: 14050 path_params['recipientId'] = params['recipient_id'] 14051 14052 query_params = {} 14053 14054 header_params = {} 14055 14056 form_params = [] 14057 local_var_files = {} 14058 14059 body_params = None 14060 # HTTP header `Accept` 14061 header_params['Accept'] = self.api_client.\ 14062 select_header_accept(['application/json']) 14063 14064 # HTTP header `Content-Type` 14065 header_params['Content-Type'] = self.api_client.\ 14066 select_header_content_type(['image/gif']) 14067 14068 # Authentication setting 14069 auth_settings = [] 14070 14071 return self.api_client.call_api(resource_path, 'PUT', 14072 path_params, 14073 query_params, 14074 header_params, 14075 body=body_params, 14076 post_params=form_params, 14077 files=local_var_files, 14078 response_type=None, 14079 auth_settings=auth_settings, 14080 callback=params.get('callback'), 14081 _return_http_data_only=params.get('_return_http_data_only'), 14082 _preload_content=params.get('_preload_content', True), 14083 _request_timeout=params.get('_request_timeout'), 14084 collection_formats=collection_formats) 14085 14086 def update_recipients(self, account_id, envelope_id, **kwargs): 14087 """ 14088 Updates recipients in a draft envelope or corrects recipient information for an in process envelope. 14089 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). 14090 This method makes a synchronous HTTP request by default. To make an 14091 asynchronous HTTP request, please define a `callback` function 14092 to be invoked when receiving the response. 14093 >>> def callback_function(response): 14094 >>> pprint(response) 14095 >>> 14096 >>> thread = api.update_recipients(account_id, envelope_id, callback=callback_function) 14097 14098 :param callback function: The callback function 14099 for asynchronous request. (optional) 14100 :param str account_id: The external account number (int) or account ID Guid. (required) 14101 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14102 :param str combine_same_order_recipients: 14103 :param str offline_signing: 14104 :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. 14105 :param Recipients recipients: 14106 :return: RecipientsUpdateSummary 14107 If the method is called asynchronously, 14108 returns the request thread. 14109 """ 14110 kwargs['_return_http_data_only'] = True 14111 if kwargs.get('callback'): 14112 return self.update_recipients_with_http_info(account_id, envelope_id, **kwargs) 14113 else: 14114 (data) = self.update_recipients_with_http_info(account_id, envelope_id, **kwargs) 14115 return data 14116 14117 def update_recipients_with_http_info(self, account_id, envelope_id, **kwargs): 14118 """ 14119 Updates recipients in a draft envelope or corrects recipient information for an in process envelope. 14120 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). 14121 This method makes a synchronous HTTP request by default. To make an 14122 asynchronous HTTP request, please define a `callback` function 14123 to be invoked when receiving the response. 14124 >>> def callback_function(response): 14125 >>> pprint(response) 14126 >>> 14127 >>> thread = api.update_recipients_with_http_info(account_id, envelope_id, callback=callback_function) 14128 14129 :param callback function: The callback function 14130 for asynchronous request. (optional) 14131 :param str account_id: The external account number (int) or account ID Guid. (required) 14132 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14133 :param str combine_same_order_recipients: 14134 :param str offline_signing: 14135 :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. 14136 :param Recipients recipients: 14137 :return: RecipientsUpdateSummary 14138 If the method is called asynchronously, 14139 returns the request thread. 14140 """ 14141 14142 all_params = ['account_id', 'envelope_id', 'combine_same_order_recipients', 'offline_signing', 'resend_envelope', 'recipients'] 14143 all_params.append('callback') 14144 all_params.append('_return_http_data_only') 14145 all_params.append('_preload_content') 14146 all_params.append('_request_timeout') 14147 14148 params = locals() 14149 for key, val in iteritems(params['kwargs']): 14150 if key not in all_params: 14151 raise TypeError( 14152 "Got an unexpected keyword argument '%s'" 14153 " to method update_recipients" % key 14154 ) 14155 params[key] = val 14156 del params['kwargs'] 14157 # verify the required parameter 'account_id' is set 14158 if ('account_id' not in params) or (params['account_id'] is None): 14159 raise ValueError("Missing the required parameter `account_id` when calling `update_recipients`") 14160 # verify the required parameter 'envelope_id' is set 14161 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14162 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipients`") 14163 14164 14165 collection_formats = {} 14166 14167 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients'.replace('{format}', 'json') 14168 path_params = {} 14169 if 'account_id' in params: 14170 path_params['accountId'] = params['account_id'] 14171 if 'envelope_id' in params: 14172 path_params['envelopeId'] = params['envelope_id'] 14173 14174 query_params = {} 14175 if 'combine_same_order_recipients' in params: 14176 query_params['combine_same_order_recipients'] = params['combine_same_order_recipients'] 14177 if 'offline_signing' in params: 14178 query_params['offline_signing'] = params['offline_signing'] 14179 if 'resend_envelope' in params: 14180 query_params['resend_envelope'] = params['resend_envelope'] 14181 14182 header_params = {} 14183 14184 form_params = [] 14185 local_var_files = {} 14186 14187 body_params = None 14188 if 'recipients' in params: 14189 body_params = params['recipients'] 14190 # HTTP header `Accept` 14191 header_params['Accept'] = self.api_client.\ 14192 select_header_accept(['application/json']) 14193 14194 # Authentication setting 14195 auth_settings = [] 14196 14197 return self.api_client.call_api(resource_path, 'PUT', 14198 path_params, 14199 query_params, 14200 header_params, 14201 body=body_params, 14202 post_params=form_params, 14203 files=local_var_files, 14204 response_type='RecipientsUpdateSummary', 14205 auth_settings=auth_settings, 14206 callback=params.get('callback'), 14207 _return_http_data_only=params.get('_return_http_data_only'), 14208 _preload_content=params.get('_preload_content', True), 14209 _request_timeout=params.get('_request_timeout'), 14210 collection_formats=collection_formats) 14211 14212 def update_recipients_document_visibility(self, account_id, envelope_id, **kwargs): 14213 """ 14214 Updates document visibility for the recipients 14215 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. 14216 This method makes a synchronous HTTP request by default. To make an 14217 asynchronous HTTP request, please define a `callback` function 14218 to be invoked when receiving the response. 14219 >>> def callback_function(response): 14220 >>> pprint(response) 14221 >>> 14222 >>> thread = api.update_recipients_document_visibility(account_id, envelope_id, callback=callback_function) 14223 14224 :param callback function: The callback function 14225 for asynchronous request. (optional) 14226 :param str account_id: The external account number (int) or account ID Guid. (required) 14227 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14228 :param DocumentVisibilityList document_visibility_list: 14229 :return: DocumentVisibilityList 14230 If the method is called asynchronously, 14231 returns the request thread. 14232 """ 14233 kwargs['_return_http_data_only'] = True 14234 if kwargs.get('callback'): 14235 return self.update_recipients_document_visibility_with_http_info(account_id, envelope_id, **kwargs) 14236 else: 14237 (data) = self.update_recipients_document_visibility_with_http_info(account_id, envelope_id, **kwargs) 14238 return data 14239 14240 def update_recipients_document_visibility_with_http_info(self, account_id, envelope_id, **kwargs): 14241 """ 14242 Updates document visibility for the recipients 14243 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. 14244 This method makes a synchronous HTTP request by default. To make an 14245 asynchronous HTTP request, please define a `callback` function 14246 to be invoked when receiving the response. 14247 >>> def callback_function(response): 14248 >>> pprint(response) 14249 >>> 14250 >>> thread = api.update_recipients_document_visibility_with_http_info(account_id, envelope_id, callback=callback_function) 14251 14252 :param callback function: The callback function 14253 for asynchronous request. (optional) 14254 :param str account_id: The external account number (int) or account ID Guid. (required) 14255 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14256 :param DocumentVisibilityList document_visibility_list: 14257 :return: DocumentVisibilityList 14258 If the method is called asynchronously, 14259 returns the request thread. 14260 """ 14261 14262 all_params = ['account_id', 'envelope_id', 'document_visibility_list'] 14263 all_params.append('callback') 14264 all_params.append('_return_http_data_only') 14265 all_params.append('_preload_content') 14266 all_params.append('_request_timeout') 14267 14268 params = locals() 14269 for key, val in iteritems(params['kwargs']): 14270 if key not in all_params: 14271 raise TypeError( 14272 "Got an unexpected keyword argument '%s'" 14273 " to method update_recipients_document_visibility" % key 14274 ) 14275 params[key] = val 14276 del params['kwargs'] 14277 # verify the required parameter 'account_id' is set 14278 if ('account_id' not in params) or (params['account_id'] is None): 14279 raise ValueError("Missing the required parameter `account_id` when calling `update_recipients_document_visibility`") 14280 # verify the required parameter 'envelope_id' is set 14281 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14282 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipients_document_visibility`") 14283 14284 14285 collection_formats = {} 14286 14287 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/document_visibility'.replace('{format}', 'json') 14288 path_params = {} 14289 if 'account_id' in params: 14290 path_params['accountId'] = params['account_id'] 14291 if 'envelope_id' in params: 14292 path_params['envelopeId'] = params['envelope_id'] 14293 14294 query_params = {} 14295 14296 header_params = {} 14297 14298 form_params = [] 14299 local_var_files = {} 14300 14301 body_params = None 14302 if 'document_visibility_list' in params: 14303 body_params = params['document_visibility_list'] 14304 # HTTP header `Accept` 14305 header_params['Accept'] = self.api_client.\ 14306 select_header_accept(['application/json']) 14307 14308 # Authentication setting 14309 auth_settings = [] 14310 14311 return self.api_client.call_api(resource_path, 'PUT', 14312 path_params, 14313 query_params, 14314 header_params, 14315 body=body_params, 14316 post_params=form_params, 14317 files=local_var_files, 14318 response_type='DocumentVisibilityList', 14319 auth_settings=auth_settings, 14320 callback=params.get('callback'), 14321 _return_http_data_only=params.get('_return_http_data_only'), 14322 _preload_content=params.get('_preload_content', True), 14323 _request_timeout=params.get('_request_timeout'), 14324 collection_formats=collection_formats) 14325 14326 def update_tabs(self, account_id, envelope_id, recipient_id, **kwargs): 14327 """ 14328 Updates the tabs for a recipient. 14329 Updates one or more tabs for a recipient in a draft envelope. 14330 This method makes a synchronous HTTP request by default. To make an 14331 asynchronous HTTP request, please define a `callback` function 14332 to be invoked when receiving the response. 14333 >>> def callback_function(response): 14334 >>> pprint(response) 14335 >>> 14336 >>> thread = api.update_tabs(account_id, envelope_id, recipient_id, callback=callback_function) 14337 14338 :param callback function: The callback function 14339 for asynchronous request. (optional) 14340 :param str account_id: The external account number (int) or account ID Guid. (required) 14341 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14342 :param str recipient_id: The ID of the recipient being accessed. (required) 14343 :param Tabs tabs: 14344 :return: Tabs 14345 If the method is called asynchronously, 14346 returns the request thread. 14347 """ 14348 kwargs['_return_http_data_only'] = True 14349 if kwargs.get('callback'): 14350 return self.update_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 14351 else: 14352 (data) = self.update_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 14353 return data 14354 14355 def update_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 14356 """ 14357 Updates the tabs for a recipient. 14358 Updates one or more tabs for a recipient in a draft envelope. 14359 This method makes a synchronous HTTP request by default. To make an 14360 asynchronous HTTP request, please define a `callback` function 14361 to be invoked when receiving the response. 14362 >>> def callback_function(response): 14363 >>> pprint(response) 14364 >>> 14365 >>> thread = api.update_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 14366 14367 :param callback function: The callback function 14368 for asynchronous request. (optional) 14369 :param str account_id: The external account number (int) or account ID Guid. (required) 14370 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14371 :param str recipient_id: The ID of the recipient being accessed. (required) 14372 :param Tabs tabs: 14373 :return: Tabs 14374 If the method is called asynchronously, 14375 returns the request thread. 14376 """ 14377 14378 all_params = ['account_id', 'envelope_id', 'recipient_id', 'tabs'] 14379 all_params.append('callback') 14380 all_params.append('_return_http_data_only') 14381 all_params.append('_preload_content') 14382 all_params.append('_request_timeout') 14383 14384 params = locals() 14385 for key, val in iteritems(params['kwargs']): 14386 if key not in all_params: 14387 raise TypeError( 14388 "Got an unexpected keyword argument '%s'" 14389 " to method update_tabs" % key 14390 ) 14391 params[key] = val 14392 del params['kwargs'] 14393 # verify the required parameter 'account_id' is set 14394 if ('account_id' not in params) or (params['account_id'] is None): 14395 raise ValueError("Missing the required parameter `account_id` when calling `update_tabs`") 14396 # verify the required parameter 'envelope_id' is set 14397 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14398 raise ValueError("Missing the required parameter `envelope_id` when calling `update_tabs`") 14399 # verify the required parameter 'recipient_id' is set 14400 if ('recipient_id' not in params) or (params['recipient_id'] is None): 14401 raise ValueError("Missing the required parameter `recipient_id` when calling `update_tabs`") 14402 14403 14404 collection_formats = {} 14405 14406 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/tabs'.replace('{format}', 'json') 14407 path_params = {} 14408 if 'account_id' in params: 14409 path_params['accountId'] = params['account_id'] 14410 if 'envelope_id' in params: 14411 path_params['envelopeId'] = params['envelope_id'] 14412 if 'recipient_id' in params: 14413 path_params['recipientId'] = params['recipient_id'] 14414 14415 query_params = {} 14416 14417 header_params = {} 14418 14419 form_params = [] 14420 local_var_files = {} 14421 14422 body_params = None 14423 if 'tabs' in params: 14424 body_params = params['tabs'] 14425 # HTTP header `Accept` 14426 header_params['Accept'] = self.api_client.\ 14427 select_header_accept(['application/json']) 14428 14429 # Authentication setting 14430 auth_settings = [] 14431 14432 return self.api_client.call_api(resource_path, 'PUT', 14433 path_params, 14434 query_params, 14435 header_params, 14436 body=body_params, 14437 post_params=form_params, 14438 files=local_var_files, 14439 response_type='Tabs', 14440 auth_settings=auth_settings, 14441 callback=params.get('callback'), 14442 _return_http_data_only=params.get('_return_http_data_only'), 14443 _preload_content=params.get('_preload_content', True), 14444 _request_timeout=params.get('_request_timeout'), 14445 collection_formats=collection_formats) 14446 14447 def update_tabs_blob(self, account_id, envelope_id, **kwargs): 14448 """ 14449 Update encrypted tabs for envelope. 14450 14451 This method makes a synchronous HTTP request by default. To make an 14452 asynchronous HTTP request, please define a `callback` function 14453 to be invoked when receiving the response. 14454 >>> def callback_function(response): 14455 >>> pprint(response) 14456 >>> 14457 >>> thread = api.update_tabs_blob(account_id, envelope_id, callback=callback_function) 14458 14459 :param callback function: The callback function 14460 for asynchronous request. (optional) 14461 :param str account_id: The external account number (int) or account ID Guid. (required) 14462 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14463 :return: None 14464 If the method is called asynchronously, 14465 returns the request thread. 14466 """ 14467 kwargs['_return_http_data_only'] = True 14468 if kwargs.get('callback'): 14469 return self.update_tabs_blob_with_http_info(account_id, envelope_id, **kwargs) 14470 else: 14471 (data) = self.update_tabs_blob_with_http_info(account_id, envelope_id, **kwargs) 14472 return data 14473 14474 def update_tabs_blob_with_http_info(self, account_id, envelope_id, **kwargs): 14475 """ 14476 Update encrypted tabs for envelope. 14477 14478 This method makes a synchronous HTTP request by default. To make an 14479 asynchronous HTTP request, please define a `callback` function 14480 to be invoked when receiving the response. 14481 >>> def callback_function(response): 14482 >>> pprint(response) 14483 >>> 14484 >>> thread = api.update_tabs_blob_with_http_info(account_id, envelope_id, callback=callback_function) 14485 14486 :param callback function: The callback function 14487 for asynchronous request. (optional) 14488 :param str account_id: The external account number (int) or account ID Guid. (required) 14489 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14490 :return: None 14491 If the method is called asynchronously, 14492 returns the request thread. 14493 """ 14494 14495 all_params = ['account_id', 'envelope_id'] 14496 all_params.append('callback') 14497 all_params.append('_return_http_data_only') 14498 all_params.append('_preload_content') 14499 all_params.append('_request_timeout') 14500 14501 params = locals() 14502 for key, val in iteritems(params['kwargs']): 14503 if key not in all_params: 14504 raise TypeError( 14505 "Got an unexpected keyword argument '%s'" 14506 " to method update_tabs_blob" % key 14507 ) 14508 params[key] = val 14509 del params['kwargs'] 14510 # verify the required parameter 'account_id' is set 14511 if ('account_id' not in params) or (params['account_id'] is None): 14512 raise ValueError("Missing the required parameter `account_id` when calling `update_tabs_blob`") 14513 # verify the required parameter 'envelope_id' is set 14514 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14515 raise ValueError("Missing the required parameter `envelope_id` when calling `update_tabs_blob`") 14516 14517 14518 collection_formats = {} 14519 14520 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/tabs_blob'.replace('{format}', 'json') 14521 path_params = {} 14522 if 'account_id' in params: 14523 path_params['accountId'] = params['account_id'] 14524 if 'envelope_id' in params: 14525 path_params['envelopeId'] = params['envelope_id'] 14526 14527 query_params = {} 14528 14529 header_params = {} 14530 14531 form_params = [] 14532 local_var_files = {} 14533 14534 body_params = None 14535 # HTTP header `Accept` 14536 header_params['Accept'] = self.api_client.\ 14537 select_header_accept(['application/json']) 14538 14539 # Authentication setting 14540 auth_settings = [] 14541 14542 return self.api_client.call_api(resource_path, 'PUT', 14543 path_params, 14544 query_params, 14545 header_params, 14546 body=body_params, 14547 post_params=form_params, 14548 files=local_var_files, 14549 response_type=None, 14550 auth_settings=auth_settings, 14551 callback=params.get('callback'), 14552 _return_http_data_only=params.get('_return_http_data_only'), 14553 _preload_content=params.get('_preload_content', True), 14554 _request_timeout=params.get('_request_timeout'), 14555 collection_formats=collection_formats) 14556 14557 def update_template_delayed_routing_definition(self, account_id, template_id, workflow_step_id, **kwargs): 14558 """ 14559 Updates the delayed routing rules for a template's workflow step definition. 14560 This method makes a synchronous HTTP request by default. To make an 14561 asynchronous HTTP request, please define a `callback` function 14562 to be invoked when receiving the response. 14563 >>> def callback_function(response): 14564 >>> pprint(response) 14565 >>> 14566 >>> thread = api.update_template_delayed_routing_definition(account_id, template_id, workflow_step_id, callback=callback_function) 14567 14568 :param callback function: The callback function 14569 for asynchronous request. (optional) 14570 :param str account_id: The external account number (int) or account ID Guid. (required) 14571 :param str template_id: The ID of the template being accessed. (required) 14572 :param str workflow_step_id: (required) 14573 :param DelayedRouting delayed_routing: 14574 :return: DelayedRouting 14575 If the method is called asynchronously, 14576 returns the request thread. 14577 """ 14578 kwargs['_return_http_data_only'] = True 14579 if kwargs.get('callback'): 14580 return self.update_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 14581 else: 14582 (data) = self.update_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 14583 return data 14584 14585 def update_template_delayed_routing_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 14586 """ 14587 Updates the delayed routing rules for a template's workflow step definition. 14588 This method makes a synchronous HTTP request by default. To make an 14589 asynchronous HTTP request, please define a `callback` function 14590 to be invoked when receiving the response. 14591 >>> def callback_function(response): 14592 >>> pprint(response) 14593 >>> 14594 >>> thread = api.update_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 14595 14596 :param callback function: The callback function 14597 for asynchronous request. (optional) 14598 :param str account_id: The external account number (int) or account ID Guid. (required) 14599 :param str template_id: The ID of the template being accessed. (required) 14600 :param str workflow_step_id: (required) 14601 :param DelayedRouting delayed_routing: 14602 :return: DelayedRouting 14603 If the method is called asynchronously, 14604 returns the request thread. 14605 """ 14606 14607 all_params = ['account_id', 'template_id', 'workflow_step_id', 'delayed_routing'] 14608 all_params.append('callback') 14609 all_params.append('_return_http_data_only') 14610 all_params.append('_preload_content') 14611 all_params.append('_request_timeout') 14612 14613 params = locals() 14614 for key, val in iteritems(params['kwargs']): 14615 if key not in all_params: 14616 raise TypeError( 14617 "Got an unexpected keyword argument '%s'" 14618 " to method update_template_delayed_routing_definition" % key 14619 ) 14620 params[key] = val 14621 del params['kwargs'] 14622 # verify the required parameter 'account_id' is set 14623 if ('account_id' not in params) or (params['account_id'] is None): 14624 raise ValueError("Missing the required parameter `account_id` when calling `update_template_delayed_routing_definition`") 14625 # verify the required parameter 'template_id' is set 14626 if ('template_id' not in params) or (params['template_id'] is None): 14627 raise ValueError("Missing the required parameter `template_id` when calling `update_template_delayed_routing_definition`") 14628 # verify the required parameter 'workflow_step_id' is set 14629 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 14630 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_template_delayed_routing_definition`") 14631 14632 14633 collection_formats = {} 14634 14635 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 14636 path_params = {} 14637 if 'account_id' in params: 14638 path_params['accountId'] = params['account_id'] 14639 if 'template_id' in params: 14640 path_params['templateId'] = params['template_id'] 14641 if 'workflow_step_id' in params: 14642 path_params['workflowStepId'] = params['workflow_step_id'] 14643 14644 query_params = {} 14645 14646 header_params = {} 14647 14648 form_params = [] 14649 local_var_files = {} 14650 14651 body_params = None 14652 if 'delayed_routing' in params: 14653 body_params = params['delayed_routing'] 14654 # HTTP header `Accept` 14655 header_params['Accept'] = self.api_client.\ 14656 select_header_accept(['application/json']) 14657 14658 # Authentication setting 14659 auth_settings = [] 14660 14661 return self.api_client.call_api(resource_path, 'PUT', 14662 path_params, 14663 query_params, 14664 header_params, 14665 body=body_params, 14666 post_params=form_params, 14667 files=local_var_files, 14668 response_type='DelayedRouting', 14669 auth_settings=auth_settings, 14670 callback=params.get('callback'), 14671 _return_http_data_only=params.get('_return_http_data_only'), 14672 _preload_content=params.get('_preload_content', True), 14673 _request_timeout=params.get('_request_timeout'), 14674 collection_formats=collection_formats) 14675 14676 def update_template_recipient_document_visibility(self, account_id, recipient_id, template_id, **kwargs): 14677 """ 14678 Updates document visibility for the recipients 14679 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. 14680 This method makes a synchronous HTTP request by default. To make an 14681 asynchronous HTTP request, please define a `callback` function 14682 to be invoked when receiving the response. 14683 >>> def callback_function(response): 14684 >>> pprint(response) 14685 >>> 14686 >>> thread = api.update_template_recipient_document_visibility(account_id, recipient_id, template_id, callback=callback_function) 14687 14688 :param callback function: The callback function 14689 for asynchronous request. (optional) 14690 :param str account_id: The external account number (int) or account ID Guid. (required) 14691 :param str recipient_id: The ID of the recipient being accessed. (required) 14692 :param str template_id: The ID of the template being accessed. (required) 14693 :param TemplateDocumentVisibilityList template_document_visibility_list: 14694 :return: TemplateDocumentVisibilityList 14695 If the method is called asynchronously, 14696 returns the request thread. 14697 """ 14698 kwargs['_return_http_data_only'] = True 14699 if kwargs.get('callback'): 14700 return self.update_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, **kwargs) 14701 else: 14702 (data) = self.update_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, **kwargs) 14703 return data 14704 14705 def update_template_recipient_document_visibility_with_http_info(self, account_id, recipient_id, template_id, **kwargs): 14706 """ 14707 Updates document visibility for the recipients 14708 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. 14709 This method makes a synchronous HTTP request by default. To make an 14710 asynchronous HTTP request, please define a `callback` function 14711 to be invoked when receiving the response. 14712 >>> def callback_function(response): 14713 >>> pprint(response) 14714 >>> 14715 >>> thread = api.update_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, callback=callback_function) 14716 14717 :param callback function: The callback function 14718 for asynchronous request. (optional) 14719 :param str account_id: The external account number (int) or account ID Guid. (required) 14720 :param str recipient_id: The ID of the recipient being accessed. (required) 14721 :param str template_id: The ID of the template being accessed. (required) 14722 :param TemplateDocumentVisibilityList template_document_visibility_list: 14723 :return: TemplateDocumentVisibilityList 14724 If the method is called asynchronously, 14725 returns the request thread. 14726 """ 14727 14728 all_params = ['account_id', 'recipient_id', 'template_id', 'template_document_visibility_list'] 14729 all_params.append('callback') 14730 all_params.append('_return_http_data_only') 14731 all_params.append('_preload_content') 14732 all_params.append('_request_timeout') 14733 14734 params = locals() 14735 for key, val in iteritems(params['kwargs']): 14736 if key not in all_params: 14737 raise TypeError( 14738 "Got an unexpected keyword argument '%s'" 14739 " to method update_template_recipient_document_visibility" % key 14740 ) 14741 params[key] = val 14742 del params['kwargs'] 14743 # verify the required parameter 'account_id' is set 14744 if ('account_id' not in params) or (params['account_id'] is None): 14745 raise ValueError("Missing the required parameter `account_id` when calling `update_template_recipient_document_visibility`") 14746 # verify the required parameter 'recipient_id' is set 14747 if ('recipient_id' not in params) or (params['recipient_id'] is None): 14748 raise ValueError("Missing the required parameter `recipient_id` when calling `update_template_recipient_document_visibility`") 14749 # verify the required parameter 'template_id' is set 14750 if ('template_id' not in params) or (params['template_id'] is None): 14751 raise ValueError("Missing the required parameter `template_id` when calling `update_template_recipient_document_visibility`") 14752 14753 14754 collection_formats = {} 14755 14756 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/recipients/{recipientId}/document_visibility'.replace('{format}', 'json') 14757 path_params = {} 14758 if 'account_id' in params: 14759 path_params['accountId'] = params['account_id'] 14760 if 'recipient_id' in params: 14761 path_params['recipientId'] = params['recipient_id'] 14762 if 'template_id' in params: 14763 path_params['templateId'] = params['template_id'] 14764 14765 query_params = {} 14766 14767 header_params = {} 14768 14769 form_params = [] 14770 local_var_files = {} 14771 14772 body_params = None 14773 if 'template_document_visibility_list' in params: 14774 body_params = params['template_document_visibility_list'] 14775 # HTTP header `Accept` 14776 header_params['Accept'] = self.api_client.\ 14777 select_header_accept(['application/json']) 14778 14779 # Authentication setting 14780 auth_settings = [] 14781 14782 return self.api_client.call_api(resource_path, 'PUT', 14783 path_params, 14784 query_params, 14785 header_params, 14786 body=body_params, 14787 post_params=form_params, 14788 files=local_var_files, 14789 response_type='TemplateDocumentVisibilityList', 14790 auth_settings=auth_settings, 14791 callback=params.get('callback'), 14792 _return_http_data_only=params.get('_return_http_data_only'), 14793 _preload_content=params.get('_preload_content', True), 14794 _request_timeout=params.get('_request_timeout'), 14795 collection_formats=collection_formats) 14796 14797 def update_template_recipients_document_visibility(self, account_id, template_id, **kwargs): 14798 """ 14799 Updates document visibility for the recipients 14800 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. 14801 This method makes a synchronous HTTP request by default. To make an 14802 asynchronous HTTP request, please define a `callback` function 14803 to be invoked when receiving the response. 14804 >>> def callback_function(response): 14805 >>> pprint(response) 14806 >>> 14807 >>> thread = api.update_template_recipients_document_visibility(account_id, template_id, callback=callback_function) 14808 14809 :param callback function: The callback function 14810 for asynchronous request. (optional) 14811 :param str account_id: The external account number (int) or account ID Guid. (required) 14812 :param str template_id: The ID of the template being accessed. (required) 14813 :param TemplateDocumentVisibilityList template_document_visibility_list: 14814 :return: TemplateDocumentVisibilityList 14815 If the method is called asynchronously, 14816 returns the request thread. 14817 """ 14818 kwargs['_return_http_data_only'] = True 14819 if kwargs.get('callback'): 14820 return self.update_template_recipients_document_visibility_with_http_info(account_id, template_id, **kwargs) 14821 else: 14822 (data) = self.update_template_recipients_document_visibility_with_http_info(account_id, template_id, **kwargs) 14823 return data 14824 14825 def update_template_recipients_document_visibility_with_http_info(self, account_id, template_id, **kwargs): 14826 """ 14827 Updates document visibility for the recipients 14828 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. 14829 This method makes a synchronous HTTP request by default. To make an 14830 asynchronous HTTP request, please define a `callback` function 14831 to be invoked when receiving the response. 14832 >>> def callback_function(response): 14833 >>> pprint(response) 14834 >>> 14835 >>> thread = api.update_template_recipients_document_visibility_with_http_info(account_id, template_id, callback=callback_function) 14836 14837 :param callback function: The callback function 14838 for asynchronous request. (optional) 14839 :param str account_id: The external account number (int) or account ID Guid. (required) 14840 :param str template_id: The ID of the template being accessed. (required) 14841 :param TemplateDocumentVisibilityList template_document_visibility_list: 14842 :return: TemplateDocumentVisibilityList 14843 If the method is called asynchronously, 14844 returns the request thread. 14845 """ 14846 14847 all_params = ['account_id', 'template_id', 'template_document_visibility_list'] 14848 all_params.append('callback') 14849 all_params.append('_return_http_data_only') 14850 all_params.append('_preload_content') 14851 all_params.append('_request_timeout') 14852 14853 params = locals() 14854 for key, val in iteritems(params['kwargs']): 14855 if key not in all_params: 14856 raise TypeError( 14857 "Got an unexpected keyword argument '%s'" 14858 " to method update_template_recipients_document_visibility" % key 14859 ) 14860 params[key] = val 14861 del params['kwargs'] 14862 # verify the required parameter 'account_id' is set 14863 if ('account_id' not in params) or (params['account_id'] is None): 14864 raise ValueError("Missing the required parameter `account_id` when calling `update_template_recipients_document_visibility`") 14865 # verify the required parameter 'template_id' is set 14866 if ('template_id' not in params) or (params['template_id'] is None): 14867 raise ValueError("Missing the required parameter `template_id` when calling `update_template_recipients_document_visibility`") 14868 14869 14870 collection_formats = {} 14871 14872 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/recipients/document_visibility'.replace('{format}', 'json') 14873 path_params = {} 14874 if 'account_id' in params: 14875 path_params['accountId'] = params['account_id'] 14876 if 'template_id' in params: 14877 path_params['templateId'] = params['template_id'] 14878 14879 query_params = {} 14880 14881 header_params = {} 14882 14883 form_params = [] 14884 local_var_files = {} 14885 14886 body_params = None 14887 if 'template_document_visibility_list' in params: 14888 body_params = params['template_document_visibility_list'] 14889 # HTTP header `Accept` 14890 header_params['Accept'] = self.api_client.\ 14891 select_header_accept(['application/json']) 14892 14893 # Authentication setting 14894 auth_settings = [] 14895 14896 return self.api_client.call_api(resource_path, 'PUT', 14897 path_params, 14898 query_params, 14899 header_params, 14900 body=body_params, 14901 post_params=form_params, 14902 files=local_var_files, 14903 response_type='TemplateDocumentVisibilityList', 14904 auth_settings=auth_settings, 14905 callback=params.get('callback'), 14906 _return_http_data_only=params.get('_return_http_data_only'), 14907 _preload_content=params.get('_preload_content', True), 14908 _request_timeout=params.get('_request_timeout'), 14909 collection_formats=collection_formats) 14910 14911 def update_template_scheduled_sending_definition(self, account_id, template_id, **kwargs): 14912 """ 14913 Updates the scheduled sending rules for a template's workflow definition. 14914 This method makes a synchronous HTTP request by default. To make an 14915 asynchronous HTTP request, please define a `callback` function 14916 to be invoked when receiving the response. 14917 >>> def callback_function(response): 14918 >>> pprint(response) 14919 >>> 14920 >>> thread = api.update_template_scheduled_sending_definition(account_id, template_id, callback=callback_function) 14921 14922 :param callback function: The callback function 14923 for asynchronous request. (optional) 14924 :param str account_id: The external account number (int) or account ID Guid. (required) 14925 :param str template_id: The ID of the template being accessed. (required) 14926 :param ScheduledSending scheduled_sending: 14927 :return: ScheduledSending 14928 If the method is called asynchronously, 14929 returns the request thread. 14930 """ 14931 kwargs['_return_http_data_only'] = True 14932 if kwargs.get('callback'): 14933 return self.update_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 14934 else: 14935 (data) = self.update_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 14936 return data 14937 14938 def update_template_scheduled_sending_definition_with_http_info(self, account_id, template_id, **kwargs): 14939 """ 14940 Updates the scheduled sending rules for a template's workflow definition. 14941 This method makes a synchronous HTTP request by default. To make an 14942 asynchronous HTTP request, please define a `callback` function 14943 to be invoked when receiving the response. 14944 >>> def callback_function(response): 14945 >>> pprint(response) 14946 >>> 14947 >>> thread = api.update_template_scheduled_sending_definition_with_http_info(account_id, template_id, callback=callback_function) 14948 14949 :param callback function: The callback function 14950 for asynchronous request. (optional) 14951 :param str account_id: The external account number (int) or account ID Guid. (required) 14952 :param str template_id: The ID of the template being accessed. (required) 14953 :param ScheduledSending scheduled_sending: 14954 :return: ScheduledSending 14955 If the method is called asynchronously, 14956 returns the request thread. 14957 """ 14958 14959 all_params = ['account_id', 'template_id', 'scheduled_sending'] 14960 all_params.append('callback') 14961 all_params.append('_return_http_data_only') 14962 all_params.append('_preload_content') 14963 all_params.append('_request_timeout') 14964 14965 params = locals() 14966 for key, val in iteritems(params['kwargs']): 14967 if key not in all_params: 14968 raise TypeError( 14969 "Got an unexpected keyword argument '%s'" 14970 " to method update_template_scheduled_sending_definition" % key 14971 ) 14972 params[key] = val 14973 del params['kwargs'] 14974 # verify the required parameter 'account_id' is set 14975 if ('account_id' not in params) or (params['account_id'] is None): 14976 raise ValueError("Missing the required parameter `account_id` when calling `update_template_scheduled_sending_definition`") 14977 # verify the required parameter 'template_id' is set 14978 if ('template_id' not in params) or (params['template_id'] is None): 14979 raise ValueError("Missing the required parameter `template_id` when calling `update_template_scheduled_sending_definition`") 14980 14981 14982 collection_formats = {} 14983 14984 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/scheduledSending'.replace('{format}', 'json') 14985 path_params = {} 14986 if 'account_id' in params: 14987 path_params['accountId'] = params['account_id'] 14988 if 'template_id' in params: 14989 path_params['templateId'] = params['template_id'] 14990 14991 query_params = {} 14992 14993 header_params = {} 14994 14995 form_params = [] 14996 local_var_files = {} 14997 14998 body_params = None 14999 if 'scheduled_sending' in params: 15000 body_params = params['scheduled_sending'] 15001 # HTTP header `Accept` 15002 header_params['Accept'] = self.api_client.\ 15003 select_header_accept(['application/json']) 15004 15005 # Authentication setting 15006 auth_settings = [] 15007 15008 return self.api_client.call_api(resource_path, 'PUT', 15009 path_params, 15010 query_params, 15011 header_params, 15012 body=body_params, 15013 post_params=form_params, 15014 files=local_var_files, 15015 response_type='ScheduledSending', 15016 auth_settings=auth_settings, 15017 callback=params.get('callback'), 15018 _return_http_data_only=params.get('_return_http_data_only'), 15019 _preload_content=params.get('_preload_content', True), 15020 _request_timeout=params.get('_request_timeout'), 15021 collection_formats=collection_formats) 15022 15023 def update_template_workflow_definition(self, account_id, template_id, **kwargs): 15024 """ 15025 Updates the workflow definition for a template. 15026 Updates the specified template's workflow definition if it has one. 15027 This method makes a synchronous HTTP request by default. To make an 15028 asynchronous HTTP request, please define a `callback` function 15029 to be invoked when receiving the response. 15030 >>> def callback_function(response): 15031 >>> pprint(response) 15032 >>> 15033 >>> thread = api.update_template_workflow_definition(account_id, template_id, callback=callback_function) 15034 15035 :param callback function: The callback function 15036 for asynchronous request. (optional) 15037 :param str account_id: The external account number (int) or account ID Guid. (required) 15038 :param str template_id: The ID of the template being accessed. (required) 15039 :param Workflow workflow: 15040 :return: Workflow 15041 If the method is called asynchronously, 15042 returns the request thread. 15043 """ 15044 kwargs['_return_http_data_only'] = True 15045 if kwargs.get('callback'): 15046 return self.update_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 15047 else: 15048 (data) = self.update_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 15049 return data 15050 15051 def update_template_workflow_definition_with_http_info(self, account_id, template_id, **kwargs): 15052 """ 15053 Updates the workflow definition for a template. 15054 Updates the specified template's workflow definition if it has one. 15055 This method makes a synchronous HTTP request by default. To make an 15056 asynchronous HTTP request, please define a `callback` function 15057 to be invoked when receiving the response. 15058 >>> def callback_function(response): 15059 >>> pprint(response) 15060 >>> 15061 >>> thread = api.update_template_workflow_definition_with_http_info(account_id, template_id, callback=callback_function) 15062 15063 :param callback function: The callback function 15064 for asynchronous request. (optional) 15065 :param str account_id: The external account number (int) or account ID Guid. (required) 15066 :param str template_id: The ID of the template being accessed. (required) 15067 :param Workflow workflow: 15068 :return: Workflow 15069 If the method is called asynchronously, 15070 returns the request thread. 15071 """ 15072 15073 all_params = ['account_id', 'template_id', 'workflow'] 15074 all_params.append('callback') 15075 all_params.append('_return_http_data_only') 15076 all_params.append('_preload_content') 15077 all_params.append('_request_timeout') 15078 15079 params = locals() 15080 for key, val in iteritems(params['kwargs']): 15081 if key not in all_params: 15082 raise TypeError( 15083 "Got an unexpected keyword argument '%s'" 15084 " to method update_template_workflow_definition" % key 15085 ) 15086 params[key] = val 15087 del params['kwargs'] 15088 # verify the required parameter 'account_id' is set 15089 if ('account_id' not in params) or (params['account_id'] is None): 15090 raise ValueError("Missing the required parameter `account_id` when calling `update_template_workflow_definition`") 15091 # verify the required parameter 'template_id' is set 15092 if ('template_id' not in params) or (params['template_id'] is None): 15093 raise ValueError("Missing the required parameter `template_id` when calling `update_template_workflow_definition`") 15094 15095 15096 collection_formats = {} 15097 15098 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow'.replace('{format}', 'json') 15099 path_params = {} 15100 if 'account_id' in params: 15101 path_params['accountId'] = params['account_id'] 15102 if 'template_id' in params: 15103 path_params['templateId'] = params['template_id'] 15104 15105 query_params = {} 15106 15107 header_params = {} 15108 15109 form_params = [] 15110 local_var_files = {} 15111 15112 body_params = None 15113 if 'workflow' in params: 15114 body_params = params['workflow'] 15115 # HTTP header `Accept` 15116 header_params['Accept'] = self.api_client.\ 15117 select_header_accept(['application/json']) 15118 15119 # Authentication setting 15120 auth_settings = [] 15121 15122 return self.api_client.call_api(resource_path, 'PUT', 15123 path_params, 15124 query_params, 15125 header_params, 15126 body=body_params, 15127 post_params=form_params, 15128 files=local_var_files, 15129 response_type='Workflow', 15130 auth_settings=auth_settings, 15131 callback=params.get('callback'), 15132 _return_http_data_only=params.get('_return_http_data_only'), 15133 _preload_content=params.get('_preload_content', True), 15134 _request_timeout=params.get('_request_timeout'), 15135 collection_formats=collection_formats) 15136 15137 def update_template_workflow_step_definition(self, account_id, template_id, workflow_step_id, **kwargs): 15138 """ 15139 Updates the template workflow step definition for an envelope. 15140 This method makes a synchronous HTTP request by default. To make an 15141 asynchronous HTTP request, please define a `callback` function 15142 to be invoked when receiving the response. 15143 >>> def callback_function(response): 15144 >>> pprint(response) 15145 >>> 15146 >>> thread = api.update_template_workflow_step_definition(account_id, template_id, workflow_step_id, callback=callback_function) 15147 15148 :param callback function: The callback function 15149 for asynchronous request. (optional) 15150 :param str account_id: The external account number (int) or account ID Guid. (required) 15151 :param str template_id: The ID of the template being accessed. (required) 15152 :param str workflow_step_id: (required) 15153 :param WorkflowStep workflow_step: 15154 :return: WorkflowStep 15155 If the method is called asynchronously, 15156 returns the request thread. 15157 """ 15158 kwargs['_return_http_data_only'] = True 15159 if kwargs.get('callback'): 15160 return self.update_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 15161 else: 15162 (data) = self.update_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 15163 return data 15164 15165 def update_template_workflow_step_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 15166 """ 15167 Updates the template workflow step definition for an envelope. 15168 This method makes a synchronous HTTP request by default. To make an 15169 asynchronous HTTP request, please define a `callback` function 15170 to be invoked when receiving the response. 15171 >>> def callback_function(response): 15172 >>> pprint(response) 15173 >>> 15174 >>> thread = api.update_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 15175 15176 :param callback function: The callback function 15177 for asynchronous request. (optional) 15178 :param str account_id: The external account number (int) or account ID Guid. (required) 15179 :param str template_id: The ID of the template being accessed. (required) 15180 :param str workflow_step_id: (required) 15181 :param WorkflowStep workflow_step: 15182 :return: WorkflowStep 15183 If the method is called asynchronously, 15184 returns the request thread. 15185 """ 15186 15187 all_params = ['account_id', 'template_id', 'workflow_step_id', 'workflow_step'] 15188 all_params.append('callback') 15189 all_params.append('_return_http_data_only') 15190 all_params.append('_preload_content') 15191 all_params.append('_request_timeout') 15192 15193 params = locals() 15194 for key, val in iteritems(params['kwargs']): 15195 if key not in all_params: 15196 raise TypeError( 15197 "Got an unexpected keyword argument '%s'" 15198 " to method update_template_workflow_step_definition" % key 15199 ) 15200 params[key] = val 15201 del params['kwargs'] 15202 # verify the required parameter 'account_id' is set 15203 if ('account_id' not in params) or (params['account_id'] is None): 15204 raise ValueError("Missing the required parameter `account_id` when calling `update_template_workflow_step_definition`") 15205 # verify the required parameter 'template_id' is set 15206 if ('template_id' not in params) or (params['template_id'] is None): 15207 raise ValueError("Missing the required parameter `template_id` when calling `update_template_workflow_step_definition`") 15208 # verify the required parameter 'workflow_step_id' is set 15209 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 15210 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_template_workflow_step_definition`") 15211 15212 15213 collection_formats = {} 15214 15215 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 15216 path_params = {} 15217 if 'account_id' in params: 15218 path_params['accountId'] = params['account_id'] 15219 if 'template_id' in params: 15220 path_params['templateId'] = params['template_id'] 15221 if 'workflow_step_id' in params: 15222 path_params['workflowStepId'] = params['workflow_step_id'] 15223 15224 query_params = {} 15225 15226 header_params = {} 15227 15228 form_params = [] 15229 local_var_files = {} 15230 15231 body_params = None 15232 if 'workflow_step' in params: 15233 body_params = params['workflow_step'] 15234 # HTTP header `Accept` 15235 header_params['Accept'] = self.api_client.\ 15236 select_header_accept(['application/json']) 15237 15238 # Authentication setting 15239 auth_settings = [] 15240 15241 return self.api_client.call_api(resource_path, 'PUT', 15242 path_params, 15243 query_params, 15244 header_params, 15245 body=body_params, 15246 post_params=form_params, 15247 files=local_var_files, 15248 response_type='WorkflowStep', 15249 auth_settings=auth_settings, 15250 callback=params.get('callback'), 15251 _return_http_data_only=params.get('_return_http_data_only'), 15252 _preload_content=params.get('_preload_content', True), 15253 _request_timeout=params.get('_request_timeout'), 15254 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 :param str locale: Locale setting for the response, e.g., 'en-US'. 9924 :return: EnvelopeAuditEventResponse 9925 If the method is called asynchronously, 9926 returns the request thread. 9927 """ 9928 kwargs['_return_http_data_only'] = True 9929 if kwargs.get('callback'): 9930 return self.list_audit_events_with_http_info(account_id, envelope_id, **kwargs) 9931 else: 9932 (data) = self.list_audit_events_with_http_info(account_id, envelope_id, **kwargs) 9933 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)
- str locale: Locale setting for the response, e.g., 'en-US'.
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)
9935 def list_audit_events_with_http_info(self, account_id, envelope_id, **kwargs): 9936 """ 9937 Gets the envelope audit events for an envelope. 9938 Gets the envelope audit events for the specified envelope. 9939 This method makes a synchronous HTTP request by default. To make an 9940 asynchronous HTTP request, please define a `callback` function 9941 to be invoked when receiving the response. 9942 >>> def callback_function(response): 9943 >>> pprint(response) 9944 >>> 9945 >>> thread = api.list_audit_events_with_http_info(account_id, envelope_id, callback=callback_function) 9946 9947 :param callback function: The callback function 9948 for asynchronous request. (optional) 9949 :param str account_id: The external account number (int) or account ID Guid. (required) 9950 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9951 :param str locale: Locale setting for the response, e.g., 'en-US'. 9952 :return: EnvelopeAuditEventResponse 9953 If the method is called asynchronously, 9954 returns the request thread. 9955 """ 9956 9957 all_params = ['account_id', 'envelope_id', 'locale'] 9958 all_params.append('callback') 9959 all_params.append('_return_http_data_only') 9960 all_params.append('_preload_content') 9961 all_params.append('_request_timeout') 9962 9963 params = locals() 9964 for key, val in iteritems(params['kwargs']): 9965 if key not in all_params: 9966 raise TypeError( 9967 "Got an unexpected keyword argument '%s'" 9968 " to method list_audit_events" % key 9969 ) 9970 params[key] = val 9971 del params['kwargs'] 9972 # verify the required parameter 'account_id' is set 9973 if ('account_id' not in params) or (params['account_id'] is None): 9974 raise ValueError("Missing the required parameter `account_id` when calling `list_audit_events`") 9975 # verify the required parameter 'envelope_id' is set 9976 if ('envelope_id' not in params) or (params['envelope_id'] is None): 9977 raise ValueError("Missing the required parameter `envelope_id` when calling `list_audit_events`") 9978 9979 9980 collection_formats = {} 9981 9982 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/audit_events'.replace('{format}', 'json') 9983 path_params = {} 9984 if 'account_id' in params: 9985 path_params['accountId'] = params['account_id'] 9986 if 'envelope_id' in params: 9987 path_params['envelopeId'] = params['envelope_id'] 9988 9989 query_params = {} 9990 if 'locale' in params: 9991 query_params['locale'] = params['locale'] 9992 9993 header_params = {} 9994 9995 form_params = [] 9996 local_var_files = {} 9997 9998 body_params = None 9999 # HTTP header `Accept` 10000 header_params['Accept'] = self.api_client.\ 10001 select_header_accept(['application/json']) 10002 10003 # Authentication setting 10004 auth_settings = [] 10005 10006 return self.api_client.call_api(resource_path, 'GET', 10007 path_params, 10008 query_params, 10009 header_params, 10010 body=body_params, 10011 post_params=form_params, 10012 files=local_var_files, 10013 response_type='EnvelopeAuditEventResponse', 10014 auth_settings=auth_settings, 10015 callback=params.get('callback'), 10016 _return_http_data_only=params.get('_return_http_data_only'), 10017 _preload_content=params.get('_preload_content', True), 10018 _request_timeout=params.get('_request_timeout'), 10019 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)
- str locale: Locale setting for the response, e.g., 'en-US'.
Returns
EnvelopeAuditEventResponse If the method is called asynchronously, returns the request thread.
def
list_custom_fields(self, account_id, envelope_id, **kwargs)
10021 def list_custom_fields(self, account_id, envelope_id, **kwargs): 10022 """ 10023 Gets the custom field information for the specified envelope. 10024 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. 10025 This method makes a synchronous HTTP request by default. To make an 10026 asynchronous HTTP request, please define a `callback` function 10027 to be invoked when receiving the response. 10028 >>> def callback_function(response): 10029 >>> pprint(response) 10030 >>> 10031 >>> thread = api.list_custom_fields(account_id, envelope_id, callback=callback_function) 10032 10033 :param callback function: The callback function 10034 for asynchronous request. (optional) 10035 :param str account_id: The external account number (int) or account ID Guid. (required) 10036 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10037 :return: CustomFieldsEnvelope 10038 If the method is called asynchronously, 10039 returns the request thread. 10040 """ 10041 kwargs['_return_http_data_only'] = True 10042 if kwargs.get('callback'): 10043 return self.list_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 10044 else: 10045 (data) = self.list_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 10046 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)
10048 def list_custom_fields_with_http_info(self, account_id, envelope_id, **kwargs): 10049 """ 10050 Gets the custom field information for the specified envelope. 10051 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. 10052 This method makes a synchronous HTTP request by default. To make an 10053 asynchronous HTTP request, please define a `callback` function 10054 to be invoked when receiving the response. 10055 >>> def callback_function(response): 10056 >>> pprint(response) 10057 >>> 10058 >>> thread = api.list_custom_fields_with_http_info(account_id, envelope_id, callback=callback_function) 10059 10060 :param callback function: The callback function 10061 for asynchronous request. (optional) 10062 :param str account_id: The external account number (int) or account ID Guid. (required) 10063 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10064 :return: CustomFieldsEnvelope 10065 If the method is called asynchronously, 10066 returns the request thread. 10067 """ 10068 10069 all_params = ['account_id', 'envelope_id'] 10070 all_params.append('callback') 10071 all_params.append('_return_http_data_only') 10072 all_params.append('_preload_content') 10073 all_params.append('_request_timeout') 10074 10075 params = locals() 10076 for key, val in iteritems(params['kwargs']): 10077 if key not in all_params: 10078 raise TypeError( 10079 "Got an unexpected keyword argument '%s'" 10080 " to method list_custom_fields" % key 10081 ) 10082 params[key] = val 10083 del params['kwargs'] 10084 # verify the required parameter 'account_id' is set 10085 if ('account_id' not in params) or (params['account_id'] is None): 10086 raise ValueError("Missing the required parameter `account_id` when calling `list_custom_fields`") 10087 # verify the required parameter 'envelope_id' is set 10088 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10089 raise ValueError("Missing the required parameter `envelope_id` when calling `list_custom_fields`") 10090 10091 10092 collection_formats = {} 10093 10094 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/custom_fields'.replace('{format}', 'json') 10095 path_params = {} 10096 if 'account_id' in params: 10097 path_params['accountId'] = params['account_id'] 10098 if 'envelope_id' in params: 10099 path_params['envelopeId'] = params['envelope_id'] 10100 10101 query_params = {} 10102 10103 header_params = {} 10104 10105 form_params = [] 10106 local_var_files = {} 10107 10108 body_params = None 10109 # HTTP header `Accept` 10110 header_params['Accept'] = self.api_client.\ 10111 select_header_accept(['application/json']) 10112 10113 # Authentication setting 10114 auth_settings = [] 10115 10116 return self.api_client.call_api(resource_path, 'GET', 10117 path_params, 10118 query_params, 10119 header_params, 10120 body=body_params, 10121 post_params=form_params, 10122 files=local_var_files, 10123 response_type='CustomFieldsEnvelope', 10124 auth_settings=auth_settings, 10125 callback=params.get('callback'), 10126 _return_http_data_only=params.get('_return_http_data_only'), 10127 _preload_content=params.get('_preload_content', True), 10128 _request_timeout=params.get('_request_timeout'), 10129 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)
10131 def list_document_fields(self, account_id, document_id, envelope_id, **kwargs): 10132 """ 10133 Gets the custom document fields from an existing envelope document. 10134 Retrieves the custom document field information from an existing envelope document. 10135 This method makes a synchronous HTTP request by default. To make an 10136 asynchronous HTTP request, please define a `callback` function 10137 to be invoked when receiving the response. 10138 >>> def callback_function(response): 10139 >>> pprint(response) 10140 >>> 10141 >>> thread = api.list_document_fields(account_id, document_id, envelope_id, callback=callback_function) 10142 10143 :param callback function: The callback function 10144 for asynchronous request. (optional) 10145 :param str account_id: The external account number (int) or account ID Guid. (required) 10146 :param str document_id: The ID of the document being accessed. (required) 10147 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10148 :return: DocumentFieldsInformation 10149 If the method is called asynchronously, 10150 returns the request thread. 10151 """ 10152 kwargs['_return_http_data_only'] = True 10153 if kwargs.get('callback'): 10154 return self.list_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 10155 else: 10156 (data) = self.list_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 10157 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)
10159 def list_document_fields_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 10160 """ 10161 Gets the custom document fields from an existing envelope document. 10162 Retrieves the custom document field information from an existing envelope document. 10163 This method makes a synchronous HTTP request by default. To make an 10164 asynchronous HTTP request, please define a `callback` function 10165 to be invoked when receiving the response. 10166 >>> def callback_function(response): 10167 >>> pprint(response) 10168 >>> 10169 >>> thread = api.list_document_fields_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 10170 10171 :param callback function: The callback function 10172 for asynchronous request. (optional) 10173 :param str account_id: The external account number (int) or account ID Guid. (required) 10174 :param str document_id: The ID of the document being accessed. (required) 10175 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10176 :return: DocumentFieldsInformation 10177 If the method is called asynchronously, 10178 returns the request thread. 10179 """ 10180 10181 all_params = ['account_id', 'document_id', 'envelope_id'] 10182 all_params.append('callback') 10183 all_params.append('_return_http_data_only') 10184 all_params.append('_preload_content') 10185 all_params.append('_request_timeout') 10186 10187 params = locals() 10188 for key, val in iteritems(params['kwargs']): 10189 if key not in all_params: 10190 raise TypeError( 10191 "Got an unexpected keyword argument '%s'" 10192 " to method list_document_fields" % key 10193 ) 10194 params[key] = val 10195 del params['kwargs'] 10196 # verify the required parameter 'account_id' is set 10197 if ('account_id' not in params) or (params['account_id'] is None): 10198 raise ValueError("Missing the required parameter `account_id` when calling `list_document_fields`") 10199 # verify the required parameter 'document_id' is set 10200 if ('document_id' not in params) or (params['document_id'] is None): 10201 raise ValueError("Missing the required parameter `document_id` when calling `list_document_fields`") 10202 # verify the required parameter 'envelope_id' is set 10203 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10204 raise ValueError("Missing the required parameter `envelope_id` when calling `list_document_fields`") 10205 10206 10207 collection_formats = {} 10208 10209 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/fields'.replace('{format}', 'json') 10210 path_params = {} 10211 if 'account_id' in params: 10212 path_params['accountId'] = params['account_id'] 10213 if 'document_id' in params: 10214 path_params['documentId'] = params['document_id'] 10215 if 'envelope_id' in params: 10216 path_params['envelopeId'] = params['envelope_id'] 10217 10218 query_params = {} 10219 10220 header_params = {} 10221 10222 form_params = [] 10223 local_var_files = {} 10224 10225 body_params = None 10226 # HTTP header `Accept` 10227 header_params['Accept'] = self.api_client.\ 10228 select_header_accept(['application/json']) 10229 10230 # Authentication setting 10231 auth_settings = [] 10232 10233 return self.api_client.call_api(resource_path, 'GET', 10234 path_params, 10235 query_params, 10236 header_params, 10237 body=body_params, 10238 post_params=form_params, 10239 files=local_var_files, 10240 response_type='DocumentFieldsInformation', 10241 auth_settings=auth_settings, 10242 callback=params.get('callback'), 10243 _return_http_data_only=params.get('_return_http_data_only'), 10244 _preload_content=params.get('_preload_content', True), 10245 _request_timeout=params.get('_request_timeout'), 10246 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)
10248 def list_documents(self, account_id, envelope_id, **kwargs): 10249 """ 10250 Gets a list of envelope documents. 10251 Retrieves a list of documents associated with the specified envelope. 10252 This method makes a synchronous HTTP request by default. To make an 10253 asynchronous HTTP request, please define a `callback` function 10254 to be invoked when receiving the response. 10255 >>> def callback_function(response): 10256 >>> pprint(response) 10257 >>> 10258 >>> thread = api.list_documents(account_id, envelope_id, callback=callback_function) 10259 10260 :param callback function: The callback function 10261 for asynchronous request. (optional) 10262 :param str account_id: The external account number (int) or account ID Guid. (required) 10263 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10264 :param str documents_by_userid: 10265 :param str include_agreement_type: 10266 :param str include_docgen_formfields: 10267 :param str include_document_size: 10268 :param str include_metadata: 10269 :param str include_tabs: 10270 :param str recipient_id: 10271 :param str shared_user_id: 10272 :return: EnvelopeDocumentsResult 10273 If the method is called asynchronously, 10274 returns the request thread. 10275 """ 10276 kwargs['_return_http_data_only'] = True 10277 if kwargs.get('callback'): 10278 return self.list_documents_with_http_info(account_id, envelope_id, **kwargs) 10279 else: 10280 (data) = self.list_documents_with_http_info(account_id, envelope_id, **kwargs) 10281 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_agreement_type:
- 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)
10283 def list_documents_with_http_info(self, account_id, envelope_id, **kwargs): 10284 """ 10285 Gets a list of envelope documents. 10286 Retrieves a list of documents associated with the specified envelope. 10287 This method makes a synchronous HTTP request by default. To make an 10288 asynchronous HTTP request, please define a `callback` function 10289 to be invoked when receiving the response. 10290 >>> def callback_function(response): 10291 >>> pprint(response) 10292 >>> 10293 >>> thread = api.list_documents_with_http_info(account_id, envelope_id, callback=callback_function) 10294 10295 :param callback function: The callback function 10296 for asynchronous request. (optional) 10297 :param str account_id: The external account number (int) or account ID Guid. (required) 10298 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10299 :param str documents_by_userid: 10300 :param str include_agreement_type: 10301 :param str include_docgen_formfields: 10302 :param str include_document_size: 10303 :param str include_metadata: 10304 :param str include_tabs: 10305 :param str recipient_id: 10306 :param str shared_user_id: 10307 :return: EnvelopeDocumentsResult 10308 If the method is called asynchronously, 10309 returns the request thread. 10310 """ 10311 10312 all_params = ['account_id', 'envelope_id', 'documents_by_userid', 'include_agreement_type', 'include_docgen_formfields', 'include_document_size', 'include_metadata', 'include_tabs', 'recipient_id', 'shared_user_id'] 10313 all_params.append('callback') 10314 all_params.append('_return_http_data_only') 10315 all_params.append('_preload_content') 10316 all_params.append('_request_timeout') 10317 10318 params = locals() 10319 for key, val in iteritems(params['kwargs']): 10320 if key not in all_params: 10321 raise TypeError( 10322 "Got an unexpected keyword argument '%s'" 10323 " to method list_documents" % key 10324 ) 10325 params[key] = val 10326 del params['kwargs'] 10327 # verify the required parameter 'account_id' is set 10328 if ('account_id' not in params) or (params['account_id'] is None): 10329 raise ValueError("Missing the required parameter `account_id` when calling `list_documents`") 10330 # verify the required parameter 'envelope_id' is set 10331 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10332 raise ValueError("Missing the required parameter `envelope_id` when calling `list_documents`") 10333 10334 10335 collection_formats = {} 10336 10337 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents'.replace('{format}', 'json') 10338 path_params = {} 10339 if 'account_id' in params: 10340 path_params['accountId'] = params['account_id'] 10341 if 'envelope_id' in params: 10342 path_params['envelopeId'] = params['envelope_id'] 10343 10344 query_params = {} 10345 if 'documents_by_userid' in params: 10346 query_params['documents_by_userid'] = params['documents_by_userid'] 10347 if 'include_agreement_type' in params: 10348 query_params['include_agreement_type'] = params['include_agreement_type'] 10349 if 'include_docgen_formfields' in params: 10350 query_params['include_docgen_formfields'] = params['include_docgen_formfields'] 10351 if 'include_document_size' in params: 10352 query_params['include_document_size'] = params['include_document_size'] 10353 if 'include_metadata' in params: 10354 query_params['include_metadata'] = params['include_metadata'] 10355 if 'include_tabs' in params: 10356 query_params['include_tabs'] = params['include_tabs'] 10357 if 'recipient_id' in params: 10358 query_params['recipient_id'] = params['recipient_id'] 10359 if 'shared_user_id' in params: 10360 query_params['shared_user_id'] = params['shared_user_id'] 10361 10362 header_params = {} 10363 10364 form_params = [] 10365 local_var_files = {} 10366 10367 body_params = None 10368 # HTTP header `Accept` 10369 header_params['Accept'] = self.api_client.\ 10370 select_header_accept(['application/json']) 10371 10372 # Authentication setting 10373 auth_settings = [] 10374 10375 return self.api_client.call_api(resource_path, 'GET', 10376 path_params, 10377 query_params, 10378 header_params, 10379 body=body_params, 10380 post_params=form_params, 10381 files=local_var_files, 10382 response_type='EnvelopeDocumentsResult', 10383 auth_settings=auth_settings, 10384 callback=params.get('callback'), 10385 _return_http_data_only=params.get('_return_http_data_only'), 10386 _preload_content=params.get('_preload_content', True), 10387 _request_timeout=params.get('_request_timeout'), 10388 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_agreement_type:
- 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)
10390 def list_recipients(self, account_id, envelope_id, **kwargs): 10391 """ 10392 Gets the status of recipients for an envelope. 10393 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. 10394 This method makes a synchronous HTTP request by default. To make an 10395 asynchronous HTTP request, please define a `callback` function 10396 to be invoked when receiving the response. 10397 >>> def callback_function(response): 10398 >>> pprint(response) 10399 >>> 10400 >>> thread = api.list_recipients(account_id, envelope_id, callback=callback_function) 10401 10402 :param callback function: The callback function 10403 for asynchronous request. (optional) 10404 :param str account_id: The external account number (int) or account ID Guid. (required) 10405 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10406 :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. 10407 :param str include_extended: When set to **true**, the extended properties are included in the response. 10408 :param str include_metadata: 10409 :param str include_tabs: When set to **true**, the tab information associated with the recipient is included in the response. 10410 :return: Recipients 10411 If the method is called asynchronously, 10412 returns the request thread. 10413 """ 10414 kwargs['_return_http_data_only'] = True 10415 if kwargs.get('callback'): 10416 return self.list_recipients_with_http_info(account_id, envelope_id, **kwargs) 10417 else: 10418 (data) = self.list_recipients_with_http_info(account_id, envelope_id, **kwargs) 10419 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)
10421 def list_recipients_with_http_info(self, account_id, envelope_id, **kwargs): 10422 """ 10423 Gets the status of recipients for an envelope. 10424 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. 10425 This method makes a synchronous HTTP request by default. To make an 10426 asynchronous HTTP request, please define a `callback` function 10427 to be invoked when receiving the response. 10428 >>> def callback_function(response): 10429 >>> pprint(response) 10430 >>> 10431 >>> thread = api.list_recipients_with_http_info(account_id, envelope_id, callback=callback_function) 10432 10433 :param callback function: The callback function 10434 for asynchronous request. (optional) 10435 :param str account_id: The external account number (int) or account ID Guid. (required) 10436 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10437 :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. 10438 :param str include_extended: When set to **true**, the extended properties are included in the response. 10439 :param str include_metadata: 10440 :param str include_tabs: When set to **true**, the tab information associated with the recipient is included in the response. 10441 :return: Recipients 10442 If the method is called asynchronously, 10443 returns the request thread. 10444 """ 10445 10446 all_params = ['account_id', 'envelope_id', 'include_anchor_tab_locations', 'include_extended', 'include_metadata', 'include_tabs'] 10447 all_params.append('callback') 10448 all_params.append('_return_http_data_only') 10449 all_params.append('_preload_content') 10450 all_params.append('_request_timeout') 10451 10452 params = locals() 10453 for key, val in iteritems(params['kwargs']): 10454 if key not in all_params: 10455 raise TypeError( 10456 "Got an unexpected keyword argument '%s'" 10457 " to method list_recipients" % key 10458 ) 10459 params[key] = val 10460 del params['kwargs'] 10461 # verify the required parameter 'account_id' is set 10462 if ('account_id' not in params) or (params['account_id'] is None): 10463 raise ValueError("Missing the required parameter `account_id` when calling `list_recipients`") 10464 # verify the required parameter 'envelope_id' is set 10465 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10466 raise ValueError("Missing the required parameter `envelope_id` when calling `list_recipients`") 10467 10468 10469 collection_formats = {} 10470 10471 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients'.replace('{format}', 'json') 10472 path_params = {} 10473 if 'account_id' in params: 10474 path_params['accountId'] = params['account_id'] 10475 if 'envelope_id' in params: 10476 path_params['envelopeId'] = params['envelope_id'] 10477 10478 query_params = {} 10479 if 'include_anchor_tab_locations' in params: 10480 query_params['include_anchor_tab_locations'] = params['include_anchor_tab_locations'] 10481 if 'include_extended' in params: 10482 query_params['include_extended'] = params['include_extended'] 10483 if 'include_metadata' in params: 10484 query_params['include_metadata'] = params['include_metadata'] 10485 if 'include_tabs' in params: 10486 query_params['include_tabs'] = params['include_tabs'] 10487 10488 header_params = {} 10489 10490 form_params = [] 10491 local_var_files = {} 10492 10493 body_params = None 10494 # HTTP header `Accept` 10495 header_params['Accept'] = self.api_client.\ 10496 select_header_accept(['application/json']) 10497 10498 # Authentication setting 10499 auth_settings = [] 10500 10501 return self.api_client.call_api(resource_path, 'GET', 10502 path_params, 10503 query_params, 10504 header_params, 10505 body=body_params, 10506 post_params=form_params, 10507 files=local_var_files, 10508 response_type='Recipients', 10509 auth_settings=auth_settings, 10510 callback=params.get('callback'), 10511 _return_http_data_only=params.get('_return_http_data_only'), 10512 _preload_content=params.get('_preload_content', True), 10513 _request_timeout=params.get('_request_timeout'), 10514 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)
10516 def list_status(self, account_id, **kwargs): 10517 """ 10518 Gets the envelope status for the specified envelopes. 10519 Retrieves the envelope status for the specified envelopes. 10520 This method makes a synchronous HTTP request by default. To make an 10521 asynchronous HTTP request, please define a `callback` function 10522 to be invoked when receiving the response. 10523 >>> def callback_function(response): 10524 >>> pprint(response) 10525 >>> 10526 >>> thread = api.list_status(account_id, callback=callback_function) 10527 10528 :param callback function: The callback function 10529 for asynchronous request. (optional) 10530 :param str account_id: The external account number (int) or account ID Guid. (required) 10531 :param str ac_status: 10532 :param str block: 10533 :param str count: 10534 :param str email: 10535 :param str envelope_ids: 10536 :param str from_date: 10537 :param str from_to_status: 10538 :param str start_position: 10539 :param str status: 10540 :param str to_date: 10541 :param str transaction_ids: 10542 :param str user_name: 10543 :param EnvelopeIdsRequest envelope_ids_request: 10544 :return: EnvelopesInformation 10545 If the method is called asynchronously, 10546 returns the request thread. 10547 """ 10548 kwargs['_return_http_data_only'] = True 10549 if kwargs.get('callback'): 10550 return self.list_status_with_http_info(account_id, **kwargs) 10551 else: 10552 (data) = self.list_status_with_http_info(account_id, **kwargs) 10553 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)
10555 def list_status_with_http_info(self, account_id, **kwargs): 10556 """ 10557 Gets the envelope status for the specified envelopes. 10558 Retrieves the envelope status for the specified envelopes. 10559 This method makes a synchronous HTTP request by default. To make an 10560 asynchronous HTTP request, please define a `callback` function 10561 to be invoked when receiving the response. 10562 >>> def callback_function(response): 10563 >>> pprint(response) 10564 >>> 10565 >>> thread = api.list_status_with_http_info(account_id, callback=callback_function) 10566 10567 :param callback function: The callback function 10568 for asynchronous request. (optional) 10569 :param str account_id: The external account number (int) or account ID Guid. (required) 10570 :param str ac_status: 10571 :param str block: 10572 :param str count: 10573 :param str email: 10574 :param str envelope_ids: 10575 :param str from_date: 10576 :param str from_to_status: 10577 :param str start_position: 10578 :param str status: 10579 :param str to_date: 10580 :param str transaction_ids: 10581 :param str user_name: 10582 :param EnvelopeIdsRequest envelope_ids_request: 10583 :return: EnvelopesInformation 10584 If the method is called asynchronously, 10585 returns the request thread. 10586 """ 10587 10588 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'] 10589 all_params.append('callback') 10590 all_params.append('_return_http_data_only') 10591 all_params.append('_preload_content') 10592 all_params.append('_request_timeout') 10593 10594 params = locals() 10595 for key, val in iteritems(params['kwargs']): 10596 if key not in all_params: 10597 raise TypeError( 10598 "Got an unexpected keyword argument '%s'" 10599 " to method list_status" % key 10600 ) 10601 params[key] = val 10602 del params['kwargs'] 10603 # verify the required parameter 'account_id' is set 10604 if ('account_id' not in params) or (params['account_id'] is None): 10605 raise ValueError("Missing the required parameter `account_id` when calling `list_status`") 10606 10607 10608 collection_formats = {} 10609 10610 resource_path = '/v2.1/accounts/{accountId}/envelopes/status'.replace('{format}', 'json') 10611 path_params = {} 10612 if 'account_id' in params: 10613 path_params['accountId'] = params['account_id'] 10614 10615 query_params = {} 10616 if 'ac_status' in params: 10617 query_params['ac_status'] = params['ac_status'] 10618 if 'block' in params: 10619 query_params['block'] = params['block'] 10620 if 'count' in params: 10621 query_params['count'] = params['count'] 10622 if 'email' in params: 10623 query_params['email'] = params['email'] 10624 if 'envelope_ids' in params: 10625 query_params['envelope_ids'] = params['envelope_ids'] 10626 if 'from_date' in params: 10627 query_params['from_date'] = params['from_date'] 10628 if 'from_to_status' in params: 10629 query_params['from_to_status'] = params['from_to_status'] 10630 if 'start_position' in params: 10631 query_params['start_position'] = params['start_position'] 10632 if 'status' in params: 10633 query_params['status'] = params['status'] 10634 if 'to_date' in params: 10635 query_params['to_date'] = params['to_date'] 10636 if 'transaction_ids' in params: 10637 query_params['transaction_ids'] = params['transaction_ids'] 10638 if 'user_name' in params: 10639 query_params['user_name'] = params['user_name'] 10640 10641 header_params = {} 10642 10643 form_params = [] 10644 local_var_files = {} 10645 10646 body_params = None 10647 if 'envelope_ids_request' in params: 10648 body_params = params['envelope_ids_request'] 10649 # HTTP header `Accept` 10650 header_params['Accept'] = self.api_client.\ 10651 select_header_accept(['application/json']) 10652 10653 # Authentication setting 10654 auth_settings = [] 10655 10656 return self.api_client.call_api(resource_path, 'PUT', 10657 path_params, 10658 query_params, 10659 header_params, 10660 body=body_params, 10661 post_params=form_params, 10662 files=local_var_files, 10663 response_type='EnvelopesInformation', 10664 auth_settings=auth_settings, 10665 callback=params.get('callback'), 10666 _return_http_data_only=params.get('_return_http_data_only'), 10667 _preload_content=params.get('_preload_content', True), 10668 _request_timeout=params.get('_request_timeout'), 10669 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)
10671 def list_status_changes(self, account_id, **kwargs): 10672 """ 10673 Gets status changes for one or more envelopes. 10674 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. 10675 This method makes a synchronous HTTP request by default. To make an 10676 asynchronous HTTP request, please define a `callback` function 10677 to be invoked when receiving the response. 10678 >>> def callback_function(response): 10679 >>> pprint(response) 10680 >>> 10681 >>> thread = api.list_status_changes(account_id, callback=callback_function) 10682 10683 :param callback function: The callback function 10684 for asynchronous request. (optional) 10685 :param str account_id: The external account number (int) or account ID Guid. (required) 10686 :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. 10687 :param str block: 10688 :param str cdse_mode: 10689 :param str continuation_token: 10690 :param str count: 10691 :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.\" 10692 :param str email: 10693 :param str envelope_ids: 10694 :param str exclude: 10695 :param str folder_ids: 10696 :param str folder_types: 10697 :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. 10698 :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. 10699 :param str include: 10700 :param str include_purge_information: 10701 :param str intersecting_folder_ids: 10702 :param str last_queried_date: 10703 :param str order: 10704 :param str order_by: 10705 :param str powerformids: 10706 :param str query_budget: 10707 :param str requester_date_format: 10708 :param str search_mode: 10709 :param str search_text: 10710 :param str start_position: 10711 :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. 10712 :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`. 10713 :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. 10714 :param str user_filter: 10715 :param str user_id: 10716 :param str user_name: 10717 :return: EnvelopesInformation 10718 If the method is called asynchronously, 10719 returns the request thread. 10720 """ 10721 kwargs['_return_http_data_only'] = True 10722 if kwargs.get('callback'): 10723 return self.list_status_changes_with_http_info(account_id, **kwargs) 10724 else: 10725 (data) = self.list_status_changes_with_http_info(account_id, **kwargs) 10726 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)
10728 def list_status_changes_with_http_info(self, account_id, **kwargs): 10729 """ 10730 Gets status changes for one or more envelopes. 10731 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. 10732 This method makes a synchronous HTTP request by default. To make an 10733 asynchronous HTTP request, please define a `callback` function 10734 to be invoked when receiving the response. 10735 >>> def callback_function(response): 10736 >>> pprint(response) 10737 >>> 10738 >>> thread = api.list_status_changes_with_http_info(account_id, callback=callback_function) 10739 10740 :param callback function: The callback function 10741 for asynchronous request. (optional) 10742 :param str account_id: The external account number (int) or account ID Guid. (required) 10743 :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. 10744 :param str block: 10745 :param str cdse_mode: 10746 :param str continuation_token: 10747 :param str count: 10748 :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.\" 10749 :param str email: 10750 :param str envelope_ids: 10751 :param str exclude: 10752 :param str folder_ids: 10753 :param str folder_types: 10754 :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. 10755 :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. 10756 :param str include: 10757 :param str include_purge_information: 10758 :param str intersecting_folder_ids: 10759 :param str last_queried_date: 10760 :param str order: 10761 :param str order_by: 10762 :param str powerformids: 10763 :param str query_budget: 10764 :param str requester_date_format: 10765 :param str search_mode: 10766 :param str search_text: 10767 :param str start_position: 10768 :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. 10769 :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`. 10770 :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. 10771 :param str user_filter: 10772 :param str user_id: 10773 :param str user_name: 10774 :return: EnvelopesInformation 10775 If the method is called asynchronously, 10776 returns the request thread. 10777 """ 10778 10779 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'] 10780 all_params.append('callback') 10781 all_params.append('_return_http_data_only') 10782 all_params.append('_preload_content') 10783 all_params.append('_request_timeout') 10784 10785 params = locals() 10786 for key, val in iteritems(params['kwargs']): 10787 if key not in all_params: 10788 raise TypeError( 10789 "Got an unexpected keyword argument '%s'" 10790 " to method list_status_changes" % key 10791 ) 10792 params[key] = val 10793 del params['kwargs'] 10794 # verify the required parameter 'account_id' is set 10795 if ('account_id' not in params) or (params['account_id'] is None): 10796 raise ValueError("Missing the required parameter `account_id` when calling `list_status_changes`") 10797 10798 10799 collection_formats = {} 10800 10801 resource_path = '/v2.1/accounts/{accountId}/envelopes'.replace('{format}', 'json') 10802 path_params = {} 10803 if 'account_id' in params: 10804 path_params['accountId'] = params['account_id'] 10805 10806 query_params = {} 10807 if 'ac_status' in params: 10808 query_params['ac_status'] = params['ac_status'] 10809 if 'block' in params: 10810 query_params['block'] = params['block'] 10811 if 'cdse_mode' in params: 10812 query_params['cdse_mode'] = params['cdse_mode'] 10813 if 'continuation_token' in params: 10814 query_params['continuation_token'] = params['continuation_token'] 10815 if 'count' in params: 10816 query_params['count'] = params['count'] 10817 if 'custom_field' in params: 10818 query_params['custom_field'] = params['custom_field'] 10819 if 'email' in params: 10820 query_params['email'] = params['email'] 10821 if 'envelope_ids' in params: 10822 query_params['envelope_ids'] = params['envelope_ids'] 10823 if 'exclude' in params: 10824 query_params['exclude'] = params['exclude'] 10825 if 'folder_ids' in params: 10826 query_params['folder_ids'] = params['folder_ids'] 10827 if 'folder_types' in params: 10828 query_params['folder_types'] = params['folder_types'] 10829 if 'from_date' in params: 10830 query_params['from_date'] = params['from_date'] 10831 if 'from_to_status' in params: 10832 query_params['from_to_status'] = params['from_to_status'] 10833 if 'include' in params: 10834 query_params['include'] = params['include'] 10835 if 'include_purge_information' in params: 10836 query_params['include_purge_information'] = params['include_purge_information'] 10837 if 'intersecting_folder_ids' in params: 10838 query_params['intersecting_folder_ids'] = params['intersecting_folder_ids'] 10839 if 'last_queried_date' in params: 10840 query_params['last_queried_date'] = params['last_queried_date'] 10841 if 'order' in params: 10842 query_params['order'] = params['order'] 10843 if 'order_by' in params: 10844 query_params['order_by'] = params['order_by'] 10845 if 'powerformids' in params: 10846 query_params['powerformids'] = params['powerformids'] 10847 if 'query_budget' in params: 10848 query_params['query_budget'] = params['query_budget'] 10849 if 'requester_date_format' in params: 10850 query_params['requester_date_format'] = params['requester_date_format'] 10851 if 'search_mode' in params: 10852 query_params['search_mode'] = params['search_mode'] 10853 if 'search_text' in params: 10854 query_params['search_text'] = params['search_text'] 10855 if 'start_position' in params: 10856 query_params['start_position'] = params['start_position'] 10857 if 'status' in params: 10858 query_params['status'] = params['status'] 10859 if 'to_date' in params: 10860 query_params['to_date'] = params['to_date'] 10861 if 'transaction_ids' in params: 10862 query_params['transaction_ids'] = params['transaction_ids'] 10863 if 'user_filter' in params: 10864 query_params['user_filter'] = params['user_filter'] 10865 if 'user_id' in params: 10866 query_params['user_id'] = params['user_id'] 10867 if 'user_name' in params: 10868 query_params['user_name'] = params['user_name'] 10869 10870 header_params = {} 10871 10872 form_params = [] 10873 local_var_files = {} 10874 10875 body_params = None 10876 # HTTP header `Accept` 10877 header_params['Accept'] = self.api_client.\ 10878 select_header_accept(['application/json']) 10879 10880 # Authentication setting 10881 auth_settings = [] 10882 10883 return self.api_client.call_api(resource_path, 'GET', 10884 path_params, 10885 query_params, 10886 header_params, 10887 body=body_params, 10888 post_params=form_params, 10889 files=local_var_files, 10890 response_type='EnvelopesInformation', 10891 auth_settings=auth_settings, 10892 callback=params.get('callback'), 10893 _return_http_data_only=params.get('_return_http_data_only'), 10894 _preload_content=params.get('_preload_content', True), 10895 _request_timeout=params.get('_request_timeout'), 10896 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)
10898 def list_tabs(self, account_id, envelope_id, recipient_id, **kwargs): 10899 """ 10900 Gets the tabs information for a signer or sign-in-person recipient in an envelope. 10901 Retrieves information about the tabs associated with a recipient in a draft envelope. 10902 This method makes a synchronous HTTP request by default. To make an 10903 asynchronous HTTP request, please define a `callback` function 10904 to be invoked when receiving the response. 10905 >>> def callback_function(response): 10906 >>> pprint(response) 10907 >>> 10908 >>> thread = api.list_tabs(account_id, envelope_id, recipient_id, callback=callback_function) 10909 10910 :param callback function: The callback function 10911 for asynchronous request. (optional) 10912 :param str account_id: The external account number (int) or account ID Guid. (required) 10913 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10914 :param str recipient_id: The ID of the recipient being accessed. (required) 10915 :param str include_anchor_tab_locations: When set to **true**, all tabs with anchor tab properties are included in the response. 10916 :param str include_metadata: 10917 :return: Tabs 10918 If the method is called asynchronously, 10919 returns the request thread. 10920 """ 10921 kwargs['_return_http_data_only'] = True 10922 if kwargs.get('callback'): 10923 return self.list_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 10924 else: 10925 (data) = self.list_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 10926 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)
10928 def list_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 10929 """ 10930 Gets the tabs information for a signer or sign-in-person recipient in an envelope. 10931 Retrieves information about the tabs associated with a recipient in a draft envelope. 10932 This method makes a synchronous HTTP request by default. To make an 10933 asynchronous HTTP request, please define a `callback` function 10934 to be invoked when receiving the response. 10935 >>> def callback_function(response): 10936 >>> pprint(response) 10937 >>> 10938 >>> thread = api.list_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 10939 10940 :param callback function: The callback function 10941 for asynchronous request. (optional) 10942 :param str account_id: The external account number (int) or account ID Guid. (required) 10943 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10944 :param str recipient_id: The ID of the recipient being accessed. (required) 10945 :param str include_anchor_tab_locations: When set to **true**, all tabs with anchor tab properties are included in the response. 10946 :param str include_metadata: 10947 :return: Tabs 10948 If the method is called asynchronously, 10949 returns the request thread. 10950 """ 10951 10952 all_params = ['account_id', 'envelope_id', 'recipient_id', 'include_anchor_tab_locations', 'include_metadata'] 10953 all_params.append('callback') 10954 all_params.append('_return_http_data_only') 10955 all_params.append('_preload_content') 10956 all_params.append('_request_timeout') 10957 10958 params = locals() 10959 for key, val in iteritems(params['kwargs']): 10960 if key not in all_params: 10961 raise TypeError( 10962 "Got an unexpected keyword argument '%s'" 10963 " to method list_tabs" % key 10964 ) 10965 params[key] = val 10966 del params['kwargs'] 10967 # verify the required parameter 'account_id' is set 10968 if ('account_id' not in params) or (params['account_id'] is None): 10969 raise ValueError("Missing the required parameter `account_id` when calling `list_tabs`") 10970 # verify the required parameter 'envelope_id' is set 10971 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10972 raise ValueError("Missing the required parameter `envelope_id` when calling `list_tabs`") 10973 # verify the required parameter 'recipient_id' is set 10974 if ('recipient_id' not in params) or (params['recipient_id'] is None): 10975 raise ValueError("Missing the required parameter `recipient_id` when calling `list_tabs`") 10976 10977 10978 collection_formats = {} 10979 10980 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/tabs'.replace('{format}', 'json') 10981 path_params = {} 10982 if 'account_id' in params: 10983 path_params['accountId'] = params['account_id'] 10984 if 'envelope_id' in params: 10985 path_params['envelopeId'] = params['envelope_id'] 10986 if 'recipient_id' in params: 10987 path_params['recipientId'] = params['recipient_id'] 10988 10989 query_params = {} 10990 if 'include_anchor_tab_locations' in params: 10991 query_params['include_anchor_tab_locations'] = params['include_anchor_tab_locations'] 10992 if 'include_metadata' in params: 10993 query_params['include_metadata'] = params['include_metadata'] 10994 10995 header_params = {} 10996 10997 form_params = [] 10998 local_var_files = {} 10999 11000 body_params = None 11001 # HTTP header `Accept` 11002 header_params['Accept'] = self.api_client.\ 11003 select_header_accept(['application/json']) 11004 11005 # Authentication setting 11006 auth_settings = [] 11007 11008 return self.api_client.call_api(resource_path, 'GET', 11009 path_params, 11010 query_params, 11011 header_params, 11012 body=body_params, 11013 post_params=form_params, 11014 files=local_var_files, 11015 response_type='Tabs', 11016 auth_settings=auth_settings, 11017 callback=params.get('callback'), 11018 _return_http_data_only=params.get('_return_http_data_only'), 11019 _preload_content=params.get('_preload_content', True), 11020 _request_timeout=params.get('_request_timeout'), 11021 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)
11023 def list_templates(self, account_id, envelope_id, **kwargs): 11024 """ 11025 Get List of Templates used in an Envelope 11026 This returns a list of the server-side templates, their name and ID, used in an envelope. 11027 This method makes a synchronous HTTP request by default. To make an 11028 asynchronous HTTP request, please define a `callback` function 11029 to be invoked when receiving the response. 11030 >>> def callback_function(response): 11031 >>> pprint(response) 11032 >>> 11033 >>> thread = api.list_templates(account_id, envelope_id, callback=callback_function) 11034 11035 :param callback function: The callback function 11036 for asynchronous request. (optional) 11037 :param str account_id: The external account number (int) or account ID Guid. (required) 11038 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11039 :param str include: The possible values are: matching_applied - This returns template matching information for the template. 11040 :return: TemplateInformation 11041 If the method is called asynchronously, 11042 returns the request thread. 11043 """ 11044 kwargs['_return_http_data_only'] = True 11045 if kwargs.get('callback'): 11046 return self.list_templates_with_http_info(account_id, envelope_id, **kwargs) 11047 else: 11048 (data) = self.list_templates_with_http_info(account_id, envelope_id, **kwargs) 11049 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)
11051 def list_templates_with_http_info(self, account_id, envelope_id, **kwargs): 11052 """ 11053 Get List of Templates used in an Envelope 11054 This returns a list of the server-side templates, their name and ID, used in an envelope. 11055 This method makes a synchronous HTTP request by default. To make an 11056 asynchronous HTTP request, please define a `callback` function 11057 to be invoked when receiving the response. 11058 >>> def callback_function(response): 11059 >>> pprint(response) 11060 >>> 11061 >>> thread = api.list_templates_with_http_info(account_id, envelope_id, callback=callback_function) 11062 11063 :param callback function: The callback function 11064 for asynchronous request. (optional) 11065 :param str account_id: The external account number (int) or account ID Guid. (required) 11066 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11067 :param str include: The possible values are: matching_applied - This returns template matching information for the template. 11068 :return: TemplateInformation 11069 If the method is called asynchronously, 11070 returns the request thread. 11071 """ 11072 11073 all_params = ['account_id', 'envelope_id', 'include'] 11074 all_params.append('callback') 11075 all_params.append('_return_http_data_only') 11076 all_params.append('_preload_content') 11077 all_params.append('_request_timeout') 11078 11079 params = locals() 11080 for key, val in iteritems(params['kwargs']): 11081 if key not in all_params: 11082 raise TypeError( 11083 "Got an unexpected keyword argument '%s'" 11084 " to method list_templates" % key 11085 ) 11086 params[key] = val 11087 del params['kwargs'] 11088 # verify the required parameter 'account_id' is set 11089 if ('account_id' not in params) or (params['account_id'] is None): 11090 raise ValueError("Missing the required parameter `account_id` when calling `list_templates`") 11091 # verify the required parameter 'envelope_id' is set 11092 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11093 raise ValueError("Missing the required parameter `envelope_id` when calling `list_templates`") 11094 11095 11096 collection_formats = {} 11097 11098 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/templates'.replace('{format}', 'json') 11099 path_params = {} 11100 if 'account_id' in params: 11101 path_params['accountId'] = params['account_id'] 11102 if 'envelope_id' in params: 11103 path_params['envelopeId'] = params['envelope_id'] 11104 11105 query_params = {} 11106 if 'include' in params: 11107 query_params['include'] = params['include'] 11108 11109 header_params = {} 11110 11111 form_params = [] 11112 local_var_files = {} 11113 11114 body_params = None 11115 # HTTP header `Accept` 11116 header_params['Accept'] = self.api_client.\ 11117 select_header_accept(['application/json']) 11118 11119 # Authentication setting 11120 auth_settings = [] 11121 11122 return self.api_client.call_api(resource_path, 'GET', 11123 path_params, 11124 query_params, 11125 header_params, 11126 body=body_params, 11127 post_params=form_params, 11128 files=local_var_files, 11129 response_type='TemplateInformation', 11130 auth_settings=auth_settings, 11131 callback=params.get('callback'), 11132 _return_http_data_only=params.get('_return_http_data_only'), 11133 _preload_content=params.get('_preload_content', True), 11134 _request_timeout=params.get('_request_timeout'), 11135 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)
11137 def list_templates_for_document(self, account_id, document_id, envelope_id, **kwargs): 11138 """ 11139 Gets the templates associated with a document in an existing envelope. 11140 Retrieves the templates associated with a document in the specified envelope. 11141 This method makes a synchronous HTTP request by default. To make an 11142 asynchronous HTTP request, please define a `callback` function 11143 to be invoked when receiving the response. 11144 >>> def callback_function(response): 11145 >>> pprint(response) 11146 >>> 11147 >>> thread = api.list_templates_for_document(account_id, document_id, envelope_id, callback=callback_function) 11148 11149 :param callback function: The callback function 11150 for asynchronous request. (optional) 11151 :param str account_id: The external account number (int) or account ID Guid. (required) 11152 :param str document_id: The ID of the document being accessed. (required) 11153 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11154 :param str include: 11155 :return: TemplateInformation 11156 If the method is called asynchronously, 11157 returns the request thread. 11158 """ 11159 kwargs['_return_http_data_only'] = True 11160 if kwargs.get('callback'): 11161 return self.list_templates_for_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 11162 else: 11163 (data) = self.list_templates_for_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 11164 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)
11166 def list_templates_for_document_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 11167 """ 11168 Gets the templates associated with a document in an existing envelope. 11169 Retrieves the templates associated with a document in the specified envelope. 11170 This method makes a synchronous HTTP request by default. To make an 11171 asynchronous HTTP request, please define a `callback` function 11172 to be invoked when receiving the response. 11173 >>> def callback_function(response): 11174 >>> pprint(response) 11175 >>> 11176 >>> thread = api.list_templates_for_document_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 11177 11178 :param callback function: The callback function 11179 for asynchronous request. (optional) 11180 :param str account_id: The external account number (int) or account ID Guid. (required) 11181 :param str document_id: The ID of the document being accessed. (required) 11182 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11183 :param str include: 11184 :return: TemplateInformation 11185 If the method is called asynchronously, 11186 returns the request thread. 11187 """ 11188 11189 all_params = ['account_id', 'document_id', 'envelope_id', 'include'] 11190 all_params.append('callback') 11191 all_params.append('_return_http_data_only') 11192 all_params.append('_preload_content') 11193 all_params.append('_request_timeout') 11194 11195 params = locals() 11196 for key, val in iteritems(params['kwargs']): 11197 if key not in all_params: 11198 raise TypeError( 11199 "Got an unexpected keyword argument '%s'" 11200 " to method list_templates_for_document" % key 11201 ) 11202 params[key] = val 11203 del params['kwargs'] 11204 # verify the required parameter 'account_id' is set 11205 if ('account_id' not in params) or (params['account_id'] is None): 11206 raise ValueError("Missing the required parameter `account_id` when calling `list_templates_for_document`") 11207 # verify the required parameter 'document_id' is set 11208 if ('document_id' not in params) or (params['document_id'] is None): 11209 raise ValueError("Missing the required parameter `document_id` when calling `list_templates_for_document`") 11210 # verify the required parameter 'envelope_id' is set 11211 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11212 raise ValueError("Missing the required parameter `envelope_id` when calling `list_templates_for_document`") 11213 11214 11215 collection_formats = {} 11216 11217 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/templates'.replace('{format}', 'json') 11218 path_params = {} 11219 if 'account_id' in params: 11220 path_params['accountId'] = params['account_id'] 11221 if 'document_id' in params: 11222 path_params['documentId'] = params['document_id'] 11223 if 'envelope_id' in params: 11224 path_params['envelopeId'] = params['envelope_id'] 11225 11226 query_params = {} 11227 if 'include' in params: 11228 query_params['include'] = params['include'] 11229 11230 header_params = {} 11231 11232 form_params = [] 11233 local_var_files = {} 11234 11235 body_params = None 11236 # HTTP header `Accept` 11237 header_params['Accept'] = self.api_client.\ 11238 select_header_accept(['application/json']) 11239 11240 # Authentication setting 11241 auth_settings = [] 11242 11243 return self.api_client.call_api(resource_path, 'GET', 11244 path_params, 11245 query_params, 11246 header_params, 11247 body=body_params, 11248 post_params=form_params, 11249 files=local_var_files, 11250 response_type='TemplateInformation', 11251 auth_settings=auth_settings, 11252 callback=params.get('callback'), 11253 _return_http_data_only=params.get('_return_http_data_only'), 11254 _preload_content=params.get('_preload_content', True), 11255 _request_timeout=params.get('_request_timeout'), 11256 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)
11258 def put_attachment(self, account_id, attachment_id, envelope_id, **kwargs): 11259 """ 11260 Add an attachment to a DRAFT or IN-PROCESS envelope. 11261 Adds an attachment to a draft or in-process envelope. 11262 This method makes a synchronous HTTP request by default. To make an 11263 asynchronous HTTP request, please define a `callback` function 11264 to be invoked when receiving the response. 11265 >>> def callback_function(response): 11266 >>> pprint(response) 11267 >>> 11268 >>> thread = api.put_attachment(account_id, attachment_id, envelope_id, callback=callback_function) 11269 11270 :param callback function: The callback function 11271 for asynchronous request. (optional) 11272 :param str account_id: The external account number (int) or account ID Guid. (required) 11273 :param str attachment_id: (required) 11274 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11275 :param Attachment attachment: 11276 :return: EnvelopeAttachmentsResult 11277 If the method is called asynchronously, 11278 returns the request thread. 11279 """ 11280 kwargs['_return_http_data_only'] = True 11281 if kwargs.get('callback'): 11282 return self.put_attachment_with_http_info(account_id, attachment_id, envelope_id, **kwargs) 11283 else: 11284 (data) = self.put_attachment_with_http_info(account_id, attachment_id, envelope_id, **kwargs) 11285 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)
11287 def put_attachment_with_http_info(self, account_id, attachment_id, envelope_id, **kwargs): 11288 """ 11289 Add an attachment to a DRAFT or IN-PROCESS envelope. 11290 Adds an attachment to a draft or in-process envelope. 11291 This method makes a synchronous HTTP request by default. To make an 11292 asynchronous HTTP request, please define a `callback` function 11293 to be invoked when receiving the response. 11294 >>> def callback_function(response): 11295 >>> pprint(response) 11296 >>> 11297 >>> thread = api.put_attachment_with_http_info(account_id, attachment_id, envelope_id, callback=callback_function) 11298 11299 :param callback function: The callback function 11300 for asynchronous request. (optional) 11301 :param str account_id: The external account number (int) or account ID Guid. (required) 11302 :param str attachment_id: (required) 11303 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11304 :param Attachment attachment: 11305 :return: EnvelopeAttachmentsResult 11306 If the method is called asynchronously, 11307 returns the request thread. 11308 """ 11309 11310 all_params = ['account_id', 'attachment_id', 'envelope_id', 'attachment'] 11311 all_params.append('callback') 11312 all_params.append('_return_http_data_only') 11313 all_params.append('_preload_content') 11314 all_params.append('_request_timeout') 11315 11316 params = locals() 11317 for key, val in iteritems(params['kwargs']): 11318 if key not in all_params: 11319 raise TypeError( 11320 "Got an unexpected keyword argument '%s'" 11321 " to method put_attachment" % key 11322 ) 11323 params[key] = val 11324 del params['kwargs'] 11325 # verify the required parameter 'account_id' is set 11326 if ('account_id' not in params) or (params['account_id'] is None): 11327 raise ValueError("Missing the required parameter `account_id` when calling `put_attachment`") 11328 # verify the required parameter 'attachment_id' is set 11329 if ('attachment_id' not in params) or (params['attachment_id'] is None): 11330 raise ValueError("Missing the required parameter `attachment_id` when calling `put_attachment`") 11331 # verify the required parameter 'envelope_id' is set 11332 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11333 raise ValueError("Missing the required parameter `envelope_id` when calling `put_attachment`") 11334 11335 11336 collection_formats = {} 11337 11338 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments/{attachmentId}'.replace('{format}', 'json') 11339 path_params = {} 11340 if 'account_id' in params: 11341 path_params['accountId'] = params['account_id'] 11342 if 'attachment_id' in params: 11343 path_params['attachmentId'] = params['attachment_id'] 11344 if 'envelope_id' in params: 11345 path_params['envelopeId'] = params['envelope_id'] 11346 11347 query_params = {} 11348 11349 header_params = {} 11350 11351 form_params = [] 11352 local_var_files = {} 11353 11354 body_params = None 11355 if 'attachment' in params: 11356 body_params = params['attachment'] 11357 # HTTP header `Accept` 11358 header_params['Accept'] = self.api_client.\ 11359 select_header_accept(['application/json']) 11360 11361 # Authentication setting 11362 auth_settings = [] 11363 11364 return self.api_client.call_api(resource_path, 'PUT', 11365 path_params, 11366 query_params, 11367 header_params, 11368 body=body_params, 11369 post_params=form_params, 11370 files=local_var_files, 11371 response_type='EnvelopeAttachmentsResult', 11372 auth_settings=auth_settings, 11373 callback=params.get('callback'), 11374 _return_http_data_only=params.get('_return_http_data_only'), 11375 _preload_content=params.get('_preload_content', True), 11376 _request_timeout=params.get('_request_timeout'), 11377 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)
11379 def put_attachments(self, account_id, envelope_id, **kwargs): 11380 """ 11381 Add one or more attachments to a DRAFT or IN-PROCESS envelope. 11382 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). 11383 This method makes a synchronous HTTP request by default. To make an 11384 asynchronous HTTP request, please define a `callback` function 11385 to be invoked when receiving the response. 11386 >>> def callback_function(response): 11387 >>> pprint(response) 11388 >>> 11389 >>> thread = api.put_attachments(account_id, envelope_id, callback=callback_function) 11390 11391 :param callback function: The callback function 11392 for asynchronous request. (optional) 11393 :param str account_id: The external account number (int) or account ID Guid. (required) 11394 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11395 :param EnvelopeAttachmentsRequest envelope_attachments_request: 11396 :return: EnvelopeAttachmentsResult 11397 If the method is called asynchronously, 11398 returns the request thread. 11399 """ 11400 kwargs['_return_http_data_only'] = True 11401 if kwargs.get('callback'): 11402 return self.put_attachments_with_http_info(account_id, envelope_id, **kwargs) 11403 else: 11404 (data) = self.put_attachments_with_http_info(account_id, envelope_id, **kwargs) 11405 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)
11407 def put_attachments_with_http_info(self, account_id, envelope_id, **kwargs): 11408 """ 11409 Add one or more attachments to a DRAFT or IN-PROCESS envelope. 11410 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). 11411 This method makes a synchronous HTTP request by default. To make an 11412 asynchronous HTTP request, please define a `callback` function 11413 to be invoked when receiving the response. 11414 >>> def callback_function(response): 11415 >>> pprint(response) 11416 >>> 11417 >>> thread = api.put_attachments_with_http_info(account_id, envelope_id, callback=callback_function) 11418 11419 :param callback function: The callback function 11420 for asynchronous request. (optional) 11421 :param str account_id: The external account number (int) or account ID Guid. (required) 11422 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11423 :param EnvelopeAttachmentsRequest envelope_attachments_request: 11424 :return: EnvelopeAttachmentsResult 11425 If the method is called asynchronously, 11426 returns the request thread. 11427 """ 11428 11429 all_params = ['account_id', 'envelope_id', 'envelope_attachments_request'] 11430 all_params.append('callback') 11431 all_params.append('_return_http_data_only') 11432 all_params.append('_preload_content') 11433 all_params.append('_request_timeout') 11434 11435 params = locals() 11436 for key, val in iteritems(params['kwargs']): 11437 if key not in all_params: 11438 raise TypeError( 11439 "Got an unexpected keyword argument '%s'" 11440 " to method put_attachments" % key 11441 ) 11442 params[key] = val 11443 del params['kwargs'] 11444 # verify the required parameter 'account_id' is set 11445 if ('account_id' not in params) or (params['account_id'] is None): 11446 raise ValueError("Missing the required parameter `account_id` when calling `put_attachments`") 11447 # verify the required parameter 'envelope_id' is set 11448 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11449 raise ValueError("Missing the required parameter `envelope_id` when calling `put_attachments`") 11450 11451 11452 collection_formats = {} 11453 11454 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments'.replace('{format}', 'json') 11455 path_params = {} 11456 if 'account_id' in params: 11457 path_params['accountId'] = params['account_id'] 11458 if 'envelope_id' in params: 11459 path_params['envelopeId'] = params['envelope_id'] 11460 11461 query_params = {} 11462 11463 header_params = {} 11464 11465 form_params = [] 11466 local_var_files = {} 11467 11468 body_params = None 11469 if 'envelope_attachments_request' in params: 11470 body_params = params['envelope_attachments_request'] 11471 # HTTP header `Accept` 11472 header_params['Accept'] = self.api_client.\ 11473 select_header_accept(['application/json']) 11474 11475 # Authentication setting 11476 auth_settings = [] 11477 11478 return self.api_client.call_api(resource_path, 'PUT', 11479 path_params, 11480 query_params, 11481 header_params, 11482 body=body_params, 11483 post_params=form_params, 11484 files=local_var_files, 11485 response_type='EnvelopeAttachmentsResult', 11486 auth_settings=auth_settings, 11487 callback=params.get('callback'), 11488 _return_http_data_only=params.get('_return_http_data_only'), 11489 _preload_content=params.get('_preload_content', True), 11490 _request_timeout=params.get('_request_timeout'), 11491 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)
11493 def rotate_document_page(self, account_id, document_id, envelope_id, page_number, **kwargs): 11494 """ 11495 Rotates page image from an envelope for display. 11496 Rotates page image from an envelope for display. The page image can be rotated to the left or right. 11497 This method makes a synchronous HTTP request by default. To make an 11498 asynchronous HTTP request, please define a `callback` function 11499 to be invoked when receiving the response. 11500 >>> def callback_function(response): 11501 >>> pprint(response) 11502 >>> 11503 >>> thread = api.rotate_document_page(account_id, document_id, envelope_id, page_number, callback=callback_function) 11504 11505 :param callback function: The callback function 11506 for asynchronous request. (optional) 11507 :param str account_id: The external account number (int) or account ID Guid. (required) 11508 :param str document_id: The ID of the document being accessed. (required) 11509 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11510 :param str page_number: The page number being accessed. (required) 11511 :param PageRequest page_request: 11512 :return: None 11513 If the method is called asynchronously, 11514 returns the request thread. 11515 """ 11516 kwargs['_return_http_data_only'] = True 11517 if kwargs.get('callback'): 11518 return self.rotate_document_page_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 11519 else: 11520 (data) = self.rotate_document_page_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 11521 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)
11523 def rotate_document_page_with_http_info(self, account_id, document_id, envelope_id, page_number, **kwargs): 11524 """ 11525 Rotates page image from an envelope for display. 11526 Rotates page image from an envelope for display. The page image can be rotated to the left or right. 11527 This method makes a synchronous HTTP request by default. To make an 11528 asynchronous HTTP request, please define a `callback` function 11529 to be invoked when receiving the response. 11530 >>> def callback_function(response): 11531 >>> pprint(response) 11532 >>> 11533 >>> thread = api.rotate_document_page_with_http_info(account_id, document_id, envelope_id, page_number, callback=callback_function) 11534 11535 :param callback function: The callback function 11536 for asynchronous request. (optional) 11537 :param str account_id: The external account number (int) or account ID Guid. (required) 11538 :param str document_id: The ID of the document being accessed. (required) 11539 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11540 :param str page_number: The page number being accessed. (required) 11541 :param PageRequest page_request: 11542 :return: None 11543 If the method is called asynchronously, 11544 returns the request thread. 11545 """ 11546 11547 all_params = ['account_id', 'document_id', 'envelope_id', 'page_number', 'page_request'] 11548 all_params.append('callback') 11549 all_params.append('_return_http_data_only') 11550 all_params.append('_preload_content') 11551 all_params.append('_request_timeout') 11552 11553 params = locals() 11554 for key, val in iteritems(params['kwargs']): 11555 if key not in all_params: 11556 raise TypeError( 11557 "Got an unexpected keyword argument '%s'" 11558 " to method rotate_document_page" % key 11559 ) 11560 params[key] = val 11561 del params['kwargs'] 11562 # verify the required parameter 'account_id' is set 11563 if ('account_id' not in params) or (params['account_id'] is None): 11564 raise ValueError("Missing the required parameter `account_id` when calling `rotate_document_page`") 11565 # verify the required parameter 'document_id' is set 11566 if ('document_id' not in params) or (params['document_id'] is None): 11567 raise ValueError("Missing the required parameter `document_id` when calling `rotate_document_page`") 11568 # verify the required parameter 'envelope_id' is set 11569 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11570 raise ValueError("Missing the required parameter `envelope_id` when calling `rotate_document_page`") 11571 # verify the required parameter 'page_number' is set 11572 if ('page_number' not in params) or (params['page_number'] is None): 11573 raise ValueError("Missing the required parameter `page_number` when calling `rotate_document_page`") 11574 11575 11576 collection_formats = {} 11577 11578 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/pages/{pageNumber}/page_image'.replace('{format}', 'json') 11579 path_params = {} 11580 if 'account_id' in params: 11581 path_params['accountId'] = params['account_id'] 11582 if 'document_id' in params: 11583 path_params['documentId'] = params['document_id'] 11584 if 'envelope_id' in params: 11585 path_params['envelopeId'] = params['envelope_id'] 11586 if 'page_number' in params: 11587 path_params['pageNumber'] = params['page_number'] 11588 11589 query_params = {} 11590 11591 header_params = {} 11592 11593 form_params = [] 11594 local_var_files = {} 11595 11596 body_params = None 11597 if 'page_request' in params: 11598 body_params = params['page_request'] 11599 # HTTP header `Accept` 11600 header_params['Accept'] = self.api_client.\ 11601 select_header_accept(['application/json']) 11602 11603 # Authentication setting 11604 auth_settings = [] 11605 11606 return self.api_client.call_api(resource_path, 'PUT', 11607 path_params, 11608 query_params, 11609 header_params, 11610 body=body_params, 11611 post_params=form_params, 11612 files=local_var_files, 11613 response_type=None, 11614 auth_settings=auth_settings, 11615 callback=params.get('callback'), 11616 _return_http_data_only=params.get('_return_http_data_only'), 11617 _preload_content=params.get('_preload_content', True), 11618 _request_timeout=params.get('_request_timeout'), 11619 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)
11621 def update(self, account_id, envelope_id, **kwargs): 11622 """ 11623 Send Draft Envelope/Void Envelope/Move/Purge Envelope/Modify draft 11624 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. 11625 This method makes a synchronous HTTP request by default. To make an 11626 asynchronous HTTP request, please define a `callback` function 11627 to be invoked when receiving the response. 11628 >>> def callback_function(response): 11629 >>> pprint(response) 11630 >>> 11631 >>> thread = api.update(account_id, envelope_id, callback=callback_function) 11632 11633 :param callback function: The callback function 11634 for asynchronous request. (optional) 11635 :param str account_id: The external account number (int) or account ID Guid. (required) 11636 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11637 :param str advanced_update: When set to **true**, allows the caller to update recipients, tabs, custom fields, notification, email settings and other envelope attributes. 11638 :param str recycle_on_void: 11639 :param str resend_envelope: When set to **true**, sends the specified envelope again. 11640 :param Envelope envelope: 11641 :return: EnvelopeUpdateSummary 11642 If the method is called asynchronously, 11643 returns the request thread. 11644 """ 11645 kwargs['_return_http_data_only'] = True 11646 if kwargs.get('callback'): 11647 return self.update_with_http_info(account_id, envelope_id, **kwargs) 11648 else: 11649 (data) = self.update_with_http_info(account_id, envelope_id, **kwargs) 11650 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)
11652 def update_with_http_info(self, account_id, envelope_id, **kwargs): 11653 """ 11654 Send Draft Envelope/Void Envelope/Move/Purge Envelope/Modify draft 11655 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. 11656 This method makes a synchronous HTTP request by default. To make an 11657 asynchronous HTTP request, please define a `callback` function 11658 to be invoked when receiving the response. 11659 >>> def callback_function(response): 11660 >>> pprint(response) 11661 >>> 11662 >>> thread = api.update_with_http_info(account_id, envelope_id, callback=callback_function) 11663 11664 :param callback function: The callback function 11665 for asynchronous request. (optional) 11666 :param str account_id: The external account number (int) or account ID Guid. (required) 11667 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11668 :param str advanced_update: When set to **true**, allows the caller to update recipients, tabs, custom fields, notification, email settings and other envelope attributes. 11669 :param str recycle_on_void: 11670 :param str resend_envelope: When set to **true**, sends the specified envelope again. 11671 :param Envelope envelope: 11672 :return: EnvelopeUpdateSummary 11673 If the method is called asynchronously, 11674 returns the request thread. 11675 """ 11676 11677 all_params = ['account_id', 'envelope_id', 'advanced_update', 'recycle_on_void', 'resend_envelope', 'envelope'] 11678 all_params.append('callback') 11679 all_params.append('_return_http_data_only') 11680 all_params.append('_preload_content') 11681 all_params.append('_request_timeout') 11682 11683 params = locals() 11684 for key, val in iteritems(params['kwargs']): 11685 if key not in all_params: 11686 raise TypeError( 11687 "Got an unexpected keyword argument '%s'" 11688 " to method update" % key 11689 ) 11690 params[key] = val 11691 del params['kwargs'] 11692 # verify the required parameter 'account_id' is set 11693 if ('account_id' not in params) or (params['account_id'] is None): 11694 raise ValueError("Missing the required parameter `account_id` when calling `update`") 11695 # verify the required parameter 'envelope_id' is set 11696 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11697 raise ValueError("Missing the required parameter `envelope_id` when calling `update`") 11698 11699 11700 collection_formats = {} 11701 11702 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}'.replace('{format}', 'json') 11703 path_params = {} 11704 if 'account_id' in params: 11705 path_params['accountId'] = params['account_id'] 11706 if 'envelope_id' in params: 11707 path_params['envelopeId'] = params['envelope_id'] 11708 11709 query_params = {} 11710 if 'advanced_update' in params: 11711 query_params['advanced_update'] = params['advanced_update'] 11712 if 'recycle_on_void' in params: 11713 query_params['recycle_on_void'] = params['recycle_on_void'] 11714 if 'resend_envelope' in params: 11715 query_params['resend_envelope'] = params['resend_envelope'] 11716 11717 header_params = {} 11718 11719 form_params = [] 11720 local_var_files = {} 11721 11722 body_params = None 11723 if 'envelope' in params: 11724 body_params = params['envelope'] 11725 # HTTP header `Accept` 11726 header_params['Accept'] = self.api_client.\ 11727 select_header_accept(['application/json']) 11728 11729 # Authentication setting 11730 auth_settings = [] 11731 11732 return self.api_client.call_api(resource_path, 'PUT', 11733 path_params, 11734 query_params, 11735 header_params, 11736 body=body_params, 11737 post_params=form_params, 11738 files=local_var_files, 11739 response_type='EnvelopeUpdateSummary', 11740 auth_settings=auth_settings, 11741 callback=params.get('callback'), 11742 _return_http_data_only=params.get('_return_http_data_only'), 11743 _preload_content=params.get('_preload_content', True), 11744 _request_timeout=params.get('_request_timeout'), 11745 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)
11747 def update_chunked_upload(self, account_id, chunked_upload_id, **kwargs): 11748 """ 11749 Integrity-Check and Commit a ChunkedUpload, readying it for use elsewhere. 11750 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. 11751 This method makes a synchronous HTTP request by default. To make an 11752 asynchronous HTTP request, please define a `callback` function 11753 to be invoked when receiving the response. 11754 >>> def callback_function(response): 11755 >>> pprint(response) 11756 >>> 11757 >>> thread = api.update_chunked_upload(account_id, chunked_upload_id, callback=callback_function) 11758 11759 :param callback function: The callback function 11760 for asynchronous request. (optional) 11761 :param str account_id: The external account number (int) or account ID Guid. (required) 11762 :param str chunked_upload_id: (required) 11763 :param str action: 11764 :return: ChunkedUploadResponse 11765 If the method is called asynchronously, 11766 returns the request thread. 11767 """ 11768 kwargs['_return_http_data_only'] = True 11769 if kwargs.get('callback'): 11770 return self.update_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 11771 else: 11772 (data) = self.update_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 11773 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)
11775 def update_chunked_upload_with_http_info(self, account_id, chunked_upload_id, **kwargs): 11776 """ 11777 Integrity-Check and Commit a ChunkedUpload, readying it for use elsewhere. 11778 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. 11779 This method makes a synchronous HTTP request by default. To make an 11780 asynchronous HTTP request, please define a `callback` function 11781 to be invoked when receiving the response. 11782 >>> def callback_function(response): 11783 >>> pprint(response) 11784 >>> 11785 >>> thread = api.update_chunked_upload_with_http_info(account_id, chunked_upload_id, callback=callback_function) 11786 11787 :param callback function: The callback function 11788 for asynchronous request. (optional) 11789 :param str account_id: The external account number (int) or account ID Guid. (required) 11790 :param str chunked_upload_id: (required) 11791 :param str action: 11792 :return: ChunkedUploadResponse 11793 If the method is called asynchronously, 11794 returns the request thread. 11795 """ 11796 11797 all_params = ['account_id', 'chunked_upload_id', 'action'] 11798 all_params.append('callback') 11799 all_params.append('_return_http_data_only') 11800 all_params.append('_preload_content') 11801 all_params.append('_request_timeout') 11802 11803 params = locals() 11804 for key, val in iteritems(params['kwargs']): 11805 if key not in all_params: 11806 raise TypeError( 11807 "Got an unexpected keyword argument '%s'" 11808 " to method update_chunked_upload" % key 11809 ) 11810 params[key] = val 11811 del params['kwargs'] 11812 # verify the required parameter 'account_id' is set 11813 if ('account_id' not in params) or (params['account_id'] is None): 11814 raise ValueError("Missing the required parameter `account_id` when calling `update_chunked_upload`") 11815 # verify the required parameter 'chunked_upload_id' is set 11816 if ('chunked_upload_id' not in params) or (params['chunked_upload_id'] is None): 11817 raise ValueError("Missing the required parameter `chunked_upload_id` when calling `update_chunked_upload`") 11818 11819 11820 collection_formats = {} 11821 11822 resource_path = '/v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}'.replace('{format}', 'json') 11823 path_params = {} 11824 if 'account_id' in params: 11825 path_params['accountId'] = params['account_id'] 11826 if 'chunked_upload_id' in params: 11827 path_params['chunkedUploadId'] = params['chunked_upload_id'] 11828 11829 query_params = {} 11830 if 'action' in params: 11831 query_params['action'] = params['action'] 11832 11833 header_params = {} 11834 11835 form_params = [] 11836 local_var_files = {} 11837 11838 body_params = None 11839 # HTTP header `Accept` 11840 header_params['Accept'] = self.api_client.\ 11841 select_header_accept(['application/json']) 11842 11843 # Authentication setting 11844 auth_settings = [] 11845 11846 return self.api_client.call_api(resource_path, 'PUT', 11847 path_params, 11848 query_params, 11849 header_params, 11850 body=body_params, 11851 post_params=form_params, 11852 files=local_var_files, 11853 response_type='ChunkedUploadResponse', 11854 auth_settings=auth_settings, 11855 callback=params.get('callback'), 11856 _return_http_data_only=params.get('_return_http_data_only'), 11857 _preload_content=params.get('_preload_content', True), 11858 _request_timeout=params.get('_request_timeout'), 11859 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)
11861 def update_chunked_upload_part(self, account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs): 11862 """ 11863 Add a chunk, a chunk 'part', to an existing ChunkedUpload. 11864 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. 11865 This method makes a synchronous HTTP request by default. To make an 11866 asynchronous HTTP request, please define a `callback` function 11867 to be invoked when receiving the response. 11868 >>> def callback_function(response): 11869 >>> pprint(response) 11870 >>> 11871 >>> thread = api.update_chunked_upload_part(account_id, chunked_upload_id, chunked_upload_part_seq, callback=callback_function) 11872 11873 :param callback function: The callback function 11874 for asynchronous request. (optional) 11875 :param str account_id: The external account number (int) or account ID Guid. (required) 11876 :param str chunked_upload_id: (required) 11877 :param str chunked_upload_part_seq: (required) 11878 :param ChunkedUploadRequest chunked_upload_request: 11879 :return: ChunkedUploadResponse 11880 If the method is called asynchronously, 11881 returns the request thread. 11882 """ 11883 kwargs['_return_http_data_only'] = True 11884 if kwargs.get('callback'): 11885 return self.update_chunked_upload_part_with_http_info(account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs) 11886 else: 11887 (data) = self.update_chunked_upload_part_with_http_info(account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs) 11888 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)
11890 def update_chunked_upload_part_with_http_info(self, account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs): 11891 """ 11892 Add a chunk, a chunk 'part', to an existing ChunkedUpload. 11893 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. 11894 This method makes a synchronous HTTP request by default. To make an 11895 asynchronous HTTP request, please define a `callback` function 11896 to be invoked when receiving the response. 11897 >>> def callback_function(response): 11898 >>> pprint(response) 11899 >>> 11900 >>> thread = api.update_chunked_upload_part_with_http_info(account_id, chunked_upload_id, chunked_upload_part_seq, callback=callback_function) 11901 11902 :param callback function: The callback function 11903 for asynchronous request. (optional) 11904 :param str account_id: The external account number (int) or account ID Guid. (required) 11905 :param str chunked_upload_id: (required) 11906 :param str chunked_upload_part_seq: (required) 11907 :param ChunkedUploadRequest chunked_upload_request: 11908 :return: ChunkedUploadResponse 11909 If the method is called asynchronously, 11910 returns the request thread. 11911 """ 11912 11913 all_params = ['account_id', 'chunked_upload_id', 'chunked_upload_part_seq', 'chunked_upload_request'] 11914 all_params.append('callback') 11915 all_params.append('_return_http_data_only') 11916 all_params.append('_preload_content') 11917 all_params.append('_request_timeout') 11918 11919 params = locals() 11920 for key, val in iteritems(params['kwargs']): 11921 if key not in all_params: 11922 raise TypeError( 11923 "Got an unexpected keyword argument '%s'" 11924 " to method update_chunked_upload_part" % key 11925 ) 11926 params[key] = val 11927 del params['kwargs'] 11928 # verify the required parameter 'account_id' is set 11929 if ('account_id' not in params) or (params['account_id'] is None): 11930 raise ValueError("Missing the required parameter `account_id` when calling `update_chunked_upload_part`") 11931 # verify the required parameter 'chunked_upload_id' is set 11932 if ('chunked_upload_id' not in params) or (params['chunked_upload_id'] is None): 11933 raise ValueError("Missing the required parameter `chunked_upload_id` when calling `update_chunked_upload_part`") 11934 # verify the required parameter 'chunked_upload_part_seq' is set 11935 if ('chunked_upload_part_seq' not in params) or (params['chunked_upload_part_seq'] is None): 11936 raise ValueError("Missing the required parameter `chunked_upload_part_seq` when calling `update_chunked_upload_part`") 11937 11938 11939 collection_formats = {} 11940 11941 resource_path = '/v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}/{chunkedUploadPartSeq}'.replace('{format}', 'json') 11942 path_params = {} 11943 if 'account_id' in params: 11944 path_params['accountId'] = params['account_id'] 11945 if 'chunked_upload_id' in params: 11946 path_params['chunkedUploadId'] = params['chunked_upload_id'] 11947 if 'chunked_upload_part_seq' in params: 11948 path_params['chunkedUploadPartSeq'] = params['chunked_upload_part_seq'] 11949 11950 query_params = {} 11951 11952 header_params = {} 11953 11954 form_params = [] 11955 local_var_files = {} 11956 11957 body_params = None 11958 if 'chunked_upload_request' in params: 11959 body_params = params['chunked_upload_request'] 11960 # HTTP header `Accept` 11961 header_params['Accept'] = self.api_client.\ 11962 select_header_accept(['application/json']) 11963 11964 # Authentication setting 11965 auth_settings = [] 11966 11967 return self.api_client.call_api(resource_path, 'PUT', 11968 path_params, 11969 query_params, 11970 header_params, 11971 body=body_params, 11972 post_params=form_params, 11973 files=local_var_files, 11974 response_type='ChunkedUploadResponse', 11975 auth_settings=auth_settings, 11976 callback=params.get('callback'), 11977 _return_http_data_only=params.get('_return_http_data_only'), 11978 _preload_content=params.get('_preload_content', True), 11979 _request_timeout=params.get('_request_timeout'), 11980 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)
11982 def update_custom_fields(self, account_id, envelope_id, **kwargs): 11983 """ 11984 Updates envelope custom fields in an envelope. 11985 Updates the envelope custom fields in draft and in-process envelopes. Each custom field used in an envelope must have a unique name. 11986 This method makes a synchronous HTTP request by default. To make an 11987 asynchronous HTTP request, please define a `callback` function 11988 to be invoked when receiving the response. 11989 >>> def callback_function(response): 11990 >>> pprint(response) 11991 >>> 11992 >>> thread = api.update_custom_fields(account_id, envelope_id, callback=callback_function) 11993 11994 :param callback function: The callback function 11995 for asynchronous request. (optional) 11996 :param str account_id: The external account number (int) or account ID Guid. (required) 11997 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11998 :param CustomFields custom_fields: 11999 :return: CustomFields 12000 If the method is called asynchronously, 12001 returns the request thread. 12002 """ 12003 kwargs['_return_http_data_only'] = True 12004 if kwargs.get('callback'): 12005 return self.update_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 12006 else: 12007 (data) = self.update_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 12008 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)
12010 def update_custom_fields_with_http_info(self, account_id, envelope_id, **kwargs): 12011 """ 12012 Updates envelope custom fields in an envelope. 12013 Updates the envelope custom fields in draft and in-process envelopes. Each custom field used in an envelope must have a unique name. 12014 This method makes a synchronous HTTP request by default. To make an 12015 asynchronous HTTP request, please define a `callback` function 12016 to be invoked when receiving the response. 12017 >>> def callback_function(response): 12018 >>> pprint(response) 12019 >>> 12020 >>> thread = api.update_custom_fields_with_http_info(account_id, envelope_id, callback=callback_function) 12021 12022 :param callback function: The callback function 12023 for asynchronous request. (optional) 12024 :param str account_id: The external account number (int) or account ID Guid. (required) 12025 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12026 :param CustomFields custom_fields: 12027 :return: CustomFields 12028 If the method is called asynchronously, 12029 returns the request thread. 12030 """ 12031 12032 all_params = ['account_id', 'envelope_id', 'custom_fields'] 12033 all_params.append('callback') 12034 all_params.append('_return_http_data_only') 12035 all_params.append('_preload_content') 12036 all_params.append('_request_timeout') 12037 12038 params = locals() 12039 for key, val in iteritems(params['kwargs']): 12040 if key not in all_params: 12041 raise TypeError( 12042 "Got an unexpected keyword argument '%s'" 12043 " to method update_custom_fields" % key 12044 ) 12045 params[key] = val 12046 del params['kwargs'] 12047 # verify the required parameter 'account_id' is set 12048 if ('account_id' not in params) or (params['account_id'] is None): 12049 raise ValueError("Missing the required parameter `account_id` when calling `update_custom_fields`") 12050 # verify the required parameter 'envelope_id' is set 12051 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12052 raise ValueError("Missing the required parameter `envelope_id` when calling `update_custom_fields`") 12053 12054 12055 collection_formats = {} 12056 12057 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/custom_fields'.replace('{format}', 'json') 12058 path_params = {} 12059 if 'account_id' in params: 12060 path_params['accountId'] = params['account_id'] 12061 if 'envelope_id' in params: 12062 path_params['envelopeId'] = params['envelope_id'] 12063 12064 query_params = {} 12065 12066 header_params = {} 12067 12068 form_params = [] 12069 local_var_files = {} 12070 12071 body_params = None 12072 if 'custom_fields' in params: 12073 body_params = params['custom_fields'] 12074 # HTTP header `Accept` 12075 header_params['Accept'] = self.api_client.\ 12076 select_header_accept(['application/json']) 12077 12078 # Authentication setting 12079 auth_settings = [] 12080 12081 return self.api_client.call_api(resource_path, 'PUT', 12082 path_params, 12083 query_params, 12084 header_params, 12085 body=body_params, 12086 post_params=form_params, 12087 files=local_var_files, 12088 response_type='CustomFields', 12089 auth_settings=auth_settings, 12090 callback=params.get('callback'), 12091 _return_http_data_only=params.get('_return_http_data_only'), 12092 _preload_content=params.get('_preload_content', True), 12093 _request_timeout=params.get('_request_timeout'), 12094 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)
12096 def update_document(self, account_id, document_id, envelope_id, document_file_bytes, **kwargs): 12097 """ 12098 Adds a document to an existing draft envelope. 12099 Adds a document to an existing draft envelope. 12100 This method makes a synchronous HTTP request by default. To make an 12101 asynchronous HTTP request, please define a `callback` function 12102 to be invoked when receiving the response. 12103 >>> def callback_function(response): 12104 >>> pprint(response) 12105 >>> 12106 >>> thread = api.update_document(account_id, document_id, envelope_id, document_file_bytes, callback=callback_function) 12107 12108 :param callback function: The callback function 12109 for asynchronous request. (optional) 12110 :param str account_id: The external account number (int) or account ID Guid. (required) 12111 :param str document_id: The ID of the document being accessed. (required) 12112 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12113 :param str document_file_bytes: Updated document content. (required) 12114 :return: EnvelopeDocument 12115 If the method is called asynchronously, 12116 returns the request thread. 12117 """ 12118 kwargs['_return_http_data_only'] = True 12119 if kwargs.get('callback'): 12120 return self.update_document_with_http_info(account_id, document_id, envelope_id, document_file_bytes, **kwargs) 12121 else: 12122 (data) = self.update_document_with_http_info(account_id, document_id, envelope_id, document_file_bytes, **kwargs) 12123 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)
12125 def update_document_with_http_info(self, account_id, document_id, envelope_id, document_file_bytes, **kwargs): 12126 """ 12127 Adds a document to an existing draft envelope. 12128 Adds a document to an existing draft envelope. 12129 This method makes a synchronous HTTP request by default. To make an 12130 asynchronous HTTP request, please define a `callback` function 12131 to be invoked when receiving the response. 12132 >>> def callback_function(response): 12133 >>> pprint(response) 12134 >>> 12135 >>> thread = api.update_document_with_http_info(account_id, document_id, envelope_id, document_file_bytes, callback=callback_function) 12136 12137 :param callback function: The callback function 12138 for asynchronous request. (optional) 12139 :param str account_id: The external account number (int) or account ID Guid. (required) 12140 :param str document_id: The ID of the document being accessed. (required) 12141 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12142 :param str document_file_bytes: Updated document content. (required) 12143 :return: EnvelopeDocument 12144 If the method is called asynchronously, 12145 returns the request thread. 12146 """ 12147 12148 all_params = ['account_id', 'document_id', 'envelope_id', 'document_file_bytes'] 12149 all_params.append('callback') 12150 all_params.append('_return_http_data_only') 12151 all_params.append('_preload_content') 12152 all_params.append('_request_timeout') 12153 12154 params = locals() 12155 for key, val in iteritems(params['kwargs']): 12156 if key not in all_params: 12157 raise TypeError( 12158 "Got an unexpected keyword argument '%s'" 12159 " to method update_document" % key 12160 ) 12161 params[key] = val 12162 del params['kwargs'] 12163 # verify the required parameter 'account_id' is set 12164 if ('account_id' not in params) or (params['account_id'] is None): 12165 raise ValueError("Missing the required parameter `account_id` when calling `update_document`") 12166 # verify the required parameter 'document_id' is set 12167 if ('document_id' not in params) or (params['document_id'] is None): 12168 raise ValueError("Missing the required parameter `document_id` when calling `update_document`") 12169 # verify the required parameter 'envelope_id' is set 12170 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12171 raise ValueError("Missing the required parameter `envelope_id` when calling `update_document`") 12172 # verify the required parameter 'document_file_bytes' is set 12173 if ('document_file_bytes' not in params) or (params['document_file_bytes'] is None): 12174 raise ValueError("Missing the required parameter `document_file_bytes` when calling `update_document`") 12175 12176 12177 collection_formats = {} 12178 12179 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}'.replace('{format}', 'json') 12180 path_params = {} 12181 if 'account_id' in params: 12182 path_params['accountId'] = params['account_id'] 12183 if 'document_id' in params: 12184 path_params['documentId'] = params['document_id'] 12185 if 'envelope_id' in params: 12186 path_params['envelopeId'] = params['envelope_id'] 12187 12188 query_params = {} 12189 12190 header_params = {} 12191 12192 form_params = [] 12193 local_var_files = {} 12194 12195 body_params = None 12196 if 'document_file_bytes' in params: 12197 body_params = params['document_file_bytes'] 12198 # HTTP header `Accept` 12199 header_params['Accept'] = self.api_client.\ 12200 select_header_accept(['application/json']) 12201 12202 # HTTP header `Content-Type` 12203 header_params['Content-Type'] = self.api_client.\ 12204 select_header_content_type(['application/pdf']) 12205 12206 # Authentication setting 12207 auth_settings = [] 12208 12209 return self.api_client.call_api(resource_path, 'PUT', 12210 path_params, 12211 query_params, 12212 header_params, 12213 body=body_params, 12214 post_params=form_params, 12215 files=local_var_files, 12216 response_type='EnvelopeDocument', 12217 auth_settings=auth_settings, 12218 callback=params.get('callback'), 12219 _return_http_data_only=params.get('_return_http_data_only'), 12220 _preload_content=params.get('_preload_content', True), 12221 _request_timeout=params.get('_request_timeout'), 12222 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)
12224 def update_document_fields(self, account_id, document_id, envelope_id, **kwargs): 12225 """ 12226 Updates existing custom document fields in an existing envelope document. 12227 Updates existing custom document fields in an existing envelope document. 12228 This method makes a synchronous HTTP request by default. To make an 12229 asynchronous HTTP request, please define a `callback` function 12230 to be invoked when receiving the response. 12231 >>> def callback_function(response): 12232 >>> pprint(response) 12233 >>> 12234 >>> thread = api.update_document_fields(account_id, document_id, envelope_id, callback=callback_function) 12235 12236 :param callback function: The callback function 12237 for asynchronous request. (optional) 12238 :param str account_id: The external account number (int) or account ID Guid. (required) 12239 :param str document_id: The ID of the document being accessed. (required) 12240 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12241 :param DocumentFieldsInformation document_fields_information: 12242 :return: DocumentFieldsInformation 12243 If the method is called asynchronously, 12244 returns the request thread. 12245 """ 12246 kwargs['_return_http_data_only'] = True 12247 if kwargs.get('callback'): 12248 return self.update_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 12249 else: 12250 (data) = self.update_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 12251 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)
12253 def update_document_fields_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 12254 """ 12255 Updates existing custom document fields in an existing envelope document. 12256 Updates existing custom document fields in an existing envelope document. 12257 This method makes a synchronous HTTP request by default. To make an 12258 asynchronous HTTP request, please define a `callback` function 12259 to be invoked when receiving the response. 12260 >>> def callback_function(response): 12261 >>> pprint(response) 12262 >>> 12263 >>> thread = api.update_document_fields_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 12264 12265 :param callback function: The callback function 12266 for asynchronous request. (optional) 12267 :param str account_id: The external account number (int) or account ID Guid. (required) 12268 :param str document_id: The ID of the document being accessed. (required) 12269 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12270 :param DocumentFieldsInformation document_fields_information: 12271 :return: DocumentFieldsInformation 12272 If the method is called asynchronously, 12273 returns the request thread. 12274 """ 12275 12276 all_params = ['account_id', 'document_id', 'envelope_id', 'document_fields_information'] 12277 all_params.append('callback') 12278 all_params.append('_return_http_data_only') 12279 all_params.append('_preload_content') 12280 all_params.append('_request_timeout') 12281 12282 params = locals() 12283 for key, val in iteritems(params['kwargs']): 12284 if key not in all_params: 12285 raise TypeError( 12286 "Got an unexpected keyword argument '%s'" 12287 " to method update_document_fields" % key 12288 ) 12289 params[key] = val 12290 del params['kwargs'] 12291 # verify the required parameter 'account_id' is set 12292 if ('account_id' not in params) or (params['account_id'] is None): 12293 raise ValueError("Missing the required parameter `account_id` when calling `update_document_fields`") 12294 # verify the required parameter 'document_id' is set 12295 if ('document_id' not in params) or (params['document_id'] is None): 12296 raise ValueError("Missing the required parameter `document_id` when calling `update_document_fields`") 12297 # verify the required parameter 'envelope_id' is set 12298 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12299 raise ValueError("Missing the required parameter `envelope_id` when calling `update_document_fields`") 12300 12301 12302 collection_formats = {} 12303 12304 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/fields'.replace('{format}', 'json') 12305 path_params = {} 12306 if 'account_id' in params: 12307 path_params['accountId'] = params['account_id'] 12308 if 'document_id' in params: 12309 path_params['documentId'] = params['document_id'] 12310 if 'envelope_id' in params: 12311 path_params['envelopeId'] = params['envelope_id'] 12312 12313 query_params = {} 12314 12315 header_params = {} 12316 12317 form_params = [] 12318 local_var_files = {} 12319 12320 body_params = None 12321 if 'document_fields_information' in params: 12322 body_params = params['document_fields_information'] 12323 # HTTP header `Accept` 12324 header_params['Accept'] = self.api_client.\ 12325 select_header_accept(['application/json']) 12326 12327 # Authentication setting 12328 auth_settings = [] 12329 12330 return self.api_client.call_api(resource_path, 'PUT', 12331 path_params, 12332 query_params, 12333 header_params, 12334 body=body_params, 12335 post_params=form_params, 12336 files=local_var_files, 12337 response_type='DocumentFieldsInformation', 12338 auth_settings=auth_settings, 12339 callback=params.get('callback'), 12340 _return_http_data_only=params.get('_return_http_data_only'), 12341 _preload_content=params.get('_preload_content', True), 12342 _request_timeout=params.get('_request_timeout'), 12343 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)
12345 def update_document_tabs(self, account_id, document_id, envelope_id, **kwargs): 12346 """ 12347 Updates the tabs for an envelope document 12348 Updates tabs in the document specified by `documentId` in the envelope specified by `envelopeId`. 12349 This method makes a synchronous HTTP request by default. To make an 12350 asynchronous HTTP request, please define a `callback` function 12351 to be invoked when receiving the response. 12352 >>> def callback_function(response): 12353 >>> pprint(response) 12354 >>> 12355 >>> thread = api.update_document_tabs(account_id, document_id, envelope_id, callback=callback_function) 12356 12357 :param callback function: The callback function 12358 for asynchronous request. (optional) 12359 :param str account_id: The external account number (int) or account ID Guid. (required) 12360 :param str document_id: The ID of the document being accessed. (required) 12361 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12362 :param Tabs tabs: 12363 :return: Tabs 12364 If the method is called asynchronously, 12365 returns the request thread. 12366 """ 12367 kwargs['_return_http_data_only'] = True 12368 if kwargs.get('callback'): 12369 return self.update_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 12370 else: 12371 (data) = self.update_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 12372 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)
12374 def update_document_tabs_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 12375 """ 12376 Updates the tabs for an envelope document 12377 Updates tabs in the document specified by `documentId` in the envelope specified by `envelopeId`. 12378 This method makes a synchronous HTTP request by default. To make an 12379 asynchronous HTTP request, please define a `callback` function 12380 to be invoked when receiving the response. 12381 >>> def callback_function(response): 12382 >>> pprint(response) 12383 >>> 12384 >>> thread = api.update_document_tabs_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 12385 12386 :param callback function: The callback function 12387 for asynchronous request. (optional) 12388 :param str account_id: The external account number (int) or account ID Guid. (required) 12389 :param str document_id: The ID of the document being accessed. (required) 12390 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12391 :param Tabs tabs: 12392 :return: Tabs 12393 If the method is called asynchronously, 12394 returns the request thread. 12395 """ 12396 12397 all_params = ['account_id', 'document_id', 'envelope_id', 'tabs'] 12398 all_params.append('callback') 12399 all_params.append('_return_http_data_only') 12400 all_params.append('_preload_content') 12401 all_params.append('_request_timeout') 12402 12403 params = locals() 12404 for key, val in iteritems(params['kwargs']): 12405 if key not in all_params: 12406 raise TypeError( 12407 "Got an unexpected keyword argument '%s'" 12408 " to method update_document_tabs" % key 12409 ) 12410 params[key] = val 12411 del params['kwargs'] 12412 # verify the required parameter 'account_id' is set 12413 if ('account_id' not in params) or (params['account_id'] is None): 12414 raise ValueError("Missing the required parameter `account_id` when calling `update_document_tabs`") 12415 # verify the required parameter 'document_id' is set 12416 if ('document_id' not in params) or (params['document_id'] is None): 12417 raise ValueError("Missing the required parameter `document_id` when calling `update_document_tabs`") 12418 # verify the required parameter 'envelope_id' is set 12419 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12420 raise ValueError("Missing the required parameter `envelope_id` when calling `update_document_tabs`") 12421 12422 12423 collection_formats = {} 12424 12425 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/tabs'.replace('{format}', 'json') 12426 path_params = {} 12427 if 'account_id' in params: 12428 path_params['accountId'] = params['account_id'] 12429 if 'document_id' in params: 12430 path_params['documentId'] = params['document_id'] 12431 if 'envelope_id' in params: 12432 path_params['envelopeId'] = params['envelope_id'] 12433 12434 query_params = {} 12435 12436 header_params = {} 12437 12438 form_params = [] 12439 local_var_files = {} 12440 12441 body_params = None 12442 if 'tabs' in params: 12443 body_params = params['tabs'] 12444 # HTTP header `Accept` 12445 header_params['Accept'] = self.api_client.\ 12446 select_header_accept(['application/json']) 12447 12448 # Authentication setting 12449 auth_settings = [] 12450 12451 return self.api_client.call_api(resource_path, 'PUT', 12452 path_params, 12453 query_params, 12454 header_params, 12455 body=body_params, 12456 post_params=form_params, 12457 files=local_var_files, 12458 response_type='Tabs', 12459 auth_settings=auth_settings, 12460 callback=params.get('callback'), 12461 _return_http_data_only=params.get('_return_http_data_only'), 12462 _preload_content=params.get('_preload_content', True), 12463 _request_timeout=params.get('_request_timeout'), 12464 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)
12466 def update_documents(self, account_id, envelope_id, **kwargs): 12467 """ 12468 Adds one or more documents to an existing envelope document. 12469 Adds one or more documents to an existing envelope document. 12470 This method makes a synchronous HTTP request by default. To make an 12471 asynchronous HTTP request, please define a `callback` function 12472 to be invoked when receiving the response. 12473 >>> def callback_function(response): 12474 >>> pprint(response) 12475 >>> 12476 >>> thread = api.update_documents(account_id, envelope_id, callback=callback_function) 12477 12478 :param callback function: The callback function 12479 for asynchronous request. (optional) 12480 :param str account_id: The external account number (int) or account ID Guid. (required) 12481 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12482 :param EnvelopeDefinition envelope_definition: 12483 :return: EnvelopeDocumentsResult 12484 If the method is called asynchronously, 12485 returns the request thread. 12486 """ 12487 kwargs['_return_http_data_only'] = True 12488 if kwargs.get('callback'): 12489 return self.update_documents_with_http_info(account_id, envelope_id, **kwargs) 12490 else: 12491 (data) = self.update_documents_with_http_info(account_id, envelope_id, **kwargs) 12492 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)
12494 def update_documents_with_http_info(self, account_id, envelope_id, **kwargs): 12495 """ 12496 Adds one or more documents to an existing envelope document. 12497 Adds one or more documents to an existing envelope document. 12498 This method makes a synchronous HTTP request by default. To make an 12499 asynchronous HTTP request, please define a `callback` function 12500 to be invoked when receiving the response. 12501 >>> def callback_function(response): 12502 >>> pprint(response) 12503 >>> 12504 >>> thread = api.update_documents_with_http_info(account_id, envelope_id, callback=callback_function) 12505 12506 :param callback function: The callback function 12507 for asynchronous request. (optional) 12508 :param str account_id: The external account number (int) or account ID Guid. (required) 12509 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12510 :param EnvelopeDefinition envelope_definition: 12511 :return: EnvelopeDocumentsResult 12512 If the method is called asynchronously, 12513 returns the request thread. 12514 """ 12515 12516 all_params = ['account_id', 'envelope_id', 'envelope_definition'] 12517 all_params.append('callback') 12518 all_params.append('_return_http_data_only') 12519 all_params.append('_preload_content') 12520 all_params.append('_request_timeout') 12521 12522 params = locals() 12523 for key, val in iteritems(params['kwargs']): 12524 if key not in all_params: 12525 raise TypeError( 12526 "Got an unexpected keyword argument '%s'" 12527 " to method update_documents" % key 12528 ) 12529 params[key] = val 12530 del params['kwargs'] 12531 # verify the required parameter 'account_id' is set 12532 if ('account_id' not in params) or (params['account_id'] is None): 12533 raise ValueError("Missing the required parameter `account_id` when calling `update_documents`") 12534 # verify the required parameter 'envelope_id' is set 12535 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12536 raise ValueError("Missing the required parameter `envelope_id` when calling `update_documents`") 12537 12538 12539 collection_formats = {} 12540 12541 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents'.replace('{format}', 'json') 12542 path_params = {} 12543 if 'account_id' in params: 12544 path_params['accountId'] = params['account_id'] 12545 if 'envelope_id' in params: 12546 path_params['envelopeId'] = params['envelope_id'] 12547 12548 query_params = {} 12549 12550 header_params = {} 12551 12552 form_params = [] 12553 local_var_files = {} 12554 12555 body_params = None 12556 if 'envelope_definition' in params: 12557 body_params = params['envelope_definition'] 12558 # HTTP header `Accept` 12559 header_params['Accept'] = self.api_client.\ 12560 select_header_accept(['application/json']) 12561 12562 # Authentication setting 12563 auth_settings = [] 12564 12565 return self.api_client.call_api(resource_path, 'PUT', 12566 path_params, 12567 query_params, 12568 header_params, 12569 body=body_params, 12570 post_params=form_params, 12571 files=local_var_files, 12572 response_type='EnvelopeDocumentsResult', 12573 auth_settings=auth_settings, 12574 callback=params.get('callback'), 12575 _return_http_data_only=params.get('_return_http_data_only'), 12576 _preload_content=params.get('_preload_content', True), 12577 _request_timeout=params.get('_request_timeout'), 12578 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)
12580 def update_email_settings(self, account_id, envelope_id, **kwargs): 12581 """ 12582 Updates the email setting overrides for an envelope. 12583 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. 12584 This method makes a synchronous HTTP request by default. To make an 12585 asynchronous HTTP request, please define a `callback` function 12586 to be invoked when receiving the response. 12587 >>> def callback_function(response): 12588 >>> pprint(response) 12589 >>> 12590 >>> thread = api.update_email_settings(account_id, envelope_id, callback=callback_function) 12591 12592 :param callback function: The callback function 12593 for asynchronous request. (optional) 12594 :param str account_id: The external account number (int) or account ID Guid. (required) 12595 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12596 :param EmailSettings email_settings: 12597 :return: EmailSettings 12598 If the method is called asynchronously, 12599 returns the request thread. 12600 """ 12601 kwargs['_return_http_data_only'] = True 12602 if kwargs.get('callback'): 12603 return self.update_email_settings_with_http_info(account_id, envelope_id, **kwargs) 12604 else: 12605 (data) = self.update_email_settings_with_http_info(account_id, envelope_id, **kwargs) 12606 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)
12608 def update_email_settings_with_http_info(self, account_id, envelope_id, **kwargs): 12609 """ 12610 Updates the email setting overrides for an envelope. 12611 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. 12612 This method makes a synchronous HTTP request by default. To make an 12613 asynchronous HTTP request, please define a `callback` function 12614 to be invoked when receiving the response. 12615 >>> def callback_function(response): 12616 >>> pprint(response) 12617 >>> 12618 >>> thread = api.update_email_settings_with_http_info(account_id, envelope_id, callback=callback_function) 12619 12620 :param callback function: The callback function 12621 for asynchronous request. (optional) 12622 :param str account_id: The external account number (int) or account ID Guid. (required) 12623 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12624 :param EmailSettings email_settings: 12625 :return: EmailSettings 12626 If the method is called asynchronously, 12627 returns the request thread. 12628 """ 12629 12630 all_params = ['account_id', 'envelope_id', 'email_settings'] 12631 all_params.append('callback') 12632 all_params.append('_return_http_data_only') 12633 all_params.append('_preload_content') 12634 all_params.append('_request_timeout') 12635 12636 params = locals() 12637 for key, val in iteritems(params['kwargs']): 12638 if key not in all_params: 12639 raise TypeError( 12640 "Got an unexpected keyword argument '%s'" 12641 " to method update_email_settings" % key 12642 ) 12643 params[key] = val 12644 del params['kwargs'] 12645 # verify the required parameter 'account_id' is set 12646 if ('account_id' not in params) or (params['account_id'] is None): 12647 raise ValueError("Missing the required parameter `account_id` when calling `update_email_settings`") 12648 # verify the required parameter 'envelope_id' is set 12649 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12650 raise ValueError("Missing the required parameter `envelope_id` when calling `update_email_settings`") 12651 12652 12653 collection_formats = {} 12654 12655 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/email_settings'.replace('{format}', 'json') 12656 path_params = {} 12657 if 'account_id' in params: 12658 path_params['accountId'] = params['account_id'] 12659 if 'envelope_id' in params: 12660 path_params['envelopeId'] = params['envelope_id'] 12661 12662 query_params = {} 12663 12664 header_params = {} 12665 12666 form_params = [] 12667 local_var_files = {} 12668 12669 body_params = None 12670 if 'email_settings' in params: 12671 body_params = params['email_settings'] 12672 # HTTP header `Accept` 12673 header_params['Accept'] = self.api_client.\ 12674 select_header_accept(['application/json']) 12675 12676 # Authentication setting 12677 auth_settings = [] 12678 12679 return self.api_client.call_api(resource_path, 'PUT', 12680 path_params, 12681 query_params, 12682 header_params, 12683 body=body_params, 12684 post_params=form_params, 12685 files=local_var_files, 12686 response_type='EmailSettings', 12687 auth_settings=auth_settings, 12688 callback=params.get('callback'), 12689 _return_http_data_only=params.get('_return_http_data_only'), 12690 _preload_content=params.get('_preload_content', True), 12691 _request_timeout=params.get('_request_timeout'), 12692 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)
12694 def update_envelope_delayed_routing_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 12695 """ 12696 Updates the delayed routing rules for an envelope's workflow step definition. 12697 This method makes a synchronous HTTP request by default. To make an 12698 asynchronous HTTP request, please define a `callback` function 12699 to be invoked when receiving the response. 12700 >>> def callback_function(response): 12701 >>> pprint(response) 12702 >>> 12703 >>> thread = api.update_envelope_delayed_routing_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 12704 12705 :param callback function: The callback function 12706 for asynchronous request. (optional) 12707 :param str account_id: The external account number (int) or account ID Guid. (required) 12708 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12709 :param str workflow_step_id: (required) 12710 :param DelayedRouting delayed_routing: 12711 :return: DelayedRouting 12712 If the method is called asynchronously, 12713 returns the request thread. 12714 """ 12715 kwargs['_return_http_data_only'] = True 12716 if kwargs.get('callback'): 12717 return self.update_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 12718 else: 12719 (data) = self.update_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 12720 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)
12722 def update_envelope_delayed_routing_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 12723 """ 12724 Updates the delayed routing rules for an envelope's workflow step definition. 12725 This method makes a synchronous HTTP request by default. To make an 12726 asynchronous HTTP request, please define a `callback` function 12727 to be invoked when receiving the response. 12728 >>> def callback_function(response): 12729 >>> pprint(response) 12730 >>> 12731 >>> thread = api.update_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 12732 12733 :param callback function: The callback function 12734 for asynchronous request. (optional) 12735 :param str account_id: The external account number (int) or account ID Guid. (required) 12736 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12737 :param str workflow_step_id: (required) 12738 :param DelayedRouting delayed_routing: 12739 :return: DelayedRouting 12740 If the method is called asynchronously, 12741 returns the request thread. 12742 """ 12743 12744 all_params = ['account_id', 'envelope_id', 'workflow_step_id', 'delayed_routing'] 12745 all_params.append('callback') 12746 all_params.append('_return_http_data_only') 12747 all_params.append('_preload_content') 12748 all_params.append('_request_timeout') 12749 12750 params = locals() 12751 for key, val in iteritems(params['kwargs']): 12752 if key not in all_params: 12753 raise TypeError( 12754 "Got an unexpected keyword argument '%s'" 12755 " to method update_envelope_delayed_routing_definition" % key 12756 ) 12757 params[key] = val 12758 del params['kwargs'] 12759 # verify the required parameter 'account_id' is set 12760 if ('account_id' not in params) or (params['account_id'] is None): 12761 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_delayed_routing_definition`") 12762 # verify the required parameter 'envelope_id' is set 12763 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12764 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_delayed_routing_definition`") 12765 # verify the required parameter 'workflow_step_id' is set 12766 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 12767 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_envelope_delayed_routing_definition`") 12768 12769 12770 collection_formats = {} 12771 12772 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 12773 path_params = {} 12774 if 'account_id' in params: 12775 path_params['accountId'] = params['account_id'] 12776 if 'envelope_id' in params: 12777 path_params['envelopeId'] = params['envelope_id'] 12778 if 'workflow_step_id' in params: 12779 path_params['workflowStepId'] = params['workflow_step_id'] 12780 12781 query_params = {} 12782 12783 header_params = {} 12784 12785 form_params = [] 12786 local_var_files = {} 12787 12788 body_params = None 12789 if 'delayed_routing' in params: 12790 body_params = params['delayed_routing'] 12791 # HTTP header `Accept` 12792 header_params['Accept'] = self.api_client.\ 12793 select_header_accept(['application/json']) 12794 12795 # Authentication setting 12796 auth_settings = [] 12797 12798 return self.api_client.call_api(resource_path, 'PUT', 12799 path_params, 12800 query_params, 12801 header_params, 12802 body=body_params, 12803 post_params=form_params, 12804 files=local_var_files, 12805 response_type='DelayedRouting', 12806 auth_settings=auth_settings, 12807 callback=params.get('callback'), 12808 _return_http_data_only=params.get('_return_http_data_only'), 12809 _preload_content=params.get('_preload_content', True), 12810 _request_timeout=params.get('_request_timeout'), 12811 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)
12813 def update_envelope_doc_gen_form_fields(self, account_id, envelope_id, **kwargs): 12814 """ 12815 Updates formfields for an envelope 12816 This method makes a synchronous HTTP request by default. To make an 12817 asynchronous HTTP request, please define a `callback` function 12818 to be invoked when receiving the response. 12819 >>> def callback_function(response): 12820 >>> pprint(response) 12821 >>> 12822 >>> thread = api.update_envelope_doc_gen_form_fields(account_id, envelope_id, callback=callback_function) 12823 12824 :param callback function: The callback function 12825 for asynchronous request. (optional) 12826 :param str account_id: The external account number (int) or account ID Guid. (required) 12827 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12828 :param str update_docgen_formfields_only: 12829 :param DocGenFormFieldRequest doc_gen_form_field_request: 12830 :return: DocGenFormFieldResponse 12831 If the method is called asynchronously, 12832 returns the request thread. 12833 """ 12834 kwargs['_return_http_data_only'] = True 12835 if kwargs.get('callback'): 12836 return self.update_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, **kwargs) 12837 else: 12838 (data) = self.update_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, **kwargs) 12839 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)
12841 def update_envelope_doc_gen_form_fields_with_http_info(self, account_id, envelope_id, **kwargs): 12842 """ 12843 Updates formfields for an envelope 12844 This method makes a synchronous HTTP request by default. To make an 12845 asynchronous HTTP request, please define a `callback` function 12846 to be invoked when receiving the response. 12847 >>> def callback_function(response): 12848 >>> pprint(response) 12849 >>> 12850 >>> thread = api.update_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, callback=callback_function) 12851 12852 :param callback function: The callback function 12853 for asynchronous request. (optional) 12854 :param str account_id: The external account number (int) or account ID Guid. (required) 12855 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12856 :param str update_docgen_formfields_only: 12857 :param DocGenFormFieldRequest doc_gen_form_field_request: 12858 :return: DocGenFormFieldResponse 12859 If the method is called asynchronously, 12860 returns the request thread. 12861 """ 12862 12863 all_params = ['account_id', 'envelope_id', 'update_docgen_formfields_only', 'doc_gen_form_field_request'] 12864 all_params.append('callback') 12865 all_params.append('_return_http_data_only') 12866 all_params.append('_preload_content') 12867 all_params.append('_request_timeout') 12868 12869 params = locals() 12870 for key, val in iteritems(params['kwargs']): 12871 if key not in all_params: 12872 raise TypeError( 12873 "Got an unexpected keyword argument '%s'" 12874 " to method update_envelope_doc_gen_form_fields" % key 12875 ) 12876 params[key] = val 12877 del params['kwargs'] 12878 # verify the required parameter 'account_id' is set 12879 if ('account_id' not in params) or (params['account_id'] is None): 12880 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_doc_gen_form_fields`") 12881 # verify the required parameter 'envelope_id' is set 12882 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12883 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_doc_gen_form_fields`") 12884 12885 12886 collection_formats = {} 12887 12888 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/docGenFormFields'.replace('{format}', 'json') 12889 path_params = {} 12890 if 'account_id' in params: 12891 path_params['accountId'] = params['account_id'] 12892 if 'envelope_id' in params: 12893 path_params['envelopeId'] = params['envelope_id'] 12894 12895 query_params = {} 12896 if 'update_docgen_formfields_only' in params: 12897 query_params['update_docgen_formfields_only'] = params['update_docgen_formfields_only'] 12898 12899 header_params = {} 12900 12901 form_params = [] 12902 local_var_files = {} 12903 12904 body_params = None 12905 if 'doc_gen_form_field_request' in params: 12906 body_params = params['doc_gen_form_field_request'] 12907 # HTTP header `Accept` 12908 header_params['Accept'] = self.api_client.\ 12909 select_header_accept(['application/json']) 12910 12911 # Authentication setting 12912 auth_settings = [] 12913 12914 return self.api_client.call_api(resource_path, 'PUT', 12915 path_params, 12916 query_params, 12917 header_params, 12918 body=body_params, 12919 post_params=form_params, 12920 files=local_var_files, 12921 response_type='DocGenFormFieldResponse', 12922 auth_settings=auth_settings, 12923 callback=params.get('callback'), 12924 _return_http_data_only=params.get('_return_http_data_only'), 12925 _preload_content=params.get('_preload_content', True), 12926 _request_timeout=params.get('_request_timeout'), 12927 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)
12929 def update_envelope_scheduled_sending_definition(self, account_id, envelope_id, **kwargs): 12930 """ 12931 Updates the scheduled sending rules for an envelope's workflow definition. 12932 This method makes a synchronous HTTP request by default. To make an 12933 asynchronous HTTP request, please define a `callback` function 12934 to be invoked when receiving the response. 12935 >>> def callback_function(response): 12936 >>> pprint(response) 12937 >>> 12938 >>> thread = api.update_envelope_scheduled_sending_definition(account_id, envelope_id, callback=callback_function) 12939 12940 :param callback function: The callback function 12941 for asynchronous request. (optional) 12942 :param str account_id: The external account number (int) or account ID Guid. (required) 12943 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12944 :param ScheduledSending scheduled_sending: 12945 :return: ScheduledSending 12946 If the method is called asynchronously, 12947 returns the request thread. 12948 """ 12949 kwargs['_return_http_data_only'] = True 12950 if kwargs.get('callback'): 12951 return self.update_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 12952 else: 12953 (data) = self.update_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 12954 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)
12956 def update_envelope_scheduled_sending_definition_with_http_info(self, account_id, envelope_id, **kwargs): 12957 """ 12958 Updates the scheduled sending rules for an envelope's workflow definition. 12959 This method makes a synchronous HTTP request by default. To make an 12960 asynchronous HTTP request, please define a `callback` function 12961 to be invoked when receiving the response. 12962 >>> def callback_function(response): 12963 >>> pprint(response) 12964 >>> 12965 >>> thread = api.update_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, callback=callback_function) 12966 12967 :param callback function: The callback function 12968 for asynchronous request. (optional) 12969 :param str account_id: The external account number (int) or account ID Guid. (required) 12970 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12971 :param ScheduledSending scheduled_sending: 12972 :return: ScheduledSending 12973 If the method is called asynchronously, 12974 returns the request thread. 12975 """ 12976 12977 all_params = ['account_id', 'envelope_id', 'scheduled_sending'] 12978 all_params.append('callback') 12979 all_params.append('_return_http_data_only') 12980 all_params.append('_preload_content') 12981 all_params.append('_request_timeout') 12982 12983 params = locals() 12984 for key, val in iteritems(params['kwargs']): 12985 if key not in all_params: 12986 raise TypeError( 12987 "Got an unexpected keyword argument '%s'" 12988 " to method update_envelope_scheduled_sending_definition" % key 12989 ) 12990 params[key] = val 12991 del params['kwargs'] 12992 # verify the required parameter 'account_id' is set 12993 if ('account_id' not in params) or (params['account_id'] is None): 12994 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_scheduled_sending_definition`") 12995 # verify the required parameter 'envelope_id' is set 12996 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12997 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_scheduled_sending_definition`") 12998 12999 13000 collection_formats = {} 13001 13002 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/scheduledSending'.replace('{format}', 'json') 13003 path_params = {} 13004 if 'account_id' in params: 13005 path_params['accountId'] = params['account_id'] 13006 if 'envelope_id' in params: 13007 path_params['envelopeId'] = params['envelope_id'] 13008 13009 query_params = {} 13010 13011 header_params = {} 13012 13013 form_params = [] 13014 local_var_files = {} 13015 13016 body_params = None 13017 if 'scheduled_sending' in params: 13018 body_params = params['scheduled_sending'] 13019 # HTTP header `Accept` 13020 header_params['Accept'] = self.api_client.\ 13021 select_header_accept(['application/json']) 13022 13023 # Authentication setting 13024 auth_settings = [] 13025 13026 return self.api_client.call_api(resource_path, 'PUT', 13027 path_params, 13028 query_params, 13029 header_params, 13030 body=body_params, 13031 post_params=form_params, 13032 files=local_var_files, 13033 response_type='ScheduledSending', 13034 auth_settings=auth_settings, 13035 callback=params.get('callback'), 13036 _return_http_data_only=params.get('_return_http_data_only'), 13037 _preload_content=params.get('_preload_content', True), 13038 _request_timeout=params.get('_request_timeout'), 13039 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)
13041 def update_envelope_transfer_rule(self, account_id, envelope_transfer_rule_id, **kwargs): 13042 """ 13043 Update an envelope transfer rule for an account. 13044 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. 13045 This method makes a synchronous HTTP request by default. To make an 13046 asynchronous HTTP request, please define a `callback` function 13047 to be invoked when receiving the response. 13048 >>> def callback_function(response): 13049 >>> pprint(response) 13050 >>> 13051 >>> thread = api.update_envelope_transfer_rule(account_id, envelope_transfer_rule_id, callback=callback_function) 13052 13053 :param callback function: The callback function 13054 for asynchronous request. (optional) 13055 :param str account_id: The external account number (int) or account ID Guid. (required) 13056 :param str envelope_transfer_rule_id: (required) 13057 :param EnvelopeTransferRule envelope_transfer_rule: 13058 :return: EnvelopeTransferRule 13059 If the method is called asynchronously, 13060 returns the request thread. 13061 """ 13062 kwargs['_return_http_data_only'] = True 13063 if kwargs.get('callback'): 13064 return self.update_envelope_transfer_rule_with_http_info(account_id, envelope_transfer_rule_id, **kwargs) 13065 else: 13066 (data) = self.update_envelope_transfer_rule_with_http_info(account_id, envelope_transfer_rule_id, **kwargs) 13067 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)
13069 def update_envelope_transfer_rule_with_http_info(self, account_id, envelope_transfer_rule_id, **kwargs): 13070 """ 13071 Update an envelope transfer rule for an account. 13072 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. 13073 This method makes a synchronous HTTP request by default. To make an 13074 asynchronous HTTP request, please define a `callback` function 13075 to be invoked when receiving the response. 13076 >>> def callback_function(response): 13077 >>> pprint(response) 13078 >>> 13079 >>> thread = api.update_envelope_transfer_rule_with_http_info(account_id, envelope_transfer_rule_id, callback=callback_function) 13080 13081 :param callback function: The callback function 13082 for asynchronous request. (optional) 13083 :param str account_id: The external account number (int) or account ID Guid. (required) 13084 :param str envelope_transfer_rule_id: (required) 13085 :param EnvelopeTransferRule envelope_transfer_rule: 13086 :return: EnvelopeTransferRule 13087 If the method is called asynchronously, 13088 returns the request thread. 13089 """ 13090 13091 all_params = ['account_id', 'envelope_transfer_rule_id', 'envelope_transfer_rule'] 13092 all_params.append('callback') 13093 all_params.append('_return_http_data_only') 13094 all_params.append('_preload_content') 13095 all_params.append('_request_timeout') 13096 13097 params = locals() 13098 for key, val in iteritems(params['kwargs']): 13099 if key not in all_params: 13100 raise TypeError( 13101 "Got an unexpected keyword argument '%s'" 13102 " to method update_envelope_transfer_rule" % key 13103 ) 13104 params[key] = val 13105 del params['kwargs'] 13106 # verify the required parameter 'account_id' is set 13107 if ('account_id' not in params) or (params['account_id'] is None): 13108 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_transfer_rule`") 13109 # verify the required parameter 'envelope_transfer_rule_id' is set 13110 if ('envelope_transfer_rule_id' not in params) or (params['envelope_transfer_rule_id'] is None): 13111 raise ValueError("Missing the required parameter `envelope_transfer_rule_id` when calling `update_envelope_transfer_rule`") 13112 13113 13114 collection_formats = {} 13115 13116 resource_path = '/v2.1/accounts/{accountId}/envelopes/transfer_rules/{envelopeTransferRuleId}'.replace('{format}', 'json') 13117 path_params = {} 13118 if 'account_id' in params: 13119 path_params['accountId'] = params['account_id'] 13120 if 'envelope_transfer_rule_id' in params: 13121 path_params['envelopeTransferRuleId'] = params['envelope_transfer_rule_id'] 13122 13123 query_params = {} 13124 13125 header_params = {} 13126 13127 form_params = [] 13128 local_var_files = {} 13129 13130 body_params = None 13131 if 'envelope_transfer_rule' in params: 13132 body_params = params['envelope_transfer_rule'] 13133 # HTTP header `Accept` 13134 header_params['Accept'] = self.api_client.\ 13135 select_header_accept(['application/json']) 13136 13137 # Authentication setting 13138 auth_settings = [] 13139 13140 return self.api_client.call_api(resource_path, 'PUT', 13141 path_params, 13142 query_params, 13143 header_params, 13144 body=body_params, 13145 post_params=form_params, 13146 files=local_var_files, 13147 response_type='EnvelopeTransferRule', 13148 auth_settings=auth_settings, 13149 callback=params.get('callback'), 13150 _return_http_data_only=params.get('_return_http_data_only'), 13151 _preload_content=params.get('_preload_content', True), 13152 _request_timeout=params.get('_request_timeout'), 13153 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)
13155 def update_envelope_transfer_rules(self, account_id, **kwargs): 13156 """ 13157 Update envelope transfer rules for an account. 13158 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. 13159 This method makes a synchronous HTTP request by default. To make an 13160 asynchronous HTTP request, please define a `callback` function 13161 to be invoked when receiving the response. 13162 >>> def callback_function(response): 13163 >>> pprint(response) 13164 >>> 13165 >>> thread = api.update_envelope_transfer_rules(account_id, callback=callback_function) 13166 13167 :param callback function: The callback function 13168 for asynchronous request. (optional) 13169 :param str account_id: The external account number (int) or account ID Guid. (required) 13170 :param EnvelopeTransferRuleInformation envelope_transfer_rule_information: 13171 :return: EnvelopeTransferRuleInformation 13172 If the method is called asynchronously, 13173 returns the request thread. 13174 """ 13175 kwargs['_return_http_data_only'] = True 13176 if kwargs.get('callback'): 13177 return self.update_envelope_transfer_rules_with_http_info(account_id, **kwargs) 13178 else: 13179 (data) = self.update_envelope_transfer_rules_with_http_info(account_id, **kwargs) 13180 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)
13182 def update_envelope_transfer_rules_with_http_info(self, account_id, **kwargs): 13183 """ 13184 Update envelope transfer rules for an account. 13185 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. 13186 This method makes a synchronous HTTP request by default. To make an 13187 asynchronous HTTP request, please define a `callback` function 13188 to be invoked when receiving the response. 13189 >>> def callback_function(response): 13190 >>> pprint(response) 13191 >>> 13192 >>> thread = api.update_envelope_transfer_rules_with_http_info(account_id, callback=callback_function) 13193 13194 :param callback function: The callback function 13195 for asynchronous request. (optional) 13196 :param str account_id: The external account number (int) or account ID Guid. (required) 13197 :param EnvelopeTransferRuleInformation envelope_transfer_rule_information: 13198 :return: EnvelopeTransferRuleInformation 13199 If the method is called asynchronously, 13200 returns the request thread. 13201 """ 13202 13203 all_params = ['account_id', 'envelope_transfer_rule_information'] 13204 all_params.append('callback') 13205 all_params.append('_return_http_data_only') 13206 all_params.append('_preload_content') 13207 all_params.append('_request_timeout') 13208 13209 params = locals() 13210 for key, val in iteritems(params['kwargs']): 13211 if key not in all_params: 13212 raise TypeError( 13213 "Got an unexpected keyword argument '%s'" 13214 " to method update_envelope_transfer_rules" % key 13215 ) 13216 params[key] = val 13217 del params['kwargs'] 13218 # verify the required parameter 'account_id' is set 13219 if ('account_id' not in params) or (params['account_id'] is None): 13220 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_transfer_rules`") 13221 13222 13223 collection_formats = {} 13224 13225 resource_path = '/v2.1/accounts/{accountId}/envelopes/transfer_rules'.replace('{format}', 'json') 13226 path_params = {} 13227 if 'account_id' in params: 13228 path_params['accountId'] = params['account_id'] 13229 13230 query_params = {} 13231 13232 header_params = {} 13233 13234 form_params = [] 13235 local_var_files = {} 13236 13237 body_params = None 13238 if 'envelope_transfer_rule_information' in params: 13239 body_params = params['envelope_transfer_rule_information'] 13240 # HTTP header `Accept` 13241 header_params['Accept'] = self.api_client.\ 13242 select_header_accept(['application/json']) 13243 13244 # Authentication setting 13245 auth_settings = [] 13246 13247 return self.api_client.call_api(resource_path, 'PUT', 13248 path_params, 13249 query_params, 13250 header_params, 13251 body=body_params, 13252 post_params=form_params, 13253 files=local_var_files, 13254 response_type='EnvelopeTransferRuleInformation', 13255 auth_settings=auth_settings, 13256 callback=params.get('callback'), 13257 _return_http_data_only=params.get('_return_http_data_only'), 13258 _preload_content=params.get('_preload_content', True), 13259 _request_timeout=params.get('_request_timeout'), 13260 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)
13262 def update_envelope_workflow_definition(self, account_id, envelope_id, **kwargs): 13263 """ 13264 Updates the envelope workflow definition for an envelope. 13265 Updates the specified envelope's workflow definition if it has one. 13266 This method makes a synchronous HTTP request by default. To make an 13267 asynchronous HTTP request, please define a `callback` function 13268 to be invoked when receiving the response. 13269 >>> def callback_function(response): 13270 >>> pprint(response) 13271 >>> 13272 >>> thread = api.update_envelope_workflow_definition(account_id, envelope_id, callback=callback_function) 13273 13274 :param callback function: The callback function 13275 for asynchronous request. (optional) 13276 :param str account_id: The external account number (int) or account ID Guid. (required) 13277 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13278 :param Workflow workflow: 13279 :return: Workflow 13280 If the method is called asynchronously, 13281 returns the request thread. 13282 """ 13283 kwargs['_return_http_data_only'] = True 13284 if kwargs.get('callback'): 13285 return self.update_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 13286 else: 13287 (data) = self.update_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 13288 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)
13290 def update_envelope_workflow_definition_with_http_info(self, account_id, envelope_id, **kwargs): 13291 """ 13292 Updates the envelope workflow definition for an envelope. 13293 Updates the specified envelope's workflow definition if it has one. 13294 This method makes a synchronous HTTP request by default. To make an 13295 asynchronous HTTP request, please define a `callback` function 13296 to be invoked when receiving the response. 13297 >>> def callback_function(response): 13298 >>> pprint(response) 13299 >>> 13300 >>> thread = api.update_envelope_workflow_definition_with_http_info(account_id, envelope_id, callback=callback_function) 13301 13302 :param callback function: The callback function 13303 for asynchronous request. (optional) 13304 :param str account_id: The external account number (int) or account ID Guid. (required) 13305 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13306 :param Workflow workflow: 13307 :return: Workflow 13308 If the method is called asynchronously, 13309 returns the request thread. 13310 """ 13311 13312 all_params = ['account_id', 'envelope_id', 'workflow'] 13313 all_params.append('callback') 13314 all_params.append('_return_http_data_only') 13315 all_params.append('_preload_content') 13316 all_params.append('_request_timeout') 13317 13318 params = locals() 13319 for key, val in iteritems(params['kwargs']): 13320 if key not in all_params: 13321 raise TypeError( 13322 "Got an unexpected keyword argument '%s'" 13323 " to method update_envelope_workflow_definition" % key 13324 ) 13325 params[key] = val 13326 del params['kwargs'] 13327 # verify the required parameter 'account_id' is set 13328 if ('account_id' not in params) or (params['account_id'] is None): 13329 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_workflow_definition`") 13330 # verify the required parameter 'envelope_id' is set 13331 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13332 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_workflow_definition`") 13333 13334 13335 collection_formats = {} 13336 13337 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow'.replace('{format}', 'json') 13338 path_params = {} 13339 if 'account_id' in params: 13340 path_params['accountId'] = params['account_id'] 13341 if 'envelope_id' in params: 13342 path_params['envelopeId'] = params['envelope_id'] 13343 13344 query_params = {} 13345 13346 header_params = {} 13347 13348 form_params = [] 13349 local_var_files = {} 13350 13351 body_params = None 13352 if 'workflow' in params: 13353 body_params = params['workflow'] 13354 # HTTP header `Accept` 13355 header_params['Accept'] = self.api_client.\ 13356 select_header_accept(['application/json']) 13357 13358 # Authentication setting 13359 auth_settings = [] 13360 13361 return self.api_client.call_api(resource_path, 'PUT', 13362 path_params, 13363 query_params, 13364 header_params, 13365 body=body_params, 13366 post_params=form_params, 13367 files=local_var_files, 13368 response_type='Workflow', 13369 auth_settings=auth_settings, 13370 callback=params.get('callback'), 13371 _return_http_data_only=params.get('_return_http_data_only'), 13372 _preload_content=params.get('_preload_content', True), 13373 _request_timeout=params.get('_request_timeout'), 13374 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)
13376 def update_envelope_workflow_step_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 13377 """ 13378 Updates the envelope workflow step definition for an envelope. 13379 This method makes a synchronous HTTP request by default. To make an 13380 asynchronous HTTP request, please define a `callback` function 13381 to be invoked when receiving the response. 13382 >>> def callback_function(response): 13383 >>> pprint(response) 13384 >>> 13385 >>> thread = api.update_envelope_workflow_step_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 13386 13387 :param callback function: The callback function 13388 for asynchronous request. (optional) 13389 :param str account_id: The external account number (int) or account ID Guid. (required) 13390 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13391 :param str workflow_step_id: (required) 13392 :param WorkflowStep workflow_step: 13393 :return: WorkflowStep 13394 If the method is called asynchronously, 13395 returns the request thread. 13396 """ 13397 kwargs['_return_http_data_only'] = True 13398 if kwargs.get('callback'): 13399 return self.update_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 13400 else: 13401 (data) = self.update_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 13402 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)
13404 def update_envelope_workflow_step_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 13405 """ 13406 Updates the envelope workflow step definition for an envelope. 13407 This method makes a synchronous HTTP request by default. To make an 13408 asynchronous HTTP request, please define a `callback` function 13409 to be invoked when receiving the response. 13410 >>> def callback_function(response): 13411 >>> pprint(response) 13412 >>> 13413 >>> thread = api.update_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 13414 13415 :param callback function: The callback function 13416 for asynchronous request. (optional) 13417 :param str account_id: The external account number (int) or account ID Guid. (required) 13418 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13419 :param str workflow_step_id: (required) 13420 :param WorkflowStep workflow_step: 13421 :return: WorkflowStep 13422 If the method is called asynchronously, 13423 returns the request thread. 13424 """ 13425 13426 all_params = ['account_id', 'envelope_id', 'workflow_step_id', 'workflow_step'] 13427 all_params.append('callback') 13428 all_params.append('_return_http_data_only') 13429 all_params.append('_preload_content') 13430 all_params.append('_request_timeout') 13431 13432 params = locals() 13433 for key, val in iteritems(params['kwargs']): 13434 if key not in all_params: 13435 raise TypeError( 13436 "Got an unexpected keyword argument '%s'" 13437 " to method update_envelope_workflow_step_definition" % key 13438 ) 13439 params[key] = val 13440 del params['kwargs'] 13441 # verify the required parameter 'account_id' is set 13442 if ('account_id' not in params) or (params['account_id'] is None): 13443 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_workflow_step_definition`") 13444 # verify the required parameter 'envelope_id' is set 13445 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13446 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_workflow_step_definition`") 13447 # verify the required parameter 'workflow_step_id' is set 13448 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 13449 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_envelope_workflow_step_definition`") 13450 13451 13452 collection_formats = {} 13453 13454 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 13455 path_params = {} 13456 if 'account_id' in params: 13457 path_params['accountId'] = params['account_id'] 13458 if 'envelope_id' in params: 13459 path_params['envelopeId'] = params['envelope_id'] 13460 if 'workflow_step_id' in params: 13461 path_params['workflowStepId'] = params['workflow_step_id'] 13462 13463 query_params = {} 13464 13465 header_params = {} 13466 13467 form_params = [] 13468 local_var_files = {} 13469 13470 body_params = None 13471 if 'workflow_step' in params: 13472 body_params = params['workflow_step'] 13473 # HTTP header `Accept` 13474 header_params['Accept'] = self.api_client.\ 13475 select_header_accept(['application/json']) 13476 13477 # Authentication setting 13478 auth_settings = [] 13479 13480 return self.api_client.call_api(resource_path, 'PUT', 13481 path_params, 13482 query_params, 13483 header_params, 13484 body=body_params, 13485 post_params=form_params, 13486 files=local_var_files, 13487 response_type='WorkflowStep', 13488 auth_settings=auth_settings, 13489 callback=params.get('callback'), 13490 _return_http_data_only=params.get('_return_http_data_only'), 13491 _preload_content=params.get('_preload_content', True), 13492 _request_timeout=params.get('_request_timeout'), 13493 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)
13495 def update_lock(self, account_id, envelope_id, **kwargs): 13496 """ 13497 Updates an envelope lock. 13498 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. 13499 This method makes a synchronous HTTP request by default. To make an 13500 asynchronous HTTP request, please define a `callback` function 13501 to be invoked when receiving the response. 13502 >>> def callback_function(response): 13503 >>> pprint(response) 13504 >>> 13505 >>> thread = api.update_lock(account_id, envelope_id, callback=callback_function) 13506 13507 :param callback function: The callback function 13508 for asynchronous request. (optional) 13509 :param str account_id: The external account number (int) or account ID Guid. (required) 13510 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13511 :param LockRequest lock_request: 13512 :return: LockInformation 13513 If the method is called asynchronously, 13514 returns the request thread. 13515 """ 13516 kwargs['_return_http_data_only'] = True 13517 if kwargs.get('callback'): 13518 return self.update_lock_with_http_info(account_id, envelope_id, **kwargs) 13519 else: 13520 (data) = self.update_lock_with_http_info(account_id, envelope_id, **kwargs) 13521 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)
13523 def update_lock_with_http_info(self, account_id, envelope_id, **kwargs): 13524 """ 13525 Updates an envelope lock. 13526 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. 13527 This method makes a synchronous HTTP request by default. To make an 13528 asynchronous HTTP request, please define a `callback` function 13529 to be invoked when receiving the response. 13530 >>> def callback_function(response): 13531 >>> pprint(response) 13532 >>> 13533 >>> thread = api.update_lock_with_http_info(account_id, envelope_id, callback=callback_function) 13534 13535 :param callback function: The callback function 13536 for asynchronous request. (optional) 13537 :param str account_id: The external account number (int) or account ID Guid. (required) 13538 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13539 :param LockRequest lock_request: 13540 :return: LockInformation 13541 If the method is called asynchronously, 13542 returns the request thread. 13543 """ 13544 13545 all_params = ['account_id', 'envelope_id', 'lock_request'] 13546 all_params.append('callback') 13547 all_params.append('_return_http_data_only') 13548 all_params.append('_preload_content') 13549 all_params.append('_request_timeout') 13550 13551 params = locals() 13552 for key, val in iteritems(params['kwargs']): 13553 if key not in all_params: 13554 raise TypeError( 13555 "Got an unexpected keyword argument '%s'" 13556 " to method update_lock" % key 13557 ) 13558 params[key] = val 13559 del params['kwargs'] 13560 # verify the required parameter 'account_id' is set 13561 if ('account_id' not in params) or (params['account_id'] is None): 13562 raise ValueError("Missing the required parameter `account_id` when calling `update_lock`") 13563 # verify the required parameter 'envelope_id' is set 13564 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13565 raise ValueError("Missing the required parameter `envelope_id` when calling `update_lock`") 13566 13567 13568 collection_formats = {} 13569 13570 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/lock'.replace('{format}', 'json') 13571 path_params = {} 13572 if 'account_id' in params: 13573 path_params['accountId'] = params['account_id'] 13574 if 'envelope_id' in params: 13575 path_params['envelopeId'] = params['envelope_id'] 13576 13577 query_params = {} 13578 13579 header_params = {} 13580 13581 form_params = [] 13582 local_var_files = {} 13583 13584 body_params = None 13585 if 'lock_request' in params: 13586 body_params = params['lock_request'] 13587 # HTTP header `Accept` 13588 header_params['Accept'] = self.api_client.\ 13589 select_header_accept(['application/json']) 13590 13591 # Authentication setting 13592 auth_settings = [] 13593 13594 return self.api_client.call_api(resource_path, 'PUT', 13595 path_params, 13596 query_params, 13597 header_params, 13598 body=body_params, 13599 post_params=form_params, 13600 files=local_var_files, 13601 response_type='LockInformation', 13602 auth_settings=auth_settings, 13603 callback=params.get('callback'), 13604 _return_http_data_only=params.get('_return_http_data_only'), 13605 _preload_content=params.get('_preload_content', True), 13606 _request_timeout=params.get('_request_timeout'), 13607 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)
13609 def update_notification_settings(self, account_id, envelope_id, **kwargs): 13610 """ 13611 Sets envelope notification (Reminders/Expirations) structure for an existing envelope. 13612 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. 13613 This method makes a synchronous HTTP request by default. To make an 13614 asynchronous HTTP request, please define a `callback` function 13615 to be invoked when receiving the response. 13616 >>> def callback_function(response): 13617 >>> pprint(response) 13618 >>> 13619 >>> thread = api.update_notification_settings(account_id, envelope_id, callback=callback_function) 13620 13621 :param callback function: The callback function 13622 for asynchronous request. (optional) 13623 :param str account_id: The external account number (int) or account ID Guid. (required) 13624 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13625 :param EnvelopeNotificationRequest envelope_notification_request: 13626 :return: Notification 13627 If the method is called asynchronously, 13628 returns the request thread. 13629 """ 13630 kwargs['_return_http_data_only'] = True 13631 if kwargs.get('callback'): 13632 return self.update_notification_settings_with_http_info(account_id, envelope_id, **kwargs) 13633 else: 13634 (data) = self.update_notification_settings_with_http_info(account_id, envelope_id, **kwargs) 13635 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)
13637 def update_notification_settings_with_http_info(self, account_id, envelope_id, **kwargs): 13638 """ 13639 Sets envelope notification (Reminders/Expirations) structure for an existing envelope. 13640 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. 13641 This method makes a synchronous HTTP request by default. To make an 13642 asynchronous HTTP request, please define a `callback` function 13643 to be invoked when receiving the response. 13644 >>> def callback_function(response): 13645 >>> pprint(response) 13646 >>> 13647 >>> thread = api.update_notification_settings_with_http_info(account_id, envelope_id, callback=callback_function) 13648 13649 :param callback function: The callback function 13650 for asynchronous request. (optional) 13651 :param str account_id: The external account number (int) or account ID Guid. (required) 13652 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13653 :param EnvelopeNotificationRequest envelope_notification_request: 13654 :return: Notification 13655 If the method is called asynchronously, 13656 returns the request thread. 13657 """ 13658 13659 all_params = ['account_id', 'envelope_id', 'envelope_notification_request'] 13660 all_params.append('callback') 13661 all_params.append('_return_http_data_only') 13662 all_params.append('_preload_content') 13663 all_params.append('_request_timeout') 13664 13665 params = locals() 13666 for key, val in iteritems(params['kwargs']): 13667 if key not in all_params: 13668 raise TypeError( 13669 "Got an unexpected keyword argument '%s'" 13670 " to method update_notification_settings" % key 13671 ) 13672 params[key] = val 13673 del params['kwargs'] 13674 # verify the required parameter 'account_id' is set 13675 if ('account_id' not in params) or (params['account_id'] is None): 13676 raise ValueError("Missing the required parameter `account_id` when calling `update_notification_settings`") 13677 # verify the required parameter 'envelope_id' is set 13678 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13679 raise ValueError("Missing the required parameter `envelope_id` when calling `update_notification_settings`") 13680 13681 13682 collection_formats = {} 13683 13684 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/notification'.replace('{format}', 'json') 13685 path_params = {} 13686 if 'account_id' in params: 13687 path_params['accountId'] = params['account_id'] 13688 if 'envelope_id' in params: 13689 path_params['envelopeId'] = params['envelope_id'] 13690 13691 query_params = {} 13692 13693 header_params = {} 13694 13695 form_params = [] 13696 local_var_files = {} 13697 13698 body_params = None 13699 if 'envelope_notification_request' in params: 13700 body_params = params['envelope_notification_request'] 13701 # HTTP header `Accept` 13702 header_params['Accept'] = self.api_client.\ 13703 select_header_accept(['application/json']) 13704 13705 # Authentication setting 13706 auth_settings = [] 13707 13708 return self.api_client.call_api(resource_path, 'PUT', 13709 path_params, 13710 query_params, 13711 header_params, 13712 body=body_params, 13713 post_params=form_params, 13714 files=local_var_files, 13715 response_type='Notification', 13716 auth_settings=auth_settings, 13717 callback=params.get('callback'), 13718 _return_http_data_only=params.get('_return_http_data_only'), 13719 _preload_content=params.get('_preload_content', True), 13720 _request_timeout=params.get('_request_timeout'), 13721 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)
13723 def update_recipient_document_visibility(self, account_id, envelope_id, recipient_id, **kwargs): 13724 """ 13725 Updates document visibility for the recipients 13726 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. 13727 This method makes a synchronous HTTP request by default. To make an 13728 asynchronous HTTP request, please define a `callback` function 13729 to be invoked when receiving the response. 13730 >>> def callback_function(response): 13731 >>> pprint(response) 13732 >>> 13733 >>> thread = api.update_recipient_document_visibility(account_id, envelope_id, recipient_id, callback=callback_function) 13734 13735 :param callback function: The callback function 13736 for asynchronous request. (optional) 13737 :param str account_id: The external account number (int) or account ID Guid. (required) 13738 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13739 :param str recipient_id: The ID of the recipient being accessed. (required) 13740 :param DocumentVisibilityList document_visibility_list: 13741 :return: DocumentVisibilityList 13742 If the method is called asynchronously, 13743 returns the request thread. 13744 """ 13745 kwargs['_return_http_data_only'] = True 13746 if kwargs.get('callback'): 13747 return self.update_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13748 else: 13749 (data) = self.update_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13750 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)
13752 def update_recipient_document_visibility_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 13753 """ 13754 Updates document visibility for the recipients 13755 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. 13756 This method makes a synchronous HTTP request by default. To make an 13757 asynchronous HTTP request, please define a `callback` function 13758 to be invoked when receiving the response. 13759 >>> def callback_function(response): 13760 >>> pprint(response) 13761 >>> 13762 >>> thread = api.update_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 13763 13764 :param callback function: The callback function 13765 for asynchronous request. (optional) 13766 :param str account_id: The external account number (int) or account ID Guid. (required) 13767 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13768 :param str recipient_id: The ID of the recipient being accessed. (required) 13769 :param DocumentVisibilityList document_visibility_list: 13770 :return: DocumentVisibilityList 13771 If the method is called asynchronously, 13772 returns the request thread. 13773 """ 13774 13775 all_params = ['account_id', 'envelope_id', 'recipient_id', 'document_visibility_list'] 13776 all_params.append('callback') 13777 all_params.append('_return_http_data_only') 13778 all_params.append('_preload_content') 13779 all_params.append('_request_timeout') 13780 13781 params = locals() 13782 for key, val in iteritems(params['kwargs']): 13783 if key not in all_params: 13784 raise TypeError( 13785 "Got an unexpected keyword argument '%s'" 13786 " to method update_recipient_document_visibility" % key 13787 ) 13788 params[key] = val 13789 del params['kwargs'] 13790 # verify the required parameter 'account_id' is set 13791 if ('account_id' not in params) or (params['account_id'] is None): 13792 raise ValueError("Missing the required parameter `account_id` when calling `update_recipient_document_visibility`") 13793 # verify the required parameter 'envelope_id' is set 13794 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13795 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipient_document_visibility`") 13796 # verify the required parameter 'recipient_id' is set 13797 if ('recipient_id' not in params) or (params['recipient_id'] is None): 13798 raise ValueError("Missing the required parameter `recipient_id` when calling `update_recipient_document_visibility`") 13799 13800 13801 collection_formats = {} 13802 13803 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/document_visibility'.replace('{format}', 'json') 13804 path_params = {} 13805 if 'account_id' in params: 13806 path_params['accountId'] = params['account_id'] 13807 if 'envelope_id' in params: 13808 path_params['envelopeId'] = params['envelope_id'] 13809 if 'recipient_id' in params: 13810 path_params['recipientId'] = params['recipient_id'] 13811 13812 query_params = {} 13813 13814 header_params = {} 13815 13816 form_params = [] 13817 local_var_files = {} 13818 13819 body_params = None 13820 if 'document_visibility_list' in params: 13821 body_params = params['document_visibility_list'] 13822 # HTTP header `Accept` 13823 header_params['Accept'] = self.api_client.\ 13824 select_header_accept(['application/json']) 13825 13826 # Authentication setting 13827 auth_settings = [] 13828 13829 return self.api_client.call_api(resource_path, 'PUT', 13830 path_params, 13831 query_params, 13832 header_params, 13833 body=body_params, 13834 post_params=form_params, 13835 files=local_var_files, 13836 response_type='DocumentVisibilityList', 13837 auth_settings=auth_settings, 13838 callback=params.get('callback'), 13839 _return_http_data_only=params.get('_return_http_data_only'), 13840 _preload_content=params.get('_preload_content', True), 13841 _request_timeout=params.get('_request_timeout'), 13842 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)
13844 def update_recipient_initials_image(self, account_id, envelope_id, recipient_id, **kwargs): 13845 """ 13846 Sets the initials image for an accountless signer. 13847 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**. 13848 This method makes a synchronous HTTP request by default. To make an 13849 asynchronous HTTP request, please define a `callback` function 13850 to be invoked when receiving the response. 13851 >>> def callback_function(response): 13852 >>> pprint(response) 13853 >>> 13854 >>> thread = api.update_recipient_initials_image(account_id, envelope_id, recipient_id, callback=callback_function) 13855 13856 :param callback function: The callback function 13857 for asynchronous request. (optional) 13858 :param str account_id: The external account number (int) or account ID Guid. (required) 13859 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13860 :param str recipient_id: The ID of the recipient being accessed. (required) 13861 :return: None 13862 If the method is called asynchronously, 13863 returns the request thread. 13864 """ 13865 kwargs['_return_http_data_only'] = True 13866 if kwargs.get('callback'): 13867 return self.update_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13868 else: 13869 (data) = self.update_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13870 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)
13872 def update_recipient_initials_image_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 13873 """ 13874 Sets the initials image for an accountless signer. 13875 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**. 13876 This method makes a synchronous HTTP request by default. To make an 13877 asynchronous HTTP request, please define a `callback` function 13878 to be invoked when receiving the response. 13879 >>> def callback_function(response): 13880 >>> pprint(response) 13881 >>> 13882 >>> thread = api.update_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 13883 13884 :param callback function: The callback function 13885 for asynchronous request. (optional) 13886 :param str account_id: The external account number (int) or account ID Guid. (required) 13887 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13888 :param str recipient_id: The ID of the recipient being accessed. (required) 13889 :return: None 13890 If the method is called asynchronously, 13891 returns the request thread. 13892 """ 13893 13894 all_params = ['account_id', 'envelope_id', 'recipient_id'] 13895 all_params.append('callback') 13896 all_params.append('_return_http_data_only') 13897 all_params.append('_preload_content') 13898 all_params.append('_request_timeout') 13899 13900 params = locals() 13901 for key, val in iteritems(params['kwargs']): 13902 if key not in all_params: 13903 raise TypeError( 13904 "Got an unexpected keyword argument '%s'" 13905 " to method update_recipient_initials_image" % key 13906 ) 13907 params[key] = val 13908 del params['kwargs'] 13909 # verify the required parameter 'account_id' is set 13910 if ('account_id' not in params) or (params['account_id'] is None): 13911 raise ValueError("Missing the required parameter `account_id` when calling `update_recipient_initials_image`") 13912 # verify the required parameter 'envelope_id' is set 13913 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13914 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipient_initials_image`") 13915 # verify the required parameter 'recipient_id' is set 13916 if ('recipient_id' not in params) or (params['recipient_id'] is None): 13917 raise ValueError("Missing the required parameter `recipient_id` when calling `update_recipient_initials_image`") 13918 13919 13920 collection_formats = {} 13921 13922 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/initials_image'.replace('{format}', 'json') 13923 path_params = {} 13924 if 'account_id' in params: 13925 path_params['accountId'] = params['account_id'] 13926 if 'envelope_id' in params: 13927 path_params['envelopeId'] = params['envelope_id'] 13928 if 'recipient_id' in params: 13929 path_params['recipientId'] = params['recipient_id'] 13930 13931 query_params = {} 13932 13933 header_params = {} 13934 13935 form_params = [] 13936 local_var_files = {} 13937 13938 body_params = None 13939 # HTTP header `Accept` 13940 header_params['Accept'] = self.api_client.\ 13941 select_header_accept(['application/json']) 13942 13943 # HTTP header `Content-Type` 13944 header_params['Content-Type'] = self.api_client.\ 13945 select_header_content_type(['image/gif']) 13946 13947 # Authentication setting 13948 auth_settings = [] 13949 13950 return self.api_client.call_api(resource_path, 'PUT', 13951 path_params, 13952 query_params, 13953 header_params, 13954 body=body_params, 13955 post_params=form_params, 13956 files=local_var_files, 13957 response_type=None, 13958 auth_settings=auth_settings, 13959 callback=params.get('callback'), 13960 _return_http_data_only=params.get('_return_http_data_only'), 13961 _preload_content=params.get('_preload_content', True), 13962 _request_timeout=params.get('_request_timeout'), 13963 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)
13965 def update_recipient_signature_image(self, account_id, envelope_id, recipient_id, **kwargs): 13966 """ 13967 Sets the signature image for an accountless signer. 13968 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**. 13969 This method makes a synchronous HTTP request by default. To make an 13970 asynchronous HTTP request, please define a `callback` function 13971 to be invoked when receiving the response. 13972 >>> def callback_function(response): 13973 >>> pprint(response) 13974 >>> 13975 >>> thread = api.update_recipient_signature_image(account_id, envelope_id, recipient_id, callback=callback_function) 13976 13977 :param callback function: The callback function 13978 for asynchronous request. (optional) 13979 :param str account_id: The external account number (int) or account ID Guid. (required) 13980 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13981 :param str recipient_id: The ID of the recipient being accessed. (required) 13982 :return: None 13983 If the method is called asynchronously, 13984 returns the request thread. 13985 """ 13986 kwargs['_return_http_data_only'] = True 13987 if kwargs.get('callback'): 13988 return self.update_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13989 else: 13990 (data) = self.update_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13991 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)
13993 def update_recipient_signature_image_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 13994 """ 13995 Sets the signature image for an accountless signer. 13996 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**. 13997 This method makes a synchronous HTTP request by default. To make an 13998 asynchronous HTTP request, please define a `callback` function 13999 to be invoked when receiving the response. 14000 >>> def callback_function(response): 14001 >>> pprint(response) 14002 >>> 14003 >>> thread = api.update_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 14004 14005 :param callback function: The callback function 14006 for asynchronous request. (optional) 14007 :param str account_id: The external account number (int) or account ID Guid. (required) 14008 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14009 :param str recipient_id: The ID of the recipient being accessed. (required) 14010 :return: None 14011 If the method is called asynchronously, 14012 returns the request thread. 14013 """ 14014 14015 all_params = ['account_id', 'envelope_id', 'recipient_id'] 14016 all_params.append('callback') 14017 all_params.append('_return_http_data_only') 14018 all_params.append('_preload_content') 14019 all_params.append('_request_timeout') 14020 14021 params = locals() 14022 for key, val in iteritems(params['kwargs']): 14023 if key not in all_params: 14024 raise TypeError( 14025 "Got an unexpected keyword argument '%s'" 14026 " to method update_recipient_signature_image" % key 14027 ) 14028 params[key] = val 14029 del params['kwargs'] 14030 # verify the required parameter 'account_id' is set 14031 if ('account_id' not in params) or (params['account_id'] is None): 14032 raise ValueError("Missing the required parameter `account_id` when calling `update_recipient_signature_image`") 14033 # verify the required parameter 'envelope_id' is set 14034 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14035 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipient_signature_image`") 14036 # verify the required parameter 'recipient_id' is set 14037 if ('recipient_id' not in params) or (params['recipient_id'] is None): 14038 raise ValueError("Missing the required parameter `recipient_id` when calling `update_recipient_signature_image`") 14039 14040 14041 collection_formats = {} 14042 14043 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/signature_image'.replace('{format}', 'json') 14044 path_params = {} 14045 if 'account_id' in params: 14046 path_params['accountId'] = params['account_id'] 14047 if 'envelope_id' in params: 14048 path_params['envelopeId'] = params['envelope_id'] 14049 if 'recipient_id' in params: 14050 path_params['recipientId'] = params['recipient_id'] 14051 14052 query_params = {} 14053 14054 header_params = {} 14055 14056 form_params = [] 14057 local_var_files = {} 14058 14059 body_params = None 14060 # HTTP header `Accept` 14061 header_params['Accept'] = self.api_client.\ 14062 select_header_accept(['application/json']) 14063 14064 # HTTP header `Content-Type` 14065 header_params['Content-Type'] = self.api_client.\ 14066 select_header_content_type(['image/gif']) 14067 14068 # Authentication setting 14069 auth_settings = [] 14070 14071 return self.api_client.call_api(resource_path, 'PUT', 14072 path_params, 14073 query_params, 14074 header_params, 14075 body=body_params, 14076 post_params=form_params, 14077 files=local_var_files, 14078 response_type=None, 14079 auth_settings=auth_settings, 14080 callback=params.get('callback'), 14081 _return_http_data_only=params.get('_return_http_data_only'), 14082 _preload_content=params.get('_preload_content', True), 14083 _request_timeout=params.get('_request_timeout'), 14084 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)
14086 def update_recipients(self, account_id, envelope_id, **kwargs): 14087 """ 14088 Updates recipients in a draft envelope or corrects recipient information for an in process envelope. 14089 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). 14090 This method makes a synchronous HTTP request by default. To make an 14091 asynchronous HTTP request, please define a `callback` function 14092 to be invoked when receiving the response. 14093 >>> def callback_function(response): 14094 >>> pprint(response) 14095 >>> 14096 >>> thread = api.update_recipients(account_id, envelope_id, callback=callback_function) 14097 14098 :param callback function: The callback function 14099 for asynchronous request. (optional) 14100 :param str account_id: The external account number (int) or account ID Guid. (required) 14101 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14102 :param str combine_same_order_recipients: 14103 :param str offline_signing: 14104 :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. 14105 :param Recipients recipients: 14106 :return: RecipientsUpdateSummary 14107 If the method is called asynchronously, 14108 returns the request thread. 14109 """ 14110 kwargs['_return_http_data_only'] = True 14111 if kwargs.get('callback'): 14112 return self.update_recipients_with_http_info(account_id, envelope_id, **kwargs) 14113 else: 14114 (data) = self.update_recipients_with_http_info(account_id, envelope_id, **kwargs) 14115 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)
14117 def update_recipients_with_http_info(self, account_id, envelope_id, **kwargs): 14118 """ 14119 Updates recipients in a draft envelope or corrects recipient information for an in process envelope. 14120 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). 14121 This method makes a synchronous HTTP request by default. To make an 14122 asynchronous HTTP request, please define a `callback` function 14123 to be invoked when receiving the response. 14124 >>> def callback_function(response): 14125 >>> pprint(response) 14126 >>> 14127 >>> thread = api.update_recipients_with_http_info(account_id, envelope_id, callback=callback_function) 14128 14129 :param callback function: The callback function 14130 for asynchronous request. (optional) 14131 :param str account_id: The external account number (int) or account ID Guid. (required) 14132 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14133 :param str combine_same_order_recipients: 14134 :param str offline_signing: 14135 :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. 14136 :param Recipients recipients: 14137 :return: RecipientsUpdateSummary 14138 If the method is called asynchronously, 14139 returns the request thread. 14140 """ 14141 14142 all_params = ['account_id', 'envelope_id', 'combine_same_order_recipients', 'offline_signing', 'resend_envelope', 'recipients'] 14143 all_params.append('callback') 14144 all_params.append('_return_http_data_only') 14145 all_params.append('_preload_content') 14146 all_params.append('_request_timeout') 14147 14148 params = locals() 14149 for key, val in iteritems(params['kwargs']): 14150 if key not in all_params: 14151 raise TypeError( 14152 "Got an unexpected keyword argument '%s'" 14153 " to method update_recipients" % key 14154 ) 14155 params[key] = val 14156 del params['kwargs'] 14157 # verify the required parameter 'account_id' is set 14158 if ('account_id' not in params) or (params['account_id'] is None): 14159 raise ValueError("Missing the required parameter `account_id` when calling `update_recipients`") 14160 # verify the required parameter 'envelope_id' is set 14161 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14162 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipients`") 14163 14164 14165 collection_formats = {} 14166 14167 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients'.replace('{format}', 'json') 14168 path_params = {} 14169 if 'account_id' in params: 14170 path_params['accountId'] = params['account_id'] 14171 if 'envelope_id' in params: 14172 path_params['envelopeId'] = params['envelope_id'] 14173 14174 query_params = {} 14175 if 'combine_same_order_recipients' in params: 14176 query_params['combine_same_order_recipients'] = params['combine_same_order_recipients'] 14177 if 'offline_signing' in params: 14178 query_params['offline_signing'] = params['offline_signing'] 14179 if 'resend_envelope' in params: 14180 query_params['resend_envelope'] = params['resend_envelope'] 14181 14182 header_params = {} 14183 14184 form_params = [] 14185 local_var_files = {} 14186 14187 body_params = None 14188 if 'recipients' in params: 14189 body_params = params['recipients'] 14190 # HTTP header `Accept` 14191 header_params['Accept'] = self.api_client.\ 14192 select_header_accept(['application/json']) 14193 14194 # Authentication setting 14195 auth_settings = [] 14196 14197 return self.api_client.call_api(resource_path, 'PUT', 14198 path_params, 14199 query_params, 14200 header_params, 14201 body=body_params, 14202 post_params=form_params, 14203 files=local_var_files, 14204 response_type='RecipientsUpdateSummary', 14205 auth_settings=auth_settings, 14206 callback=params.get('callback'), 14207 _return_http_data_only=params.get('_return_http_data_only'), 14208 _preload_content=params.get('_preload_content', True), 14209 _request_timeout=params.get('_request_timeout'), 14210 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)
14212 def update_recipients_document_visibility(self, account_id, envelope_id, **kwargs): 14213 """ 14214 Updates document visibility for the recipients 14215 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. 14216 This method makes a synchronous HTTP request by default. To make an 14217 asynchronous HTTP request, please define a `callback` function 14218 to be invoked when receiving the response. 14219 >>> def callback_function(response): 14220 >>> pprint(response) 14221 >>> 14222 >>> thread = api.update_recipients_document_visibility(account_id, envelope_id, callback=callback_function) 14223 14224 :param callback function: The callback function 14225 for asynchronous request. (optional) 14226 :param str account_id: The external account number (int) or account ID Guid. (required) 14227 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14228 :param DocumentVisibilityList document_visibility_list: 14229 :return: DocumentVisibilityList 14230 If the method is called asynchronously, 14231 returns the request thread. 14232 """ 14233 kwargs['_return_http_data_only'] = True 14234 if kwargs.get('callback'): 14235 return self.update_recipients_document_visibility_with_http_info(account_id, envelope_id, **kwargs) 14236 else: 14237 (data) = self.update_recipients_document_visibility_with_http_info(account_id, envelope_id, **kwargs) 14238 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)
14240 def update_recipients_document_visibility_with_http_info(self, account_id, envelope_id, **kwargs): 14241 """ 14242 Updates document visibility for the recipients 14243 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. 14244 This method makes a synchronous HTTP request by default. To make an 14245 asynchronous HTTP request, please define a `callback` function 14246 to be invoked when receiving the response. 14247 >>> def callback_function(response): 14248 >>> pprint(response) 14249 >>> 14250 >>> thread = api.update_recipients_document_visibility_with_http_info(account_id, envelope_id, callback=callback_function) 14251 14252 :param callback function: The callback function 14253 for asynchronous request. (optional) 14254 :param str account_id: The external account number (int) or account ID Guid. (required) 14255 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14256 :param DocumentVisibilityList document_visibility_list: 14257 :return: DocumentVisibilityList 14258 If the method is called asynchronously, 14259 returns the request thread. 14260 """ 14261 14262 all_params = ['account_id', 'envelope_id', 'document_visibility_list'] 14263 all_params.append('callback') 14264 all_params.append('_return_http_data_only') 14265 all_params.append('_preload_content') 14266 all_params.append('_request_timeout') 14267 14268 params = locals() 14269 for key, val in iteritems(params['kwargs']): 14270 if key not in all_params: 14271 raise TypeError( 14272 "Got an unexpected keyword argument '%s'" 14273 " to method update_recipients_document_visibility" % key 14274 ) 14275 params[key] = val 14276 del params['kwargs'] 14277 # verify the required parameter 'account_id' is set 14278 if ('account_id' not in params) or (params['account_id'] is None): 14279 raise ValueError("Missing the required parameter `account_id` when calling `update_recipients_document_visibility`") 14280 # verify the required parameter 'envelope_id' is set 14281 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14282 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipients_document_visibility`") 14283 14284 14285 collection_formats = {} 14286 14287 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/document_visibility'.replace('{format}', 'json') 14288 path_params = {} 14289 if 'account_id' in params: 14290 path_params['accountId'] = params['account_id'] 14291 if 'envelope_id' in params: 14292 path_params['envelopeId'] = params['envelope_id'] 14293 14294 query_params = {} 14295 14296 header_params = {} 14297 14298 form_params = [] 14299 local_var_files = {} 14300 14301 body_params = None 14302 if 'document_visibility_list' in params: 14303 body_params = params['document_visibility_list'] 14304 # HTTP header `Accept` 14305 header_params['Accept'] = self.api_client.\ 14306 select_header_accept(['application/json']) 14307 14308 # Authentication setting 14309 auth_settings = [] 14310 14311 return self.api_client.call_api(resource_path, 'PUT', 14312 path_params, 14313 query_params, 14314 header_params, 14315 body=body_params, 14316 post_params=form_params, 14317 files=local_var_files, 14318 response_type='DocumentVisibilityList', 14319 auth_settings=auth_settings, 14320 callback=params.get('callback'), 14321 _return_http_data_only=params.get('_return_http_data_only'), 14322 _preload_content=params.get('_preload_content', True), 14323 _request_timeout=params.get('_request_timeout'), 14324 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)
14326 def update_tabs(self, account_id, envelope_id, recipient_id, **kwargs): 14327 """ 14328 Updates the tabs for a recipient. 14329 Updates one or more tabs for a recipient in a draft envelope. 14330 This method makes a synchronous HTTP request by default. To make an 14331 asynchronous HTTP request, please define a `callback` function 14332 to be invoked when receiving the response. 14333 >>> def callback_function(response): 14334 >>> pprint(response) 14335 >>> 14336 >>> thread = api.update_tabs(account_id, envelope_id, recipient_id, callback=callback_function) 14337 14338 :param callback function: The callback function 14339 for asynchronous request. (optional) 14340 :param str account_id: The external account number (int) or account ID Guid. (required) 14341 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14342 :param str recipient_id: The ID of the recipient being accessed. (required) 14343 :param Tabs tabs: 14344 :return: Tabs 14345 If the method is called asynchronously, 14346 returns the request thread. 14347 """ 14348 kwargs['_return_http_data_only'] = True 14349 if kwargs.get('callback'): 14350 return self.update_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 14351 else: 14352 (data) = self.update_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 14353 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)
14355 def update_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 14356 """ 14357 Updates the tabs for a recipient. 14358 Updates one or more tabs for a recipient in a draft envelope. 14359 This method makes a synchronous HTTP request by default. To make an 14360 asynchronous HTTP request, please define a `callback` function 14361 to be invoked when receiving the response. 14362 >>> def callback_function(response): 14363 >>> pprint(response) 14364 >>> 14365 >>> thread = api.update_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 14366 14367 :param callback function: The callback function 14368 for asynchronous request. (optional) 14369 :param str account_id: The external account number (int) or account ID Guid. (required) 14370 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14371 :param str recipient_id: The ID of the recipient being accessed. (required) 14372 :param Tabs tabs: 14373 :return: Tabs 14374 If the method is called asynchronously, 14375 returns the request thread. 14376 """ 14377 14378 all_params = ['account_id', 'envelope_id', 'recipient_id', 'tabs'] 14379 all_params.append('callback') 14380 all_params.append('_return_http_data_only') 14381 all_params.append('_preload_content') 14382 all_params.append('_request_timeout') 14383 14384 params = locals() 14385 for key, val in iteritems(params['kwargs']): 14386 if key not in all_params: 14387 raise TypeError( 14388 "Got an unexpected keyword argument '%s'" 14389 " to method update_tabs" % key 14390 ) 14391 params[key] = val 14392 del params['kwargs'] 14393 # verify the required parameter 'account_id' is set 14394 if ('account_id' not in params) or (params['account_id'] is None): 14395 raise ValueError("Missing the required parameter `account_id` when calling `update_tabs`") 14396 # verify the required parameter 'envelope_id' is set 14397 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14398 raise ValueError("Missing the required parameter `envelope_id` when calling `update_tabs`") 14399 # verify the required parameter 'recipient_id' is set 14400 if ('recipient_id' not in params) or (params['recipient_id'] is None): 14401 raise ValueError("Missing the required parameter `recipient_id` when calling `update_tabs`") 14402 14403 14404 collection_formats = {} 14405 14406 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/tabs'.replace('{format}', 'json') 14407 path_params = {} 14408 if 'account_id' in params: 14409 path_params['accountId'] = params['account_id'] 14410 if 'envelope_id' in params: 14411 path_params['envelopeId'] = params['envelope_id'] 14412 if 'recipient_id' in params: 14413 path_params['recipientId'] = params['recipient_id'] 14414 14415 query_params = {} 14416 14417 header_params = {} 14418 14419 form_params = [] 14420 local_var_files = {} 14421 14422 body_params = None 14423 if 'tabs' in params: 14424 body_params = params['tabs'] 14425 # HTTP header `Accept` 14426 header_params['Accept'] = self.api_client.\ 14427 select_header_accept(['application/json']) 14428 14429 # Authentication setting 14430 auth_settings = [] 14431 14432 return self.api_client.call_api(resource_path, 'PUT', 14433 path_params, 14434 query_params, 14435 header_params, 14436 body=body_params, 14437 post_params=form_params, 14438 files=local_var_files, 14439 response_type='Tabs', 14440 auth_settings=auth_settings, 14441 callback=params.get('callback'), 14442 _return_http_data_only=params.get('_return_http_data_only'), 14443 _preload_content=params.get('_preload_content', True), 14444 _request_timeout=params.get('_request_timeout'), 14445 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)
14447 def update_tabs_blob(self, account_id, envelope_id, **kwargs): 14448 """ 14449 Update encrypted tabs for envelope. 14450 14451 This method makes a synchronous HTTP request by default. To make an 14452 asynchronous HTTP request, please define a `callback` function 14453 to be invoked when receiving the response. 14454 >>> def callback_function(response): 14455 >>> pprint(response) 14456 >>> 14457 >>> thread = api.update_tabs_blob(account_id, envelope_id, callback=callback_function) 14458 14459 :param callback function: The callback function 14460 for asynchronous request. (optional) 14461 :param str account_id: The external account number (int) or account ID Guid. (required) 14462 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14463 :return: None 14464 If the method is called asynchronously, 14465 returns the request thread. 14466 """ 14467 kwargs['_return_http_data_only'] = True 14468 if kwargs.get('callback'): 14469 return self.update_tabs_blob_with_http_info(account_id, envelope_id, **kwargs) 14470 else: 14471 (data) = self.update_tabs_blob_with_http_info(account_id, envelope_id, **kwargs) 14472 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)
14474 def update_tabs_blob_with_http_info(self, account_id, envelope_id, **kwargs): 14475 """ 14476 Update encrypted tabs for envelope. 14477 14478 This method makes a synchronous HTTP request by default. To make an 14479 asynchronous HTTP request, please define a `callback` function 14480 to be invoked when receiving the response. 14481 >>> def callback_function(response): 14482 >>> pprint(response) 14483 >>> 14484 >>> thread = api.update_tabs_blob_with_http_info(account_id, envelope_id, callback=callback_function) 14485 14486 :param callback function: The callback function 14487 for asynchronous request. (optional) 14488 :param str account_id: The external account number (int) or account ID Guid. (required) 14489 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14490 :return: None 14491 If the method is called asynchronously, 14492 returns the request thread. 14493 """ 14494 14495 all_params = ['account_id', 'envelope_id'] 14496 all_params.append('callback') 14497 all_params.append('_return_http_data_only') 14498 all_params.append('_preload_content') 14499 all_params.append('_request_timeout') 14500 14501 params = locals() 14502 for key, val in iteritems(params['kwargs']): 14503 if key not in all_params: 14504 raise TypeError( 14505 "Got an unexpected keyword argument '%s'" 14506 " to method update_tabs_blob" % key 14507 ) 14508 params[key] = val 14509 del params['kwargs'] 14510 # verify the required parameter 'account_id' is set 14511 if ('account_id' not in params) or (params['account_id'] is None): 14512 raise ValueError("Missing the required parameter `account_id` when calling `update_tabs_blob`") 14513 # verify the required parameter 'envelope_id' is set 14514 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14515 raise ValueError("Missing the required parameter `envelope_id` when calling `update_tabs_blob`") 14516 14517 14518 collection_formats = {} 14519 14520 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/tabs_blob'.replace('{format}', 'json') 14521 path_params = {} 14522 if 'account_id' in params: 14523 path_params['accountId'] = params['account_id'] 14524 if 'envelope_id' in params: 14525 path_params['envelopeId'] = params['envelope_id'] 14526 14527 query_params = {} 14528 14529 header_params = {} 14530 14531 form_params = [] 14532 local_var_files = {} 14533 14534 body_params = None 14535 # HTTP header `Accept` 14536 header_params['Accept'] = self.api_client.\ 14537 select_header_accept(['application/json']) 14538 14539 # Authentication setting 14540 auth_settings = [] 14541 14542 return self.api_client.call_api(resource_path, 'PUT', 14543 path_params, 14544 query_params, 14545 header_params, 14546 body=body_params, 14547 post_params=form_params, 14548 files=local_var_files, 14549 response_type=None, 14550 auth_settings=auth_settings, 14551 callback=params.get('callback'), 14552 _return_http_data_only=params.get('_return_http_data_only'), 14553 _preload_content=params.get('_preload_content', True), 14554 _request_timeout=params.get('_request_timeout'), 14555 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)
14557 def update_template_delayed_routing_definition(self, account_id, template_id, workflow_step_id, **kwargs): 14558 """ 14559 Updates the delayed routing rules for a template's workflow step definition. 14560 This method makes a synchronous HTTP request by default. To make an 14561 asynchronous HTTP request, please define a `callback` function 14562 to be invoked when receiving the response. 14563 >>> def callback_function(response): 14564 >>> pprint(response) 14565 >>> 14566 >>> thread = api.update_template_delayed_routing_definition(account_id, template_id, workflow_step_id, callback=callback_function) 14567 14568 :param callback function: The callback function 14569 for asynchronous request. (optional) 14570 :param str account_id: The external account number (int) or account ID Guid. (required) 14571 :param str template_id: The ID of the template being accessed. (required) 14572 :param str workflow_step_id: (required) 14573 :param DelayedRouting delayed_routing: 14574 :return: DelayedRouting 14575 If the method is called asynchronously, 14576 returns the request thread. 14577 """ 14578 kwargs['_return_http_data_only'] = True 14579 if kwargs.get('callback'): 14580 return self.update_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 14581 else: 14582 (data) = self.update_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 14583 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)
14585 def update_template_delayed_routing_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 14586 """ 14587 Updates the delayed routing rules for a template's workflow step definition. 14588 This method makes a synchronous HTTP request by default. To make an 14589 asynchronous HTTP request, please define a `callback` function 14590 to be invoked when receiving the response. 14591 >>> def callback_function(response): 14592 >>> pprint(response) 14593 >>> 14594 >>> thread = api.update_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 14595 14596 :param callback function: The callback function 14597 for asynchronous request. (optional) 14598 :param str account_id: The external account number (int) or account ID Guid. (required) 14599 :param str template_id: The ID of the template being accessed. (required) 14600 :param str workflow_step_id: (required) 14601 :param DelayedRouting delayed_routing: 14602 :return: DelayedRouting 14603 If the method is called asynchronously, 14604 returns the request thread. 14605 """ 14606 14607 all_params = ['account_id', 'template_id', 'workflow_step_id', 'delayed_routing'] 14608 all_params.append('callback') 14609 all_params.append('_return_http_data_only') 14610 all_params.append('_preload_content') 14611 all_params.append('_request_timeout') 14612 14613 params = locals() 14614 for key, val in iteritems(params['kwargs']): 14615 if key not in all_params: 14616 raise TypeError( 14617 "Got an unexpected keyword argument '%s'" 14618 " to method update_template_delayed_routing_definition" % key 14619 ) 14620 params[key] = val 14621 del params['kwargs'] 14622 # verify the required parameter 'account_id' is set 14623 if ('account_id' not in params) or (params['account_id'] is None): 14624 raise ValueError("Missing the required parameter `account_id` when calling `update_template_delayed_routing_definition`") 14625 # verify the required parameter 'template_id' is set 14626 if ('template_id' not in params) or (params['template_id'] is None): 14627 raise ValueError("Missing the required parameter `template_id` when calling `update_template_delayed_routing_definition`") 14628 # verify the required parameter 'workflow_step_id' is set 14629 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 14630 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_template_delayed_routing_definition`") 14631 14632 14633 collection_formats = {} 14634 14635 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 14636 path_params = {} 14637 if 'account_id' in params: 14638 path_params['accountId'] = params['account_id'] 14639 if 'template_id' in params: 14640 path_params['templateId'] = params['template_id'] 14641 if 'workflow_step_id' in params: 14642 path_params['workflowStepId'] = params['workflow_step_id'] 14643 14644 query_params = {} 14645 14646 header_params = {} 14647 14648 form_params = [] 14649 local_var_files = {} 14650 14651 body_params = None 14652 if 'delayed_routing' in params: 14653 body_params = params['delayed_routing'] 14654 # HTTP header `Accept` 14655 header_params['Accept'] = self.api_client.\ 14656 select_header_accept(['application/json']) 14657 14658 # Authentication setting 14659 auth_settings = [] 14660 14661 return self.api_client.call_api(resource_path, 'PUT', 14662 path_params, 14663 query_params, 14664 header_params, 14665 body=body_params, 14666 post_params=form_params, 14667 files=local_var_files, 14668 response_type='DelayedRouting', 14669 auth_settings=auth_settings, 14670 callback=params.get('callback'), 14671 _return_http_data_only=params.get('_return_http_data_only'), 14672 _preload_content=params.get('_preload_content', True), 14673 _request_timeout=params.get('_request_timeout'), 14674 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)
14676 def update_template_recipient_document_visibility(self, account_id, recipient_id, template_id, **kwargs): 14677 """ 14678 Updates document visibility for the recipients 14679 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. 14680 This method makes a synchronous HTTP request by default. To make an 14681 asynchronous HTTP request, please define a `callback` function 14682 to be invoked when receiving the response. 14683 >>> def callback_function(response): 14684 >>> pprint(response) 14685 >>> 14686 >>> thread = api.update_template_recipient_document_visibility(account_id, recipient_id, template_id, callback=callback_function) 14687 14688 :param callback function: The callback function 14689 for asynchronous request. (optional) 14690 :param str account_id: The external account number (int) or account ID Guid. (required) 14691 :param str recipient_id: The ID of the recipient being accessed. (required) 14692 :param str template_id: The ID of the template being accessed. (required) 14693 :param TemplateDocumentVisibilityList template_document_visibility_list: 14694 :return: TemplateDocumentVisibilityList 14695 If the method is called asynchronously, 14696 returns the request thread. 14697 """ 14698 kwargs['_return_http_data_only'] = True 14699 if kwargs.get('callback'): 14700 return self.update_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, **kwargs) 14701 else: 14702 (data) = self.update_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, **kwargs) 14703 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)
14705 def update_template_recipient_document_visibility_with_http_info(self, account_id, recipient_id, template_id, **kwargs): 14706 """ 14707 Updates document visibility for the recipients 14708 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. 14709 This method makes a synchronous HTTP request by default. To make an 14710 asynchronous HTTP request, please define a `callback` function 14711 to be invoked when receiving the response. 14712 >>> def callback_function(response): 14713 >>> pprint(response) 14714 >>> 14715 >>> thread = api.update_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, callback=callback_function) 14716 14717 :param callback function: The callback function 14718 for asynchronous request. (optional) 14719 :param str account_id: The external account number (int) or account ID Guid. (required) 14720 :param str recipient_id: The ID of the recipient being accessed. (required) 14721 :param str template_id: The ID of the template being accessed. (required) 14722 :param TemplateDocumentVisibilityList template_document_visibility_list: 14723 :return: TemplateDocumentVisibilityList 14724 If the method is called asynchronously, 14725 returns the request thread. 14726 """ 14727 14728 all_params = ['account_id', 'recipient_id', 'template_id', 'template_document_visibility_list'] 14729 all_params.append('callback') 14730 all_params.append('_return_http_data_only') 14731 all_params.append('_preload_content') 14732 all_params.append('_request_timeout') 14733 14734 params = locals() 14735 for key, val in iteritems(params['kwargs']): 14736 if key not in all_params: 14737 raise TypeError( 14738 "Got an unexpected keyword argument '%s'" 14739 " to method update_template_recipient_document_visibility" % key 14740 ) 14741 params[key] = val 14742 del params['kwargs'] 14743 # verify the required parameter 'account_id' is set 14744 if ('account_id' not in params) or (params['account_id'] is None): 14745 raise ValueError("Missing the required parameter `account_id` when calling `update_template_recipient_document_visibility`") 14746 # verify the required parameter 'recipient_id' is set 14747 if ('recipient_id' not in params) or (params['recipient_id'] is None): 14748 raise ValueError("Missing the required parameter `recipient_id` when calling `update_template_recipient_document_visibility`") 14749 # verify the required parameter 'template_id' is set 14750 if ('template_id' not in params) or (params['template_id'] is None): 14751 raise ValueError("Missing the required parameter `template_id` when calling `update_template_recipient_document_visibility`") 14752 14753 14754 collection_formats = {} 14755 14756 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/recipients/{recipientId}/document_visibility'.replace('{format}', 'json') 14757 path_params = {} 14758 if 'account_id' in params: 14759 path_params['accountId'] = params['account_id'] 14760 if 'recipient_id' in params: 14761 path_params['recipientId'] = params['recipient_id'] 14762 if 'template_id' in params: 14763 path_params['templateId'] = params['template_id'] 14764 14765 query_params = {} 14766 14767 header_params = {} 14768 14769 form_params = [] 14770 local_var_files = {} 14771 14772 body_params = None 14773 if 'template_document_visibility_list' in params: 14774 body_params = params['template_document_visibility_list'] 14775 # HTTP header `Accept` 14776 header_params['Accept'] = self.api_client.\ 14777 select_header_accept(['application/json']) 14778 14779 # Authentication setting 14780 auth_settings = [] 14781 14782 return self.api_client.call_api(resource_path, 'PUT', 14783 path_params, 14784 query_params, 14785 header_params, 14786 body=body_params, 14787 post_params=form_params, 14788 files=local_var_files, 14789 response_type='TemplateDocumentVisibilityList', 14790 auth_settings=auth_settings, 14791 callback=params.get('callback'), 14792 _return_http_data_only=params.get('_return_http_data_only'), 14793 _preload_content=params.get('_preload_content', True), 14794 _request_timeout=params.get('_request_timeout'), 14795 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)
14797 def update_template_recipients_document_visibility(self, account_id, template_id, **kwargs): 14798 """ 14799 Updates document visibility for the recipients 14800 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. 14801 This method makes a synchronous HTTP request by default. To make an 14802 asynchronous HTTP request, please define a `callback` function 14803 to be invoked when receiving the response. 14804 >>> def callback_function(response): 14805 >>> pprint(response) 14806 >>> 14807 >>> thread = api.update_template_recipients_document_visibility(account_id, template_id, callback=callback_function) 14808 14809 :param callback function: The callback function 14810 for asynchronous request. (optional) 14811 :param str account_id: The external account number (int) or account ID Guid. (required) 14812 :param str template_id: The ID of the template being accessed. (required) 14813 :param TemplateDocumentVisibilityList template_document_visibility_list: 14814 :return: TemplateDocumentVisibilityList 14815 If the method is called asynchronously, 14816 returns the request thread. 14817 """ 14818 kwargs['_return_http_data_only'] = True 14819 if kwargs.get('callback'): 14820 return self.update_template_recipients_document_visibility_with_http_info(account_id, template_id, **kwargs) 14821 else: 14822 (data) = self.update_template_recipients_document_visibility_with_http_info(account_id, template_id, **kwargs) 14823 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)
14825 def update_template_recipients_document_visibility_with_http_info(self, account_id, template_id, **kwargs): 14826 """ 14827 Updates document visibility for the recipients 14828 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. 14829 This method makes a synchronous HTTP request by default. To make an 14830 asynchronous HTTP request, please define a `callback` function 14831 to be invoked when receiving the response. 14832 >>> def callback_function(response): 14833 >>> pprint(response) 14834 >>> 14835 >>> thread = api.update_template_recipients_document_visibility_with_http_info(account_id, template_id, callback=callback_function) 14836 14837 :param callback function: The callback function 14838 for asynchronous request. (optional) 14839 :param str account_id: The external account number (int) or account ID Guid. (required) 14840 :param str template_id: The ID of the template being accessed. (required) 14841 :param TemplateDocumentVisibilityList template_document_visibility_list: 14842 :return: TemplateDocumentVisibilityList 14843 If the method is called asynchronously, 14844 returns the request thread. 14845 """ 14846 14847 all_params = ['account_id', 'template_id', 'template_document_visibility_list'] 14848 all_params.append('callback') 14849 all_params.append('_return_http_data_only') 14850 all_params.append('_preload_content') 14851 all_params.append('_request_timeout') 14852 14853 params = locals() 14854 for key, val in iteritems(params['kwargs']): 14855 if key not in all_params: 14856 raise TypeError( 14857 "Got an unexpected keyword argument '%s'" 14858 " to method update_template_recipients_document_visibility" % key 14859 ) 14860 params[key] = val 14861 del params['kwargs'] 14862 # verify the required parameter 'account_id' is set 14863 if ('account_id' not in params) or (params['account_id'] is None): 14864 raise ValueError("Missing the required parameter `account_id` when calling `update_template_recipients_document_visibility`") 14865 # verify the required parameter 'template_id' is set 14866 if ('template_id' not in params) or (params['template_id'] is None): 14867 raise ValueError("Missing the required parameter `template_id` when calling `update_template_recipients_document_visibility`") 14868 14869 14870 collection_formats = {} 14871 14872 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/recipients/document_visibility'.replace('{format}', 'json') 14873 path_params = {} 14874 if 'account_id' in params: 14875 path_params['accountId'] = params['account_id'] 14876 if 'template_id' in params: 14877 path_params['templateId'] = params['template_id'] 14878 14879 query_params = {} 14880 14881 header_params = {} 14882 14883 form_params = [] 14884 local_var_files = {} 14885 14886 body_params = None 14887 if 'template_document_visibility_list' in params: 14888 body_params = params['template_document_visibility_list'] 14889 # HTTP header `Accept` 14890 header_params['Accept'] = self.api_client.\ 14891 select_header_accept(['application/json']) 14892 14893 # Authentication setting 14894 auth_settings = [] 14895 14896 return self.api_client.call_api(resource_path, 'PUT', 14897 path_params, 14898 query_params, 14899 header_params, 14900 body=body_params, 14901 post_params=form_params, 14902 files=local_var_files, 14903 response_type='TemplateDocumentVisibilityList', 14904 auth_settings=auth_settings, 14905 callback=params.get('callback'), 14906 _return_http_data_only=params.get('_return_http_data_only'), 14907 _preload_content=params.get('_preload_content', True), 14908 _request_timeout=params.get('_request_timeout'), 14909 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)
14911 def update_template_scheduled_sending_definition(self, account_id, template_id, **kwargs): 14912 """ 14913 Updates the scheduled sending rules for a template's workflow definition. 14914 This method makes a synchronous HTTP request by default. To make an 14915 asynchronous HTTP request, please define a `callback` function 14916 to be invoked when receiving the response. 14917 >>> def callback_function(response): 14918 >>> pprint(response) 14919 >>> 14920 >>> thread = api.update_template_scheduled_sending_definition(account_id, template_id, callback=callback_function) 14921 14922 :param callback function: The callback function 14923 for asynchronous request. (optional) 14924 :param str account_id: The external account number (int) or account ID Guid. (required) 14925 :param str template_id: The ID of the template being accessed. (required) 14926 :param ScheduledSending scheduled_sending: 14927 :return: ScheduledSending 14928 If the method is called asynchronously, 14929 returns the request thread. 14930 """ 14931 kwargs['_return_http_data_only'] = True 14932 if kwargs.get('callback'): 14933 return self.update_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 14934 else: 14935 (data) = self.update_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 14936 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)
14938 def update_template_scheduled_sending_definition_with_http_info(self, account_id, template_id, **kwargs): 14939 """ 14940 Updates the scheduled sending rules for a template's workflow definition. 14941 This method makes a synchronous HTTP request by default. To make an 14942 asynchronous HTTP request, please define a `callback` function 14943 to be invoked when receiving the response. 14944 >>> def callback_function(response): 14945 >>> pprint(response) 14946 >>> 14947 >>> thread = api.update_template_scheduled_sending_definition_with_http_info(account_id, template_id, callback=callback_function) 14948 14949 :param callback function: The callback function 14950 for asynchronous request. (optional) 14951 :param str account_id: The external account number (int) or account ID Guid. (required) 14952 :param str template_id: The ID of the template being accessed. (required) 14953 :param ScheduledSending scheduled_sending: 14954 :return: ScheduledSending 14955 If the method is called asynchronously, 14956 returns the request thread. 14957 """ 14958 14959 all_params = ['account_id', 'template_id', 'scheduled_sending'] 14960 all_params.append('callback') 14961 all_params.append('_return_http_data_only') 14962 all_params.append('_preload_content') 14963 all_params.append('_request_timeout') 14964 14965 params = locals() 14966 for key, val in iteritems(params['kwargs']): 14967 if key not in all_params: 14968 raise TypeError( 14969 "Got an unexpected keyword argument '%s'" 14970 " to method update_template_scheduled_sending_definition" % key 14971 ) 14972 params[key] = val 14973 del params['kwargs'] 14974 # verify the required parameter 'account_id' is set 14975 if ('account_id' not in params) or (params['account_id'] is None): 14976 raise ValueError("Missing the required parameter `account_id` when calling `update_template_scheduled_sending_definition`") 14977 # verify the required parameter 'template_id' is set 14978 if ('template_id' not in params) or (params['template_id'] is None): 14979 raise ValueError("Missing the required parameter `template_id` when calling `update_template_scheduled_sending_definition`") 14980 14981 14982 collection_formats = {} 14983 14984 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/scheduledSending'.replace('{format}', 'json') 14985 path_params = {} 14986 if 'account_id' in params: 14987 path_params['accountId'] = params['account_id'] 14988 if 'template_id' in params: 14989 path_params['templateId'] = params['template_id'] 14990 14991 query_params = {} 14992 14993 header_params = {} 14994 14995 form_params = [] 14996 local_var_files = {} 14997 14998 body_params = None 14999 if 'scheduled_sending' in params: 15000 body_params = params['scheduled_sending'] 15001 # HTTP header `Accept` 15002 header_params['Accept'] = self.api_client.\ 15003 select_header_accept(['application/json']) 15004 15005 # Authentication setting 15006 auth_settings = [] 15007 15008 return self.api_client.call_api(resource_path, 'PUT', 15009 path_params, 15010 query_params, 15011 header_params, 15012 body=body_params, 15013 post_params=form_params, 15014 files=local_var_files, 15015 response_type='ScheduledSending', 15016 auth_settings=auth_settings, 15017 callback=params.get('callback'), 15018 _return_http_data_only=params.get('_return_http_data_only'), 15019 _preload_content=params.get('_preload_content', True), 15020 _request_timeout=params.get('_request_timeout'), 15021 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)
15023 def update_template_workflow_definition(self, account_id, template_id, **kwargs): 15024 """ 15025 Updates the workflow definition for a template. 15026 Updates the specified template's workflow definition if it has one. 15027 This method makes a synchronous HTTP request by default. To make an 15028 asynchronous HTTP request, please define a `callback` function 15029 to be invoked when receiving the response. 15030 >>> def callback_function(response): 15031 >>> pprint(response) 15032 >>> 15033 >>> thread = api.update_template_workflow_definition(account_id, template_id, callback=callback_function) 15034 15035 :param callback function: The callback function 15036 for asynchronous request. (optional) 15037 :param str account_id: The external account number (int) or account ID Guid. (required) 15038 :param str template_id: The ID of the template being accessed. (required) 15039 :param Workflow workflow: 15040 :return: Workflow 15041 If the method is called asynchronously, 15042 returns the request thread. 15043 """ 15044 kwargs['_return_http_data_only'] = True 15045 if kwargs.get('callback'): 15046 return self.update_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 15047 else: 15048 (data) = self.update_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 15049 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)
15051 def update_template_workflow_definition_with_http_info(self, account_id, template_id, **kwargs): 15052 """ 15053 Updates the workflow definition for a template. 15054 Updates the specified template's workflow definition if it has one. 15055 This method makes a synchronous HTTP request by default. To make an 15056 asynchronous HTTP request, please define a `callback` function 15057 to be invoked when receiving the response. 15058 >>> def callback_function(response): 15059 >>> pprint(response) 15060 >>> 15061 >>> thread = api.update_template_workflow_definition_with_http_info(account_id, template_id, callback=callback_function) 15062 15063 :param callback function: The callback function 15064 for asynchronous request. (optional) 15065 :param str account_id: The external account number (int) or account ID Guid. (required) 15066 :param str template_id: The ID of the template being accessed. (required) 15067 :param Workflow workflow: 15068 :return: Workflow 15069 If the method is called asynchronously, 15070 returns the request thread. 15071 """ 15072 15073 all_params = ['account_id', 'template_id', 'workflow'] 15074 all_params.append('callback') 15075 all_params.append('_return_http_data_only') 15076 all_params.append('_preload_content') 15077 all_params.append('_request_timeout') 15078 15079 params = locals() 15080 for key, val in iteritems(params['kwargs']): 15081 if key not in all_params: 15082 raise TypeError( 15083 "Got an unexpected keyword argument '%s'" 15084 " to method update_template_workflow_definition" % key 15085 ) 15086 params[key] = val 15087 del params['kwargs'] 15088 # verify the required parameter 'account_id' is set 15089 if ('account_id' not in params) or (params['account_id'] is None): 15090 raise ValueError("Missing the required parameter `account_id` when calling `update_template_workflow_definition`") 15091 # verify the required parameter 'template_id' is set 15092 if ('template_id' not in params) or (params['template_id'] is None): 15093 raise ValueError("Missing the required parameter `template_id` when calling `update_template_workflow_definition`") 15094 15095 15096 collection_formats = {} 15097 15098 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow'.replace('{format}', 'json') 15099 path_params = {} 15100 if 'account_id' in params: 15101 path_params['accountId'] = params['account_id'] 15102 if 'template_id' in params: 15103 path_params['templateId'] = params['template_id'] 15104 15105 query_params = {} 15106 15107 header_params = {} 15108 15109 form_params = [] 15110 local_var_files = {} 15111 15112 body_params = None 15113 if 'workflow' in params: 15114 body_params = params['workflow'] 15115 # HTTP header `Accept` 15116 header_params['Accept'] = self.api_client.\ 15117 select_header_accept(['application/json']) 15118 15119 # Authentication setting 15120 auth_settings = [] 15121 15122 return self.api_client.call_api(resource_path, 'PUT', 15123 path_params, 15124 query_params, 15125 header_params, 15126 body=body_params, 15127 post_params=form_params, 15128 files=local_var_files, 15129 response_type='Workflow', 15130 auth_settings=auth_settings, 15131 callback=params.get('callback'), 15132 _return_http_data_only=params.get('_return_http_data_only'), 15133 _preload_content=params.get('_preload_content', True), 15134 _request_timeout=params.get('_request_timeout'), 15135 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)
15137 def update_template_workflow_step_definition(self, account_id, template_id, workflow_step_id, **kwargs): 15138 """ 15139 Updates the template workflow step definition for an envelope. 15140 This method makes a synchronous HTTP request by default. To make an 15141 asynchronous HTTP request, please define a `callback` function 15142 to be invoked when receiving the response. 15143 >>> def callback_function(response): 15144 >>> pprint(response) 15145 >>> 15146 >>> thread = api.update_template_workflow_step_definition(account_id, template_id, workflow_step_id, callback=callback_function) 15147 15148 :param callback function: The callback function 15149 for asynchronous request. (optional) 15150 :param str account_id: The external account number (int) or account ID Guid. (required) 15151 :param str template_id: The ID of the template being accessed. (required) 15152 :param str workflow_step_id: (required) 15153 :param WorkflowStep workflow_step: 15154 :return: WorkflowStep 15155 If the method is called asynchronously, 15156 returns the request thread. 15157 """ 15158 kwargs['_return_http_data_only'] = True 15159 if kwargs.get('callback'): 15160 return self.update_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 15161 else: 15162 (data) = self.update_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 15163 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)
15165 def update_template_workflow_step_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 15166 """ 15167 Updates the template workflow step definition for an envelope. 15168 This method makes a synchronous HTTP request by default. To make an 15169 asynchronous HTTP request, please define a `callback` function 15170 to be invoked when receiving the response. 15171 >>> def callback_function(response): 15172 >>> pprint(response) 15173 >>> 15174 >>> thread = api.update_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 15175 15176 :param callback function: The callback function 15177 for asynchronous request. (optional) 15178 :param str account_id: The external account number (int) or account ID Guid. (required) 15179 :param str template_id: The ID of the template being accessed. (required) 15180 :param str workflow_step_id: (required) 15181 :param WorkflowStep workflow_step: 15182 :return: WorkflowStep 15183 If the method is called asynchronously, 15184 returns the request thread. 15185 """ 15186 15187 all_params = ['account_id', 'template_id', 'workflow_step_id', 'workflow_step'] 15188 all_params.append('callback') 15189 all_params.append('_return_http_data_only') 15190 all_params.append('_preload_content') 15191 all_params.append('_request_timeout') 15192 15193 params = locals() 15194 for key, val in iteritems(params['kwargs']): 15195 if key not in all_params: 15196 raise TypeError( 15197 "Got an unexpected keyword argument '%s'" 15198 " to method update_template_workflow_step_definition" % key 15199 ) 15200 params[key] = val 15201 del params['kwargs'] 15202 # verify the required parameter 'account_id' is set 15203 if ('account_id' not in params) or (params['account_id'] is None): 15204 raise ValueError("Missing the required parameter `account_id` when calling `update_template_workflow_step_definition`") 15205 # verify the required parameter 'template_id' is set 15206 if ('template_id' not in params) or (params['template_id'] is None): 15207 raise ValueError("Missing the required parameter `template_id` when calling `update_template_workflow_step_definition`") 15208 # verify the required parameter 'workflow_step_id' is set 15209 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 15210 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_template_workflow_step_definition`") 15211 15212 15213 collection_formats = {} 15214 15215 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 15216 path_params = {} 15217 if 'account_id' in params: 15218 path_params['accountId'] = params['account_id'] 15219 if 'template_id' in params: 15220 path_params['templateId'] = params['template_id'] 15221 if 'workflow_step_id' in params: 15222 path_params['workflowStepId'] = params['workflow_step_id'] 15223 15224 query_params = {} 15225 15226 header_params = {} 15227 15228 form_params = [] 15229 local_var_files = {} 15230 15231 body_params = None 15232 if 'workflow_step' in params: 15233 body_params = params['workflow_step'] 15234 # HTTP header `Accept` 15235 header_params['Accept'] = self.api_client.\ 15236 select_header_accept(['application/json']) 15237 15238 # Authentication setting 15239 auth_settings = [] 15240 15241 return self.api_client.call_api(resource_path, 'PUT', 15242 path_params, 15243 query_params, 15244 header_params, 15245 body=body_params, 15246 post_params=form_params, 15247 files=local_var_files, 15248 response_type='WorkflowStep', 15249 auth_settings=auth_settings, 15250 callback=params.get('callback'), 15251 _return_http_data_only=params.get('_return_http_data_only'), 15252 _preload_content=params.get('_preload_content', True), 15253 _request_timeout=params.get('_request_timeout'), 15254 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.