docusign_esign.apis.envelopes_api
DocuSign REST API
The DocuSign 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 REST API 5 6 The DocuSign REST API provides you with a powerful, convenient, and simple Web services API for interacting with DocuSign. # noqa: E501 7 8 OpenAPI spec version: v2.1 9 Contact: devcenter@docusign.com 10 Generated by: https://github.com/swagger-api/swagger-codegen.git 11""" 12 13 14from __future__ import absolute_import 15 16import sys 17import os 18import re 19 20# python 2 and python 3 compatibility library 21from six import iteritems 22 23from ..client.configuration import Configuration 24from ..client.api_client import ApiClient 25 26 27class 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 CorrectViewRequest correct_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 CorrectViewRequest correct_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', 'correct_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 'correct_view_request' in params: 591 body_params = params['correct_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 ReturnUrlRequest return_url_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 ReturnUrlRequest return_url_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', 'return_url_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 'return_url_request' in params: 1182 body_params = params['return_url_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, token_scopes, **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, token_scopes, 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: (required) 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, token_scopes, **kwargs) 2603 else: 2604 (data) = self.create_recipient_proof_file_resource_token_with_http_info(account_id, envelope_id, recipient_id, token_scopes, **kwargs) 2605 return data 2606 2607 def create_recipient_proof_file_resource_token_with_http_info(self, account_id, envelope_id, recipient_id, token_scopes, **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, token_scopes, 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: (required) 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 # verify the required parameter 'token_scopes' is set 2655 if ('token_scopes' not in params) or (params['token_scopes'] is None): 2656 raise ValueError("Missing the required parameter `token_scopes` when calling `create_recipient_proof_file_resource_token`") 2657 2658 2659 collection_formats = {} 2660 2661 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/identity_proof_token'.replace('{format}', 'json') 2662 path_params = {} 2663 if 'account_id' in params: 2664 path_params['accountId'] = params['account_id'] 2665 if 'envelope_id' in params: 2666 path_params['envelopeId'] = params['envelope_id'] 2667 if 'recipient_id' in params: 2668 path_params['recipientId'] = params['recipient_id'] 2669 if 'token_scopes' in params: 2670 path_params['token_scopes'] = params['token_scopes'] 2671 2672 query_params = {} 2673 2674 header_params = {} 2675 2676 form_params = [] 2677 local_var_files = {} 2678 2679 body_params = None 2680 # HTTP header `Accept` 2681 header_params['Accept'] = self.api_client.\ 2682 select_header_accept(['application/json']) 2683 2684 # Authentication setting 2685 auth_settings = [] 2686 2687 return self.api_client.call_api(resource_path, 'POST', 2688 path_params, 2689 query_params, 2690 header_params, 2691 body=body_params, 2692 post_params=form_params, 2693 files=local_var_files, 2694 response_type='IdEvidenceResourceToken', 2695 auth_settings=auth_settings, 2696 callback=params.get('callback'), 2697 _return_http_data_only=params.get('_return_http_data_only'), 2698 _preload_content=params.get('_preload_content', True), 2699 _request_timeout=params.get('_request_timeout'), 2700 collection_formats=collection_formats) 2701 2702 def create_recipient_view(self, account_id, envelope_id, **kwargs): 2703 """ 2704 Returns a URL to the recipient view UI. 2705 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. 2706 This method makes a synchronous HTTP request by default. To make an 2707 asynchronous HTTP request, please define a `callback` function 2708 to be invoked when receiving the response. 2709 >>> def callback_function(response): 2710 >>> pprint(response) 2711 >>> 2712 >>> thread = api.create_recipient_view(account_id, envelope_id, callback=callback_function) 2713 2714 :param callback function: The callback function 2715 for asynchronous request. (optional) 2716 :param str account_id: The external account number (int) or account ID Guid. (required) 2717 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2718 :param RecipientViewRequest recipient_view_request: 2719 :return: ViewUrl 2720 If the method is called asynchronously, 2721 returns the request thread. 2722 """ 2723 kwargs['_return_http_data_only'] = True 2724 if kwargs.get('callback'): 2725 return self.create_recipient_view_with_http_info(account_id, envelope_id, **kwargs) 2726 else: 2727 (data) = self.create_recipient_view_with_http_info(account_id, envelope_id, **kwargs) 2728 return data 2729 2730 def create_recipient_view_with_http_info(self, account_id, envelope_id, **kwargs): 2731 """ 2732 Returns a URL to the recipient view UI. 2733 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. 2734 This method makes a synchronous HTTP request by default. To make an 2735 asynchronous HTTP request, please define a `callback` function 2736 to be invoked when receiving the response. 2737 >>> def callback_function(response): 2738 >>> pprint(response) 2739 >>> 2740 >>> thread = api.create_recipient_view_with_http_info(account_id, envelope_id, callback=callback_function) 2741 2742 :param callback function: The callback function 2743 for asynchronous request. (optional) 2744 :param str account_id: The external account number (int) or account ID Guid. (required) 2745 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2746 :param RecipientViewRequest recipient_view_request: 2747 :return: ViewUrl 2748 If the method is called asynchronously, 2749 returns the request thread. 2750 """ 2751 2752 all_params = ['account_id', 'envelope_id', 'recipient_view_request'] 2753 all_params.append('callback') 2754 all_params.append('_return_http_data_only') 2755 all_params.append('_preload_content') 2756 all_params.append('_request_timeout') 2757 2758 params = locals() 2759 for key, val in iteritems(params['kwargs']): 2760 if key not in all_params: 2761 raise TypeError( 2762 "Got an unexpected keyword argument '%s'" 2763 " to method create_recipient_view" % key 2764 ) 2765 params[key] = val 2766 del params['kwargs'] 2767 # verify the required parameter 'account_id' is set 2768 if ('account_id' not in params) or (params['account_id'] is None): 2769 raise ValueError("Missing the required parameter `account_id` when calling `create_recipient_view`") 2770 # verify the required parameter 'envelope_id' is set 2771 if ('envelope_id' not in params) or (params['envelope_id'] is None): 2772 raise ValueError("Missing the required parameter `envelope_id` when calling `create_recipient_view`") 2773 2774 2775 collection_formats = {} 2776 2777 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/recipient'.replace('{format}', 'json') 2778 path_params = {} 2779 if 'account_id' in params: 2780 path_params['accountId'] = params['account_id'] 2781 if 'envelope_id' in params: 2782 path_params['envelopeId'] = params['envelope_id'] 2783 2784 query_params = {} 2785 2786 header_params = {} 2787 2788 form_params = [] 2789 local_var_files = {} 2790 2791 body_params = None 2792 if 'recipient_view_request' in params: 2793 body_params = params['recipient_view_request'] 2794 # HTTP header `Accept` 2795 header_params['Accept'] = self.api_client.\ 2796 select_header_accept(['application/json']) 2797 2798 # Authentication setting 2799 auth_settings = [] 2800 2801 return self.api_client.call_api(resource_path, 'POST', 2802 path_params, 2803 query_params, 2804 header_params, 2805 body=body_params, 2806 post_params=form_params, 2807 files=local_var_files, 2808 response_type='ViewUrl', 2809 auth_settings=auth_settings, 2810 callback=params.get('callback'), 2811 _return_http_data_only=params.get('_return_http_data_only'), 2812 _preload_content=params.get('_preload_content', True), 2813 _request_timeout=params.get('_request_timeout'), 2814 collection_formats=collection_formats) 2815 2816 def create_responsive_html_preview(self, account_id, envelope_id, **kwargs): 2817 """ 2818 Get Responsive HTML Preview for all documents in an envelope. 2819 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. 2820 This method makes a synchronous HTTP request by default. To make an 2821 asynchronous HTTP request, please define a `callback` function 2822 to be invoked when receiving the response. 2823 >>> def callback_function(response): 2824 >>> pprint(response) 2825 >>> 2826 >>> thread = api.create_responsive_html_preview(account_id, envelope_id, callback=callback_function) 2827 2828 :param callback function: The callback function 2829 for asynchronous request. (optional) 2830 :param str account_id: The external account number (int) or account ID Guid. (required) 2831 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2832 :param DocumentHtmlDefinition document_html_definition: 2833 :return: DocumentHtmlDefinitions 2834 If the method is called asynchronously, 2835 returns the request thread. 2836 """ 2837 kwargs['_return_http_data_only'] = True 2838 if kwargs.get('callback'): 2839 return self.create_responsive_html_preview_with_http_info(account_id, envelope_id, **kwargs) 2840 else: 2841 (data) = self.create_responsive_html_preview_with_http_info(account_id, envelope_id, **kwargs) 2842 return data 2843 2844 def create_responsive_html_preview_with_http_info(self, account_id, envelope_id, **kwargs): 2845 """ 2846 Get Responsive HTML Preview for all documents in an envelope. 2847 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. 2848 This method makes a synchronous HTTP request by default. To make an 2849 asynchronous HTTP request, please define a `callback` function 2850 to be invoked when receiving the response. 2851 >>> def callback_function(response): 2852 >>> pprint(response) 2853 >>> 2854 >>> thread = api.create_responsive_html_preview_with_http_info(account_id, envelope_id, callback=callback_function) 2855 2856 :param callback function: The callback function 2857 for asynchronous request. (optional) 2858 :param str account_id: The external account number (int) or account ID Guid. (required) 2859 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2860 :param DocumentHtmlDefinition document_html_definition: 2861 :return: DocumentHtmlDefinitions 2862 If the method is called asynchronously, 2863 returns the request thread. 2864 """ 2865 2866 all_params = ['account_id', 'envelope_id', 'document_html_definition'] 2867 all_params.append('callback') 2868 all_params.append('_return_http_data_only') 2869 all_params.append('_preload_content') 2870 all_params.append('_request_timeout') 2871 2872 params = locals() 2873 for key, val in iteritems(params['kwargs']): 2874 if key not in all_params: 2875 raise TypeError( 2876 "Got an unexpected keyword argument '%s'" 2877 " to method create_responsive_html_preview" % key 2878 ) 2879 params[key] = val 2880 del params['kwargs'] 2881 # verify the required parameter 'account_id' is set 2882 if ('account_id' not in params) or (params['account_id'] is None): 2883 raise ValueError("Missing the required parameter `account_id` when calling `create_responsive_html_preview`") 2884 # verify the required parameter 'envelope_id' is set 2885 if ('envelope_id' not in params) or (params['envelope_id'] is None): 2886 raise ValueError("Missing the required parameter `envelope_id` when calling `create_responsive_html_preview`") 2887 2888 2889 collection_formats = {} 2890 2891 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/responsive_html_preview'.replace('{format}', 'json') 2892 path_params = {} 2893 if 'account_id' in params: 2894 path_params['accountId'] = params['account_id'] 2895 if 'envelope_id' in params: 2896 path_params['envelopeId'] = params['envelope_id'] 2897 2898 query_params = {} 2899 2900 header_params = {} 2901 2902 form_params = [] 2903 local_var_files = {} 2904 2905 body_params = None 2906 if 'document_html_definition' in params: 2907 body_params = params['document_html_definition'] 2908 # HTTP header `Accept` 2909 header_params['Accept'] = self.api_client.\ 2910 select_header_accept(['application/json']) 2911 2912 # Authentication setting 2913 auth_settings = [] 2914 2915 return self.api_client.call_api(resource_path, 'POST', 2916 path_params, 2917 query_params, 2918 header_params, 2919 body=body_params, 2920 post_params=form_params, 2921 files=local_var_files, 2922 response_type='DocumentHtmlDefinitions', 2923 auth_settings=auth_settings, 2924 callback=params.get('callback'), 2925 _return_http_data_only=params.get('_return_http_data_only'), 2926 _preload_content=params.get('_preload_content', True), 2927 _request_timeout=params.get('_request_timeout'), 2928 collection_formats=collection_formats) 2929 2930 def create_sender_view(self, account_id, envelope_id, **kwargs): 2931 """ 2932 Returns a URL to the sender view UI. 2933 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. 2934 This method makes a synchronous HTTP request by default. To make an 2935 asynchronous HTTP request, please define a `callback` function 2936 to be invoked when receiving the response. 2937 >>> def callback_function(response): 2938 >>> pprint(response) 2939 >>> 2940 >>> thread = api.create_sender_view(account_id, envelope_id, callback=callback_function) 2941 2942 :param callback function: The callback function 2943 for asynchronous request. (optional) 2944 :param str account_id: The external account number (int) or account ID Guid. (required) 2945 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2946 :param ReturnUrlRequest return_url_request: 2947 :return: ViewUrl 2948 If the method is called asynchronously, 2949 returns the request thread. 2950 """ 2951 kwargs['_return_http_data_only'] = True 2952 if kwargs.get('callback'): 2953 return self.create_sender_view_with_http_info(account_id, envelope_id, **kwargs) 2954 else: 2955 (data) = self.create_sender_view_with_http_info(account_id, envelope_id, **kwargs) 2956 return data 2957 2958 def create_sender_view_with_http_info(self, account_id, envelope_id, **kwargs): 2959 """ 2960 Returns a URL to the sender view UI. 2961 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. 2962 This method makes a synchronous HTTP request by default. To make an 2963 asynchronous HTTP request, please define a `callback` function 2964 to be invoked when receiving the response. 2965 >>> def callback_function(response): 2966 >>> pprint(response) 2967 >>> 2968 >>> thread = api.create_sender_view_with_http_info(account_id, envelope_id, callback=callback_function) 2969 2970 :param callback function: The callback function 2971 for asynchronous request. (optional) 2972 :param str account_id: The external account number (int) or account ID Guid. (required) 2973 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2974 :param ReturnUrlRequest return_url_request: 2975 :return: ViewUrl 2976 If the method is called asynchronously, 2977 returns the request thread. 2978 """ 2979 2980 all_params = ['account_id', 'envelope_id', 'return_url_request'] 2981 all_params.append('callback') 2982 all_params.append('_return_http_data_only') 2983 all_params.append('_preload_content') 2984 all_params.append('_request_timeout') 2985 2986 params = locals() 2987 for key, val in iteritems(params['kwargs']): 2988 if key not in all_params: 2989 raise TypeError( 2990 "Got an unexpected keyword argument '%s'" 2991 " to method create_sender_view" % key 2992 ) 2993 params[key] = val 2994 del params['kwargs'] 2995 # verify the required parameter 'account_id' is set 2996 if ('account_id' not in params) or (params['account_id'] is None): 2997 raise ValueError("Missing the required parameter `account_id` when calling `create_sender_view`") 2998 # verify the required parameter 'envelope_id' is set 2999 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3000 raise ValueError("Missing the required parameter `envelope_id` when calling `create_sender_view`") 3001 3002 3003 collection_formats = {} 3004 3005 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/sender'.replace('{format}', 'json') 3006 path_params = {} 3007 if 'account_id' in params: 3008 path_params['accountId'] = params['account_id'] 3009 if 'envelope_id' in params: 3010 path_params['envelopeId'] = params['envelope_id'] 3011 3012 query_params = {} 3013 3014 header_params = {} 3015 3016 form_params = [] 3017 local_var_files = {} 3018 3019 body_params = None 3020 if 'return_url_request' in params: 3021 body_params = params['return_url_request'] 3022 # HTTP header `Accept` 3023 header_params['Accept'] = self.api_client.\ 3024 select_header_accept(['application/json']) 3025 3026 # Authentication setting 3027 auth_settings = [] 3028 3029 return self.api_client.call_api(resource_path, 'POST', 3030 path_params, 3031 query_params, 3032 header_params, 3033 body=body_params, 3034 post_params=form_params, 3035 files=local_var_files, 3036 response_type='ViewUrl', 3037 auth_settings=auth_settings, 3038 callback=params.get('callback'), 3039 _return_http_data_only=params.get('_return_http_data_only'), 3040 _preload_content=params.get('_preload_content', True), 3041 _request_timeout=params.get('_request_timeout'), 3042 collection_formats=collection_formats) 3043 3044 def create_tabs(self, account_id, envelope_id, recipient_id, **kwargs): 3045 """ 3046 Adds tabs for a recipient. 3047 Adds one or more tabs for a recipient. 3048 This method makes a synchronous HTTP request by default. To make an 3049 asynchronous HTTP request, please define a `callback` function 3050 to be invoked when receiving the response. 3051 >>> def callback_function(response): 3052 >>> pprint(response) 3053 >>> 3054 >>> thread = api.create_tabs(account_id, envelope_id, recipient_id, callback=callback_function) 3055 3056 :param callback function: The callback function 3057 for asynchronous request. (optional) 3058 :param str account_id: The external account number (int) or account ID Guid. (required) 3059 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3060 :param str recipient_id: The ID of the recipient being accessed. (required) 3061 :param Tabs tabs: 3062 :return: Tabs 3063 If the method is called asynchronously, 3064 returns the request thread. 3065 """ 3066 kwargs['_return_http_data_only'] = True 3067 if kwargs.get('callback'): 3068 return self.create_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 3069 else: 3070 (data) = self.create_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 3071 return data 3072 3073 def create_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 3074 """ 3075 Adds tabs for a recipient. 3076 Adds one or more tabs for a recipient. 3077 This method makes a synchronous HTTP request by default. To make an 3078 asynchronous HTTP request, please define a `callback` function 3079 to be invoked when receiving the response. 3080 >>> def callback_function(response): 3081 >>> pprint(response) 3082 >>> 3083 >>> thread = api.create_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 3084 3085 :param callback function: The callback function 3086 for asynchronous request. (optional) 3087 :param str account_id: The external account number (int) or account ID Guid. (required) 3088 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3089 :param str recipient_id: The ID of the recipient being accessed. (required) 3090 :param Tabs tabs: 3091 :return: Tabs 3092 If the method is called asynchronously, 3093 returns the request thread. 3094 """ 3095 3096 all_params = ['account_id', 'envelope_id', 'recipient_id', 'tabs'] 3097 all_params.append('callback') 3098 all_params.append('_return_http_data_only') 3099 all_params.append('_preload_content') 3100 all_params.append('_request_timeout') 3101 3102 params = locals() 3103 for key, val in iteritems(params['kwargs']): 3104 if key not in all_params: 3105 raise TypeError( 3106 "Got an unexpected keyword argument '%s'" 3107 " to method create_tabs" % key 3108 ) 3109 params[key] = val 3110 del params['kwargs'] 3111 # verify the required parameter 'account_id' is set 3112 if ('account_id' not in params) or (params['account_id'] is None): 3113 raise ValueError("Missing the required parameter `account_id` when calling `create_tabs`") 3114 # verify the required parameter 'envelope_id' is set 3115 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3116 raise ValueError("Missing the required parameter `envelope_id` when calling `create_tabs`") 3117 # verify the required parameter 'recipient_id' is set 3118 if ('recipient_id' not in params) or (params['recipient_id'] is None): 3119 raise ValueError("Missing the required parameter `recipient_id` when calling `create_tabs`") 3120 3121 3122 collection_formats = {} 3123 3124 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/tabs'.replace('{format}', 'json') 3125 path_params = {} 3126 if 'account_id' in params: 3127 path_params['accountId'] = params['account_id'] 3128 if 'envelope_id' in params: 3129 path_params['envelopeId'] = params['envelope_id'] 3130 if 'recipient_id' in params: 3131 path_params['recipientId'] = params['recipient_id'] 3132 3133 query_params = {} 3134 3135 header_params = {} 3136 3137 form_params = [] 3138 local_var_files = {} 3139 3140 body_params = None 3141 if 'tabs' in params: 3142 body_params = params['tabs'] 3143 # HTTP header `Accept` 3144 header_params['Accept'] = self.api_client.\ 3145 select_header_accept(['application/json']) 3146 3147 # Authentication setting 3148 auth_settings = [] 3149 3150 return self.api_client.call_api(resource_path, 'POST', 3151 path_params, 3152 query_params, 3153 header_params, 3154 body=body_params, 3155 post_params=form_params, 3156 files=local_var_files, 3157 response_type='Tabs', 3158 auth_settings=auth_settings, 3159 callback=params.get('callback'), 3160 _return_http_data_only=params.get('_return_http_data_only'), 3161 _preload_content=params.get('_preload_content', True), 3162 _request_timeout=params.get('_request_timeout'), 3163 collection_formats=collection_formats) 3164 3165 def create_template_workflow_step_definition(self, account_id, template_id, **kwargs): 3166 """ 3167 Creates and adds a new workflow step definition for a template's workflow 3168 This method makes a synchronous HTTP request by default. To make an 3169 asynchronous HTTP request, please define a `callback` function 3170 to be invoked when receiving the response. 3171 >>> def callback_function(response): 3172 >>> pprint(response) 3173 >>> 3174 >>> thread = api.create_template_workflow_step_definition(account_id, template_id, callback=callback_function) 3175 3176 :param callback function: The callback function 3177 for asynchronous request. (optional) 3178 :param str account_id: The external account number (int) or account ID Guid. (required) 3179 :param str template_id: The ID of the template being accessed. (required) 3180 :param WorkflowStep workflow_step: 3181 :return: WorkflowStep 3182 If the method is called asynchronously, 3183 returns the request thread. 3184 """ 3185 kwargs['_return_http_data_only'] = True 3186 if kwargs.get('callback'): 3187 return self.create_template_workflow_step_definition_with_http_info(account_id, template_id, **kwargs) 3188 else: 3189 (data) = self.create_template_workflow_step_definition_with_http_info(account_id, template_id, **kwargs) 3190 return data 3191 3192 def create_template_workflow_step_definition_with_http_info(self, account_id, template_id, **kwargs): 3193 """ 3194 Creates and adds a new workflow step definition for a template's workflow 3195 This method makes a synchronous HTTP request by default. To make an 3196 asynchronous HTTP request, please define a `callback` function 3197 to be invoked when receiving the response. 3198 >>> def callback_function(response): 3199 >>> pprint(response) 3200 >>> 3201 >>> thread = api.create_template_workflow_step_definition_with_http_info(account_id, template_id, callback=callback_function) 3202 3203 :param callback function: The callback function 3204 for asynchronous request. (optional) 3205 :param str account_id: The external account number (int) or account ID Guid. (required) 3206 :param str template_id: The ID of the template being accessed. (required) 3207 :param WorkflowStep workflow_step: 3208 :return: WorkflowStep 3209 If the method is called asynchronously, 3210 returns the request thread. 3211 """ 3212 3213 all_params = ['account_id', 'template_id', 'workflow_step'] 3214 all_params.append('callback') 3215 all_params.append('_return_http_data_only') 3216 all_params.append('_preload_content') 3217 all_params.append('_request_timeout') 3218 3219 params = locals() 3220 for key, val in iteritems(params['kwargs']): 3221 if key not in all_params: 3222 raise TypeError( 3223 "Got an unexpected keyword argument '%s'" 3224 " to method create_template_workflow_step_definition" % key 3225 ) 3226 params[key] = val 3227 del params['kwargs'] 3228 # verify the required parameter 'account_id' is set 3229 if ('account_id' not in params) or (params['account_id'] is None): 3230 raise ValueError("Missing the required parameter `account_id` when calling `create_template_workflow_step_definition`") 3231 # verify the required parameter 'template_id' is set 3232 if ('template_id' not in params) or (params['template_id'] is None): 3233 raise ValueError("Missing the required parameter `template_id` when calling `create_template_workflow_step_definition`") 3234 3235 3236 collection_formats = {} 3237 3238 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps'.replace('{format}', 'json') 3239 path_params = {} 3240 if 'account_id' in params: 3241 path_params['accountId'] = params['account_id'] 3242 if 'template_id' in params: 3243 path_params['templateId'] = params['template_id'] 3244 3245 query_params = {} 3246 3247 header_params = {} 3248 3249 form_params = [] 3250 local_var_files = {} 3251 3252 body_params = None 3253 if 'workflow_step' in params: 3254 body_params = params['workflow_step'] 3255 # HTTP header `Accept` 3256 header_params['Accept'] = self.api_client.\ 3257 select_header_accept(['application/json']) 3258 3259 # Authentication setting 3260 auth_settings = [] 3261 3262 return self.api_client.call_api(resource_path, 'POST', 3263 path_params, 3264 query_params, 3265 header_params, 3266 body=body_params, 3267 post_params=form_params, 3268 files=local_var_files, 3269 response_type='WorkflowStep', 3270 auth_settings=auth_settings, 3271 callback=params.get('callback'), 3272 _return_http_data_only=params.get('_return_http_data_only'), 3273 _preload_content=params.get('_preload_content', True), 3274 _request_timeout=params.get('_request_timeout'), 3275 collection_formats=collection_formats) 3276 3277 def delete_attachments(self, account_id, envelope_id, **kwargs): 3278 """ 3279 Delete one or more attachments from a DRAFT envelope. 3280 Deletes one or more attachments from a draft envelope. 3281 This method makes a synchronous HTTP request by default. To make an 3282 asynchronous HTTP request, please define a `callback` function 3283 to be invoked when receiving the response. 3284 >>> def callback_function(response): 3285 >>> pprint(response) 3286 >>> 3287 >>> thread = api.delete_attachments(account_id, envelope_id, callback=callback_function) 3288 3289 :param callback function: The callback function 3290 for asynchronous request. (optional) 3291 :param str account_id: The external account number (int) or account ID Guid. (required) 3292 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3293 :param EnvelopeAttachmentsRequest envelope_attachments_request: 3294 :return: EnvelopeAttachmentsResult 3295 If the method is called asynchronously, 3296 returns the request thread. 3297 """ 3298 kwargs['_return_http_data_only'] = True 3299 if kwargs.get('callback'): 3300 return self.delete_attachments_with_http_info(account_id, envelope_id, **kwargs) 3301 else: 3302 (data) = self.delete_attachments_with_http_info(account_id, envelope_id, **kwargs) 3303 return data 3304 3305 def delete_attachments_with_http_info(self, account_id, envelope_id, **kwargs): 3306 """ 3307 Delete one or more attachments from a DRAFT envelope. 3308 Deletes one or more attachments from a draft envelope. 3309 This method makes a synchronous HTTP request by default. To make an 3310 asynchronous HTTP request, please define a `callback` function 3311 to be invoked when receiving the response. 3312 >>> def callback_function(response): 3313 >>> pprint(response) 3314 >>> 3315 >>> thread = api.delete_attachments_with_http_info(account_id, envelope_id, callback=callback_function) 3316 3317 :param callback function: The callback function 3318 for asynchronous request. (optional) 3319 :param str account_id: The external account number (int) or account ID Guid. (required) 3320 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3321 :param EnvelopeAttachmentsRequest envelope_attachments_request: 3322 :return: EnvelopeAttachmentsResult 3323 If the method is called asynchronously, 3324 returns the request thread. 3325 """ 3326 3327 all_params = ['account_id', 'envelope_id', 'envelope_attachments_request'] 3328 all_params.append('callback') 3329 all_params.append('_return_http_data_only') 3330 all_params.append('_preload_content') 3331 all_params.append('_request_timeout') 3332 3333 params = locals() 3334 for key, val in iteritems(params['kwargs']): 3335 if key not in all_params: 3336 raise TypeError( 3337 "Got an unexpected keyword argument '%s'" 3338 " to method delete_attachments" % key 3339 ) 3340 params[key] = val 3341 del params['kwargs'] 3342 # verify the required parameter 'account_id' is set 3343 if ('account_id' not in params) or (params['account_id'] is None): 3344 raise ValueError("Missing the required parameter `account_id` when calling `delete_attachments`") 3345 # verify the required parameter 'envelope_id' is set 3346 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3347 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_attachments`") 3348 3349 3350 collection_formats = {} 3351 3352 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments'.replace('{format}', 'json') 3353 path_params = {} 3354 if 'account_id' in params: 3355 path_params['accountId'] = params['account_id'] 3356 if 'envelope_id' in params: 3357 path_params['envelopeId'] = params['envelope_id'] 3358 3359 query_params = {} 3360 3361 header_params = {} 3362 3363 form_params = [] 3364 local_var_files = {} 3365 3366 body_params = None 3367 if 'envelope_attachments_request' in params: 3368 body_params = params['envelope_attachments_request'] 3369 # HTTP header `Accept` 3370 header_params['Accept'] = self.api_client.\ 3371 select_header_accept(['application/json']) 3372 3373 # Authentication setting 3374 auth_settings = [] 3375 3376 return self.api_client.call_api(resource_path, 'DELETE', 3377 path_params, 3378 query_params, 3379 header_params, 3380 body=body_params, 3381 post_params=form_params, 3382 files=local_var_files, 3383 response_type='EnvelopeAttachmentsResult', 3384 auth_settings=auth_settings, 3385 callback=params.get('callback'), 3386 _return_http_data_only=params.get('_return_http_data_only'), 3387 _preload_content=params.get('_preload_content', True), 3388 _request_timeout=params.get('_request_timeout'), 3389 collection_formats=collection_formats) 3390 3391 def delete_chunked_upload(self, account_id, chunked_upload_id, **kwargs): 3392 """ 3393 Delete an existing ChunkedUpload. 3394 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. 3395 This method makes a synchronous HTTP request by default. To make an 3396 asynchronous HTTP request, please define a `callback` function 3397 to be invoked when receiving the response. 3398 >>> def callback_function(response): 3399 >>> pprint(response) 3400 >>> 3401 >>> thread = api.delete_chunked_upload(account_id, chunked_upload_id, callback=callback_function) 3402 3403 :param callback function: The callback function 3404 for asynchronous request. (optional) 3405 :param str account_id: The external account number (int) or account ID Guid. (required) 3406 :param str chunked_upload_id: (required) 3407 :return: ChunkedUploadResponse 3408 If the method is called asynchronously, 3409 returns the request thread. 3410 """ 3411 kwargs['_return_http_data_only'] = True 3412 if kwargs.get('callback'): 3413 return self.delete_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 3414 else: 3415 (data) = self.delete_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 3416 return data 3417 3418 def delete_chunked_upload_with_http_info(self, account_id, chunked_upload_id, **kwargs): 3419 """ 3420 Delete an existing ChunkedUpload. 3421 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. 3422 This method makes a synchronous HTTP request by default. To make an 3423 asynchronous HTTP request, please define a `callback` function 3424 to be invoked when receiving the response. 3425 >>> def callback_function(response): 3426 >>> pprint(response) 3427 >>> 3428 >>> thread = api.delete_chunked_upload_with_http_info(account_id, chunked_upload_id, callback=callback_function) 3429 3430 :param callback function: The callback function 3431 for asynchronous request. (optional) 3432 :param str account_id: The external account number (int) or account ID Guid. (required) 3433 :param str chunked_upload_id: (required) 3434 :return: ChunkedUploadResponse 3435 If the method is called asynchronously, 3436 returns the request thread. 3437 """ 3438 3439 all_params = ['account_id', 'chunked_upload_id'] 3440 all_params.append('callback') 3441 all_params.append('_return_http_data_only') 3442 all_params.append('_preload_content') 3443 all_params.append('_request_timeout') 3444 3445 params = locals() 3446 for key, val in iteritems(params['kwargs']): 3447 if key not in all_params: 3448 raise TypeError( 3449 "Got an unexpected keyword argument '%s'" 3450 " to method delete_chunked_upload" % key 3451 ) 3452 params[key] = val 3453 del params['kwargs'] 3454 # verify the required parameter 'account_id' is set 3455 if ('account_id' not in params) or (params['account_id'] is None): 3456 raise ValueError("Missing the required parameter `account_id` when calling `delete_chunked_upload`") 3457 # verify the required parameter 'chunked_upload_id' is set 3458 if ('chunked_upload_id' not in params) or (params['chunked_upload_id'] is None): 3459 raise ValueError("Missing the required parameter `chunked_upload_id` when calling `delete_chunked_upload`") 3460 3461 3462 collection_formats = {} 3463 3464 resource_path = '/v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}'.replace('{format}', 'json') 3465 path_params = {} 3466 if 'account_id' in params: 3467 path_params['accountId'] = params['account_id'] 3468 if 'chunked_upload_id' in params: 3469 path_params['chunkedUploadId'] = params['chunked_upload_id'] 3470 3471 query_params = {} 3472 3473 header_params = {} 3474 3475 form_params = [] 3476 local_var_files = {} 3477 3478 body_params = None 3479 # HTTP header `Accept` 3480 header_params['Accept'] = self.api_client.\ 3481 select_header_accept(['application/json']) 3482 3483 # Authentication setting 3484 auth_settings = [] 3485 3486 return self.api_client.call_api(resource_path, 'DELETE', 3487 path_params, 3488 query_params, 3489 header_params, 3490 body=body_params, 3491 post_params=form_params, 3492 files=local_var_files, 3493 response_type='ChunkedUploadResponse', 3494 auth_settings=auth_settings, 3495 callback=params.get('callback'), 3496 _return_http_data_only=params.get('_return_http_data_only'), 3497 _preload_content=params.get('_preload_content', True), 3498 _request_timeout=params.get('_request_timeout'), 3499 collection_formats=collection_formats) 3500 3501 def delete_custom_fields(self, account_id, envelope_id, **kwargs): 3502 """ 3503 Deletes envelope custom fields for draft and in-process envelopes. 3504 Deletes envelope custom fields for draft and in-process envelopes. 3505 This method makes a synchronous HTTP request by default. To make an 3506 asynchronous HTTP request, please define a `callback` function 3507 to be invoked when receiving the response. 3508 >>> def callback_function(response): 3509 >>> pprint(response) 3510 >>> 3511 >>> thread = api.delete_custom_fields(account_id, envelope_id, callback=callback_function) 3512 3513 :param callback function: The callback function 3514 for asynchronous request. (optional) 3515 :param str account_id: The external account number (int) or account ID Guid. (required) 3516 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3517 :param CustomFields custom_fields: 3518 :return: CustomFields 3519 If the method is called asynchronously, 3520 returns the request thread. 3521 """ 3522 kwargs['_return_http_data_only'] = True 3523 if kwargs.get('callback'): 3524 return self.delete_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 3525 else: 3526 (data) = self.delete_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 3527 return data 3528 3529 def delete_custom_fields_with_http_info(self, account_id, envelope_id, **kwargs): 3530 """ 3531 Deletes envelope custom fields for draft and in-process envelopes. 3532 Deletes envelope custom fields for draft and in-process envelopes. 3533 This method makes a synchronous HTTP request by default. To make an 3534 asynchronous HTTP request, please define a `callback` function 3535 to be invoked when receiving the response. 3536 >>> def callback_function(response): 3537 >>> pprint(response) 3538 >>> 3539 >>> thread = api.delete_custom_fields_with_http_info(account_id, envelope_id, callback=callback_function) 3540 3541 :param callback function: The callback function 3542 for asynchronous request. (optional) 3543 :param str account_id: The external account number (int) or account ID Guid. (required) 3544 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3545 :param CustomFields custom_fields: 3546 :return: CustomFields 3547 If the method is called asynchronously, 3548 returns the request thread. 3549 """ 3550 3551 all_params = ['account_id', 'envelope_id', 'custom_fields'] 3552 all_params.append('callback') 3553 all_params.append('_return_http_data_only') 3554 all_params.append('_preload_content') 3555 all_params.append('_request_timeout') 3556 3557 params = locals() 3558 for key, val in iteritems(params['kwargs']): 3559 if key not in all_params: 3560 raise TypeError( 3561 "Got an unexpected keyword argument '%s'" 3562 " to method delete_custom_fields" % key 3563 ) 3564 params[key] = val 3565 del params['kwargs'] 3566 # verify the required parameter 'account_id' is set 3567 if ('account_id' not in params) or (params['account_id'] is None): 3568 raise ValueError("Missing the required parameter `account_id` when calling `delete_custom_fields`") 3569 # verify the required parameter 'envelope_id' is set 3570 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3571 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_custom_fields`") 3572 3573 3574 collection_formats = {} 3575 3576 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/custom_fields'.replace('{format}', 'json') 3577 path_params = {} 3578 if 'account_id' in params: 3579 path_params['accountId'] = params['account_id'] 3580 if 'envelope_id' in params: 3581 path_params['envelopeId'] = params['envelope_id'] 3582 3583 query_params = {} 3584 3585 header_params = {} 3586 3587 form_params = [] 3588 local_var_files = {} 3589 3590 body_params = None 3591 if 'custom_fields' in params: 3592 body_params = params['custom_fields'] 3593 # HTTP header `Accept` 3594 header_params['Accept'] = self.api_client.\ 3595 select_header_accept(['application/json']) 3596 3597 # Authentication setting 3598 auth_settings = [] 3599 3600 return self.api_client.call_api(resource_path, 'DELETE', 3601 path_params, 3602 query_params, 3603 header_params, 3604 body=body_params, 3605 post_params=form_params, 3606 files=local_var_files, 3607 response_type='CustomFields', 3608 auth_settings=auth_settings, 3609 callback=params.get('callback'), 3610 _return_http_data_only=params.get('_return_http_data_only'), 3611 _preload_content=params.get('_preload_content', True), 3612 _request_timeout=params.get('_request_timeout'), 3613 collection_formats=collection_formats) 3614 3615 def delete_document_fields(self, account_id, document_id, envelope_id, **kwargs): 3616 """ 3617 Deletes custom document fields from an existing envelope document. 3618 Deletes custom document fields from an existing envelope document. 3619 This method makes a synchronous HTTP request by default. To make an 3620 asynchronous HTTP request, please define a `callback` function 3621 to be invoked when receiving the response. 3622 >>> def callback_function(response): 3623 >>> pprint(response) 3624 >>> 3625 >>> thread = api.delete_document_fields(account_id, document_id, envelope_id, callback=callback_function) 3626 3627 :param callback function: The callback function 3628 for asynchronous request. (optional) 3629 :param str account_id: The external account number (int) or account ID Guid. (required) 3630 :param str document_id: The ID of the document being accessed. (required) 3631 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3632 :param DocumentFieldsInformation document_fields_information: 3633 :return: DocumentFieldsInformation 3634 If the method is called asynchronously, 3635 returns the request thread. 3636 """ 3637 kwargs['_return_http_data_only'] = True 3638 if kwargs.get('callback'): 3639 return self.delete_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 3640 else: 3641 (data) = self.delete_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 3642 return data 3643 3644 def delete_document_fields_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 3645 """ 3646 Deletes custom document fields from an existing envelope document. 3647 Deletes custom document fields from an existing envelope document. 3648 This method makes a synchronous HTTP request by default. To make an 3649 asynchronous HTTP request, please define a `callback` function 3650 to be invoked when receiving the response. 3651 >>> def callback_function(response): 3652 >>> pprint(response) 3653 >>> 3654 >>> thread = api.delete_document_fields_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 3655 3656 :param callback function: The callback function 3657 for asynchronous request. (optional) 3658 :param str account_id: The external account number (int) or account ID Guid. (required) 3659 :param str document_id: The ID of the document being accessed. (required) 3660 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3661 :param DocumentFieldsInformation document_fields_information: 3662 :return: DocumentFieldsInformation 3663 If the method is called asynchronously, 3664 returns the request thread. 3665 """ 3666 3667 all_params = ['account_id', 'document_id', 'envelope_id', 'document_fields_information'] 3668 all_params.append('callback') 3669 all_params.append('_return_http_data_only') 3670 all_params.append('_preload_content') 3671 all_params.append('_request_timeout') 3672 3673 params = locals() 3674 for key, val in iteritems(params['kwargs']): 3675 if key not in all_params: 3676 raise TypeError( 3677 "Got an unexpected keyword argument '%s'" 3678 " to method delete_document_fields" % key 3679 ) 3680 params[key] = val 3681 del params['kwargs'] 3682 # verify the required parameter 'account_id' is set 3683 if ('account_id' not in params) or (params['account_id'] is None): 3684 raise ValueError("Missing the required parameter `account_id` when calling `delete_document_fields`") 3685 # verify the required parameter 'document_id' is set 3686 if ('document_id' not in params) or (params['document_id'] is None): 3687 raise ValueError("Missing the required parameter `document_id` when calling `delete_document_fields`") 3688 # verify the required parameter 'envelope_id' is set 3689 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3690 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_document_fields`") 3691 3692 3693 collection_formats = {} 3694 3695 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/fields'.replace('{format}', 'json') 3696 path_params = {} 3697 if 'account_id' in params: 3698 path_params['accountId'] = params['account_id'] 3699 if 'document_id' in params: 3700 path_params['documentId'] = params['document_id'] 3701 if 'envelope_id' in params: 3702 path_params['envelopeId'] = params['envelope_id'] 3703 3704 query_params = {} 3705 3706 header_params = {} 3707 3708 form_params = [] 3709 local_var_files = {} 3710 3711 body_params = None 3712 if 'document_fields_information' in params: 3713 body_params = params['document_fields_information'] 3714 # HTTP header `Accept` 3715 header_params['Accept'] = self.api_client.\ 3716 select_header_accept(['application/json']) 3717 3718 # Authentication setting 3719 auth_settings = [] 3720 3721 return self.api_client.call_api(resource_path, 'DELETE', 3722 path_params, 3723 query_params, 3724 header_params, 3725 body=body_params, 3726 post_params=form_params, 3727 files=local_var_files, 3728 response_type='DocumentFieldsInformation', 3729 auth_settings=auth_settings, 3730 callback=params.get('callback'), 3731 _return_http_data_only=params.get('_return_http_data_only'), 3732 _preload_content=params.get('_preload_content', True), 3733 _request_timeout=params.get('_request_timeout'), 3734 collection_formats=collection_formats) 3735 3736 def delete_document_page(self, account_id, document_id, envelope_id, page_number, **kwargs): 3737 """ 3738 Deletes a page from a document in an envelope. 3739 Deletes a page from a document in an envelope based on the page number. 3740 This method makes a synchronous HTTP request by default. To make an 3741 asynchronous HTTP request, please define a `callback` function 3742 to be invoked when receiving the response. 3743 >>> def callback_function(response): 3744 >>> pprint(response) 3745 >>> 3746 >>> thread = api.delete_document_page(account_id, document_id, envelope_id, page_number, callback=callback_function) 3747 3748 :param callback function: The callback function 3749 for asynchronous request. (optional) 3750 :param str account_id: The external account number (int) or account ID Guid. (required) 3751 :param str document_id: The ID of the document being accessed. (required) 3752 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3753 :param str page_number: The page number being accessed. (required) 3754 :return: None 3755 If the method is called asynchronously, 3756 returns the request thread. 3757 """ 3758 kwargs['_return_http_data_only'] = True 3759 if kwargs.get('callback'): 3760 return self.delete_document_page_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 3761 else: 3762 (data) = self.delete_document_page_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 3763 return data 3764 3765 def delete_document_page_with_http_info(self, account_id, document_id, envelope_id, page_number, **kwargs): 3766 """ 3767 Deletes a page from a document in an envelope. 3768 Deletes a page from a document in an envelope based on the page number. 3769 This method makes a synchronous HTTP request by default. To make an 3770 asynchronous HTTP request, please define a `callback` function 3771 to be invoked when receiving the response. 3772 >>> def callback_function(response): 3773 >>> pprint(response) 3774 >>> 3775 >>> thread = api.delete_document_page_with_http_info(account_id, document_id, envelope_id, page_number, callback=callback_function) 3776 3777 :param callback function: The callback function 3778 for asynchronous request. (optional) 3779 :param str account_id: The external account number (int) or account ID Guid. (required) 3780 :param str document_id: The ID of the document being accessed. (required) 3781 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3782 :param str page_number: The page number being accessed. (required) 3783 :return: None 3784 If the method is called asynchronously, 3785 returns the request thread. 3786 """ 3787 3788 all_params = ['account_id', 'document_id', 'envelope_id', 'page_number'] 3789 all_params.append('callback') 3790 all_params.append('_return_http_data_only') 3791 all_params.append('_preload_content') 3792 all_params.append('_request_timeout') 3793 3794 params = locals() 3795 for key, val in iteritems(params['kwargs']): 3796 if key not in all_params: 3797 raise TypeError( 3798 "Got an unexpected keyword argument '%s'" 3799 " to method delete_document_page" % key 3800 ) 3801 params[key] = val 3802 del params['kwargs'] 3803 # verify the required parameter 'account_id' is set 3804 if ('account_id' not in params) or (params['account_id'] is None): 3805 raise ValueError("Missing the required parameter `account_id` when calling `delete_document_page`") 3806 # verify the required parameter 'document_id' is set 3807 if ('document_id' not in params) or (params['document_id'] is None): 3808 raise ValueError("Missing the required parameter `document_id` when calling `delete_document_page`") 3809 # verify the required parameter 'envelope_id' is set 3810 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3811 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_document_page`") 3812 # verify the required parameter 'page_number' is set 3813 if ('page_number' not in params) or (params['page_number'] is None): 3814 raise ValueError("Missing the required parameter `page_number` when calling `delete_document_page`") 3815 3816 3817 collection_formats = {} 3818 3819 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/pages/{pageNumber}'.replace('{format}', 'json') 3820 path_params = {} 3821 if 'account_id' in params: 3822 path_params['accountId'] = params['account_id'] 3823 if 'document_id' in params: 3824 path_params['documentId'] = params['document_id'] 3825 if 'envelope_id' in params: 3826 path_params['envelopeId'] = params['envelope_id'] 3827 if 'page_number' in params: 3828 path_params['pageNumber'] = params['page_number'] 3829 3830 query_params = {} 3831 3832 header_params = {} 3833 3834 form_params = [] 3835 local_var_files = {} 3836 3837 body_params = None 3838 # HTTP header `Accept` 3839 header_params['Accept'] = self.api_client.\ 3840 select_header_accept(['application/json']) 3841 3842 # Authentication setting 3843 auth_settings = [] 3844 3845 return self.api_client.call_api(resource_path, 'DELETE', 3846 path_params, 3847 query_params, 3848 header_params, 3849 body=body_params, 3850 post_params=form_params, 3851 files=local_var_files, 3852 response_type=None, 3853 auth_settings=auth_settings, 3854 callback=params.get('callback'), 3855 _return_http_data_only=params.get('_return_http_data_only'), 3856 _preload_content=params.get('_preload_content', True), 3857 _request_timeout=params.get('_request_timeout'), 3858 collection_formats=collection_formats) 3859 3860 def delete_document_tabs(self, account_id, document_id, envelope_id, **kwargs): 3861 """ 3862 Deletes tabs from an envelope document 3863 Deletes tabs from the document specified by `documentId` in the envelope specified by `envelopeId`. 3864 This method makes a synchronous HTTP request by default. To make an 3865 asynchronous HTTP request, please define a `callback` function 3866 to be invoked when receiving the response. 3867 >>> def callback_function(response): 3868 >>> pprint(response) 3869 >>> 3870 >>> thread = api.delete_document_tabs(account_id, document_id, envelope_id, callback=callback_function) 3871 3872 :param callback function: The callback function 3873 for asynchronous request. (optional) 3874 :param str account_id: The external account number (int) or account ID Guid. (required) 3875 :param str document_id: The ID of the document being accessed. (required) 3876 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3877 :param Tabs tabs: 3878 :return: Tabs 3879 If the method is called asynchronously, 3880 returns the request thread. 3881 """ 3882 kwargs['_return_http_data_only'] = True 3883 if kwargs.get('callback'): 3884 return self.delete_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 3885 else: 3886 (data) = self.delete_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 3887 return data 3888 3889 def delete_document_tabs_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 3890 """ 3891 Deletes tabs from an envelope document 3892 Deletes tabs from the document specified by `documentId` in the envelope specified by `envelopeId`. 3893 This method makes a synchronous HTTP request by default. To make an 3894 asynchronous HTTP request, please define a `callback` function 3895 to be invoked when receiving the response. 3896 >>> def callback_function(response): 3897 >>> pprint(response) 3898 >>> 3899 >>> thread = api.delete_document_tabs_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 3900 3901 :param callback function: The callback function 3902 for asynchronous request. (optional) 3903 :param str account_id: The external account number (int) or account ID Guid. (required) 3904 :param str document_id: The ID of the document being accessed. (required) 3905 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3906 :param Tabs tabs: 3907 :return: Tabs 3908 If the method is called asynchronously, 3909 returns the request thread. 3910 """ 3911 3912 all_params = ['account_id', 'document_id', 'envelope_id', 'tabs'] 3913 all_params.append('callback') 3914 all_params.append('_return_http_data_only') 3915 all_params.append('_preload_content') 3916 all_params.append('_request_timeout') 3917 3918 params = locals() 3919 for key, val in iteritems(params['kwargs']): 3920 if key not in all_params: 3921 raise TypeError( 3922 "Got an unexpected keyword argument '%s'" 3923 " to method delete_document_tabs" % key 3924 ) 3925 params[key] = val 3926 del params['kwargs'] 3927 # verify the required parameter 'account_id' is set 3928 if ('account_id' not in params) or (params['account_id'] is None): 3929 raise ValueError("Missing the required parameter `account_id` when calling `delete_document_tabs`") 3930 # verify the required parameter 'document_id' is set 3931 if ('document_id' not in params) or (params['document_id'] is None): 3932 raise ValueError("Missing the required parameter `document_id` when calling `delete_document_tabs`") 3933 # verify the required parameter 'envelope_id' is set 3934 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3935 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_document_tabs`") 3936 3937 3938 collection_formats = {} 3939 3940 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/tabs'.replace('{format}', 'json') 3941 path_params = {} 3942 if 'account_id' in params: 3943 path_params['accountId'] = params['account_id'] 3944 if 'document_id' in params: 3945 path_params['documentId'] = params['document_id'] 3946 if 'envelope_id' in params: 3947 path_params['envelopeId'] = params['envelope_id'] 3948 3949 query_params = {} 3950 3951 header_params = {} 3952 3953 form_params = [] 3954 local_var_files = {} 3955 3956 body_params = None 3957 if 'tabs' in params: 3958 body_params = params['tabs'] 3959 # HTTP header `Accept` 3960 header_params['Accept'] = self.api_client.\ 3961 select_header_accept(['application/json']) 3962 3963 # Authentication setting 3964 auth_settings = [] 3965 3966 return self.api_client.call_api(resource_path, 'DELETE', 3967 path_params, 3968 query_params, 3969 header_params, 3970 body=body_params, 3971 post_params=form_params, 3972 files=local_var_files, 3973 response_type='Tabs', 3974 auth_settings=auth_settings, 3975 callback=params.get('callback'), 3976 _return_http_data_only=params.get('_return_http_data_only'), 3977 _preload_content=params.get('_preload_content', True), 3978 _request_timeout=params.get('_request_timeout'), 3979 collection_formats=collection_formats) 3980 3981 def delete_documents(self, account_id, envelope_id, **kwargs): 3982 """ 3983 Deletes documents from a draft envelope. 3984 Deletes one or more documents from an existing draft envelope. 3985 This method makes a synchronous HTTP request by default. To make an 3986 asynchronous HTTP request, please define a `callback` function 3987 to be invoked when receiving the response. 3988 >>> def callback_function(response): 3989 >>> pprint(response) 3990 >>> 3991 >>> thread = api.delete_documents(account_id, envelope_id, callback=callback_function) 3992 3993 :param callback function: The callback function 3994 for asynchronous request. (optional) 3995 :param str account_id: The external account number (int) or account ID Guid. (required) 3996 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3997 :param EnvelopeDefinition envelope_definition: 3998 :return: EnvelopeDocumentsResult 3999 If the method is called asynchronously, 4000 returns the request thread. 4001 """ 4002 kwargs['_return_http_data_only'] = True 4003 if kwargs.get('callback'): 4004 return self.delete_documents_with_http_info(account_id, envelope_id, **kwargs) 4005 else: 4006 (data) = self.delete_documents_with_http_info(account_id, envelope_id, **kwargs) 4007 return data 4008 4009 def delete_documents_with_http_info(self, account_id, envelope_id, **kwargs): 4010 """ 4011 Deletes documents from a draft envelope. 4012 Deletes one or more documents from an existing draft envelope. 4013 This method makes a synchronous HTTP request by default. To make an 4014 asynchronous HTTP request, please define a `callback` function 4015 to be invoked when receiving the response. 4016 >>> def callback_function(response): 4017 >>> pprint(response) 4018 >>> 4019 >>> thread = api.delete_documents_with_http_info(account_id, envelope_id, callback=callback_function) 4020 4021 :param callback function: The callback function 4022 for asynchronous request. (optional) 4023 :param str account_id: The external account number (int) or account ID Guid. (required) 4024 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4025 :param EnvelopeDefinition envelope_definition: 4026 :return: EnvelopeDocumentsResult 4027 If the method is called asynchronously, 4028 returns the request thread. 4029 """ 4030 4031 all_params = ['account_id', 'envelope_id', 'envelope_definition'] 4032 all_params.append('callback') 4033 all_params.append('_return_http_data_only') 4034 all_params.append('_preload_content') 4035 all_params.append('_request_timeout') 4036 4037 params = locals() 4038 for key, val in iteritems(params['kwargs']): 4039 if key not in all_params: 4040 raise TypeError( 4041 "Got an unexpected keyword argument '%s'" 4042 " to method delete_documents" % key 4043 ) 4044 params[key] = val 4045 del params['kwargs'] 4046 # verify the required parameter 'account_id' is set 4047 if ('account_id' not in params) or (params['account_id'] is None): 4048 raise ValueError("Missing the required parameter `account_id` when calling `delete_documents`") 4049 # verify the required parameter 'envelope_id' is set 4050 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4051 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_documents`") 4052 4053 4054 collection_formats = {} 4055 4056 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents'.replace('{format}', 'json') 4057 path_params = {} 4058 if 'account_id' in params: 4059 path_params['accountId'] = params['account_id'] 4060 if 'envelope_id' in params: 4061 path_params['envelopeId'] = params['envelope_id'] 4062 4063 query_params = {} 4064 4065 header_params = {} 4066 4067 form_params = [] 4068 local_var_files = {} 4069 4070 body_params = None 4071 if 'envelope_definition' in params: 4072 body_params = params['envelope_definition'] 4073 # HTTP header `Accept` 4074 header_params['Accept'] = self.api_client.\ 4075 select_header_accept(['application/json']) 4076 4077 # Authentication setting 4078 auth_settings = [] 4079 4080 return self.api_client.call_api(resource_path, 'DELETE', 4081 path_params, 4082 query_params, 4083 header_params, 4084 body=body_params, 4085 post_params=form_params, 4086 files=local_var_files, 4087 response_type='EnvelopeDocumentsResult', 4088 auth_settings=auth_settings, 4089 callback=params.get('callback'), 4090 _return_http_data_only=params.get('_return_http_data_only'), 4091 _preload_content=params.get('_preload_content', True), 4092 _request_timeout=params.get('_request_timeout'), 4093 collection_formats=collection_formats) 4094 4095 def delete_email_settings(self, account_id, envelope_id, **kwargs): 4096 """ 4097 Deletes the email setting overrides for an envelope. 4098 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. 4099 This method makes a synchronous HTTP request by default. To make an 4100 asynchronous HTTP request, please define a `callback` function 4101 to be invoked when receiving the response. 4102 >>> def callback_function(response): 4103 >>> pprint(response) 4104 >>> 4105 >>> thread = api.delete_email_settings(account_id, envelope_id, callback=callback_function) 4106 4107 :param callback function: The callback function 4108 for asynchronous request. (optional) 4109 :param str account_id: The external account number (int) or account ID Guid. (required) 4110 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4111 :return: EmailSettings 4112 If the method is called asynchronously, 4113 returns the request thread. 4114 """ 4115 kwargs['_return_http_data_only'] = True 4116 if kwargs.get('callback'): 4117 return self.delete_email_settings_with_http_info(account_id, envelope_id, **kwargs) 4118 else: 4119 (data) = self.delete_email_settings_with_http_info(account_id, envelope_id, **kwargs) 4120 return data 4121 4122 def delete_email_settings_with_http_info(self, account_id, envelope_id, **kwargs): 4123 """ 4124 Deletes the email setting overrides for an envelope. 4125 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. 4126 This method makes a synchronous HTTP request by default. To make an 4127 asynchronous HTTP request, please define a `callback` function 4128 to be invoked when receiving the response. 4129 >>> def callback_function(response): 4130 >>> pprint(response) 4131 >>> 4132 >>> thread = api.delete_email_settings_with_http_info(account_id, envelope_id, callback=callback_function) 4133 4134 :param callback function: The callback function 4135 for asynchronous request. (optional) 4136 :param str account_id: The external account number (int) or account ID Guid. (required) 4137 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4138 :return: EmailSettings 4139 If the method is called asynchronously, 4140 returns the request thread. 4141 """ 4142 4143 all_params = ['account_id', 'envelope_id'] 4144 all_params.append('callback') 4145 all_params.append('_return_http_data_only') 4146 all_params.append('_preload_content') 4147 all_params.append('_request_timeout') 4148 4149 params = locals() 4150 for key, val in iteritems(params['kwargs']): 4151 if key not in all_params: 4152 raise TypeError( 4153 "Got an unexpected keyword argument '%s'" 4154 " to method delete_email_settings" % key 4155 ) 4156 params[key] = val 4157 del params['kwargs'] 4158 # verify the required parameter 'account_id' is set 4159 if ('account_id' not in params) or (params['account_id'] is None): 4160 raise ValueError("Missing the required parameter `account_id` when calling `delete_email_settings`") 4161 # verify the required parameter 'envelope_id' is set 4162 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4163 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_email_settings`") 4164 4165 4166 collection_formats = {} 4167 4168 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/email_settings'.replace('{format}', 'json') 4169 path_params = {} 4170 if 'account_id' in params: 4171 path_params['accountId'] = params['account_id'] 4172 if 'envelope_id' in params: 4173 path_params['envelopeId'] = params['envelope_id'] 4174 4175 query_params = {} 4176 4177 header_params = {} 4178 4179 form_params = [] 4180 local_var_files = {} 4181 4182 body_params = None 4183 # HTTP header `Accept` 4184 header_params['Accept'] = self.api_client.\ 4185 select_header_accept(['application/json']) 4186 4187 # Authentication setting 4188 auth_settings = [] 4189 4190 return self.api_client.call_api(resource_path, 'DELETE', 4191 path_params, 4192 query_params, 4193 header_params, 4194 body=body_params, 4195 post_params=form_params, 4196 files=local_var_files, 4197 response_type='EmailSettings', 4198 auth_settings=auth_settings, 4199 callback=params.get('callback'), 4200 _return_http_data_only=params.get('_return_http_data_only'), 4201 _preload_content=params.get('_preload_content', True), 4202 _request_timeout=params.get('_request_timeout'), 4203 collection_formats=collection_formats) 4204 4205 def delete_envelope_correct_view(self, account_id, envelope_id, **kwargs): 4206 """ 4207 Revokes the correction view URL to the Envelope UI 4208 Revokes the correction view URL to the Envelope UI. 4209 This method makes a synchronous HTTP request by default. To make an 4210 asynchronous HTTP request, please define a `callback` function 4211 to be invoked when receiving the response. 4212 >>> def callback_function(response): 4213 >>> pprint(response) 4214 >>> 4215 >>> thread = api.delete_envelope_correct_view(account_id, envelope_id, callback=callback_function) 4216 4217 :param callback function: The callback function 4218 for asynchronous request. (optional) 4219 :param str account_id: The external account number (int) or account ID Guid. (required) 4220 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4221 :param CorrectViewRequest correct_view_request: 4222 :return: None 4223 If the method is called asynchronously, 4224 returns the request thread. 4225 """ 4226 kwargs['_return_http_data_only'] = True 4227 if kwargs.get('callback'): 4228 return self.delete_envelope_correct_view_with_http_info(account_id, envelope_id, **kwargs) 4229 else: 4230 (data) = self.delete_envelope_correct_view_with_http_info(account_id, envelope_id, **kwargs) 4231 return data 4232 4233 def delete_envelope_correct_view_with_http_info(self, account_id, envelope_id, **kwargs): 4234 """ 4235 Revokes the correction view URL to the Envelope UI 4236 Revokes the correction view URL to the Envelope UI. 4237 This method makes a synchronous HTTP request by default. To make an 4238 asynchronous HTTP request, please define a `callback` function 4239 to be invoked when receiving the response. 4240 >>> def callback_function(response): 4241 >>> pprint(response) 4242 >>> 4243 >>> thread = api.delete_envelope_correct_view_with_http_info(account_id, envelope_id, callback=callback_function) 4244 4245 :param callback function: The callback function 4246 for asynchronous request. (optional) 4247 :param str account_id: The external account number (int) or account ID Guid. (required) 4248 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4249 :param CorrectViewRequest correct_view_request: 4250 :return: None 4251 If the method is called asynchronously, 4252 returns the request thread. 4253 """ 4254 4255 all_params = ['account_id', 'envelope_id', 'correct_view_request'] 4256 all_params.append('callback') 4257 all_params.append('_return_http_data_only') 4258 all_params.append('_preload_content') 4259 all_params.append('_request_timeout') 4260 4261 params = locals() 4262 for key, val in iteritems(params['kwargs']): 4263 if key not in all_params: 4264 raise TypeError( 4265 "Got an unexpected keyword argument '%s'" 4266 " to method delete_envelope_correct_view" % key 4267 ) 4268 params[key] = val 4269 del params['kwargs'] 4270 # verify the required parameter 'account_id' is set 4271 if ('account_id' not in params) or (params['account_id'] is None): 4272 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_correct_view`") 4273 # verify the required parameter 'envelope_id' is set 4274 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4275 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_envelope_correct_view`") 4276 4277 4278 collection_formats = {} 4279 4280 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/correct'.replace('{format}', 'json') 4281 path_params = {} 4282 if 'account_id' in params: 4283 path_params['accountId'] = params['account_id'] 4284 if 'envelope_id' in params: 4285 path_params['envelopeId'] = params['envelope_id'] 4286 4287 query_params = {} 4288 4289 header_params = {} 4290 4291 form_params = [] 4292 local_var_files = {} 4293 4294 body_params = None 4295 if 'correct_view_request' in params: 4296 body_params = params['correct_view_request'] 4297 # HTTP header `Accept` 4298 header_params['Accept'] = self.api_client.\ 4299 select_header_accept(['application/json']) 4300 4301 # Authentication setting 4302 auth_settings = [] 4303 4304 return self.api_client.call_api(resource_path, 'DELETE', 4305 path_params, 4306 query_params, 4307 header_params, 4308 body=body_params, 4309 post_params=form_params, 4310 files=local_var_files, 4311 response_type=None, 4312 auth_settings=auth_settings, 4313 callback=params.get('callback'), 4314 _return_http_data_only=params.get('_return_http_data_only'), 4315 _preload_content=params.get('_preload_content', True), 4316 _request_timeout=params.get('_request_timeout'), 4317 collection_formats=collection_formats) 4318 4319 def delete_envelope_delayed_routing_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 4320 """ 4321 Deletes the delayed routing rules for the specified envelope workflow step. 4322 This method makes a synchronous HTTP request by default. To make an 4323 asynchronous HTTP request, please define a `callback` function 4324 to be invoked when receiving the response. 4325 >>> def callback_function(response): 4326 >>> pprint(response) 4327 >>> 4328 >>> thread = api.delete_envelope_delayed_routing_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 4329 4330 :param callback function: The callback function 4331 for asynchronous request. (optional) 4332 :param str account_id: The external account number (int) or account ID Guid. (required) 4333 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4334 :param str workflow_step_id: (required) 4335 :return: None 4336 If the method is called asynchronously, 4337 returns the request thread. 4338 """ 4339 kwargs['_return_http_data_only'] = True 4340 if kwargs.get('callback'): 4341 return self.delete_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 4342 else: 4343 (data) = self.delete_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 4344 return data 4345 4346 def delete_envelope_delayed_routing_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 4347 """ 4348 Deletes the delayed routing rules for the specified envelope workflow step. 4349 This method makes a synchronous HTTP request by default. To make an 4350 asynchronous HTTP request, please define a `callback` function 4351 to be invoked when receiving the response. 4352 >>> def callback_function(response): 4353 >>> pprint(response) 4354 >>> 4355 >>> thread = api.delete_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 4356 4357 :param callback function: The callback function 4358 for asynchronous request. (optional) 4359 :param str account_id: The external account number (int) or account ID Guid. (required) 4360 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4361 :param str workflow_step_id: (required) 4362 :return: None 4363 If the method is called asynchronously, 4364 returns the request thread. 4365 """ 4366 4367 all_params = ['account_id', 'envelope_id', 'workflow_step_id'] 4368 all_params.append('callback') 4369 all_params.append('_return_http_data_only') 4370 all_params.append('_preload_content') 4371 all_params.append('_request_timeout') 4372 4373 params = locals() 4374 for key, val in iteritems(params['kwargs']): 4375 if key not in all_params: 4376 raise TypeError( 4377 "Got an unexpected keyword argument '%s'" 4378 " to method delete_envelope_delayed_routing_definition" % key 4379 ) 4380 params[key] = val 4381 del params['kwargs'] 4382 # verify the required parameter 'account_id' is set 4383 if ('account_id' not in params) or (params['account_id'] is None): 4384 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_delayed_routing_definition`") 4385 # verify the required parameter 'envelope_id' is set 4386 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4387 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_envelope_delayed_routing_definition`") 4388 # verify the required parameter 'workflow_step_id' is set 4389 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 4390 raise ValueError("Missing the required parameter `workflow_step_id` when calling `delete_envelope_delayed_routing_definition`") 4391 4392 4393 collection_formats = {} 4394 4395 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 4396 path_params = {} 4397 if 'account_id' in params: 4398 path_params['accountId'] = params['account_id'] 4399 if 'envelope_id' in params: 4400 path_params['envelopeId'] = params['envelope_id'] 4401 if 'workflow_step_id' in params: 4402 path_params['workflowStepId'] = params['workflow_step_id'] 4403 4404 query_params = {} 4405 4406 header_params = {} 4407 4408 form_params = [] 4409 local_var_files = {} 4410 4411 body_params = None 4412 # HTTP header `Accept` 4413 header_params['Accept'] = self.api_client.\ 4414 select_header_accept(['application/json']) 4415 4416 # Authentication setting 4417 auth_settings = [] 4418 4419 return self.api_client.call_api(resource_path, 'DELETE', 4420 path_params, 4421 query_params, 4422 header_params, 4423 body=body_params, 4424 post_params=form_params, 4425 files=local_var_files, 4426 response_type=None, 4427 auth_settings=auth_settings, 4428 callback=params.get('callback'), 4429 _return_http_data_only=params.get('_return_http_data_only'), 4430 _preload_content=params.get('_preload_content', True), 4431 _request_timeout=params.get('_request_timeout'), 4432 collection_formats=collection_formats) 4433 4434 def delete_envelope_scheduled_sending_definition(self, account_id, envelope_id, **kwargs): 4435 """ 4436 Deletes the scheduled sending rules for the envelope's workflow. 4437 This method makes a synchronous HTTP request by default. To make an 4438 asynchronous HTTP request, please define a `callback` function 4439 to be invoked when receiving the response. 4440 >>> def callback_function(response): 4441 >>> pprint(response) 4442 >>> 4443 >>> thread = api.delete_envelope_scheduled_sending_definition(account_id, envelope_id, callback=callback_function) 4444 4445 :param callback function: The callback function 4446 for asynchronous request. (optional) 4447 :param str account_id: The external account number (int) or account ID Guid. (required) 4448 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4449 :return: None 4450 If the method is called asynchronously, 4451 returns the request thread. 4452 """ 4453 kwargs['_return_http_data_only'] = True 4454 if kwargs.get('callback'): 4455 return self.delete_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 4456 else: 4457 (data) = self.delete_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 4458 return data 4459 4460 def delete_envelope_scheduled_sending_definition_with_http_info(self, account_id, envelope_id, **kwargs): 4461 """ 4462 Deletes the scheduled sending rules for the envelope's workflow. 4463 This method makes a synchronous HTTP request by default. To make an 4464 asynchronous HTTP request, please define a `callback` function 4465 to be invoked when receiving the response. 4466 >>> def callback_function(response): 4467 >>> pprint(response) 4468 >>> 4469 >>> thread = api.delete_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, callback=callback_function) 4470 4471 :param callback function: The callback function 4472 for asynchronous request. (optional) 4473 :param str account_id: The external account number (int) or account ID Guid. (required) 4474 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4475 :return: None 4476 If the method is called asynchronously, 4477 returns the request thread. 4478 """ 4479 4480 all_params = ['account_id', 'envelope_id'] 4481 all_params.append('callback') 4482 all_params.append('_return_http_data_only') 4483 all_params.append('_preload_content') 4484 all_params.append('_request_timeout') 4485 4486 params = locals() 4487 for key, val in iteritems(params['kwargs']): 4488 if key not in all_params: 4489 raise TypeError( 4490 "Got an unexpected keyword argument '%s'" 4491 " to method delete_envelope_scheduled_sending_definition" % key 4492 ) 4493 params[key] = val 4494 del params['kwargs'] 4495 # verify the required parameter 'account_id' is set 4496 if ('account_id' not in params) or (params['account_id'] is None): 4497 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_scheduled_sending_definition`") 4498 # verify the required parameter 'envelope_id' is set 4499 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4500 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_envelope_scheduled_sending_definition`") 4501 4502 4503 collection_formats = {} 4504 4505 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/scheduledSending'.replace('{format}', 'json') 4506 path_params = {} 4507 if 'account_id' in params: 4508 path_params['accountId'] = params['account_id'] 4509 if 'envelope_id' in params: 4510 path_params['envelopeId'] = params['envelope_id'] 4511 4512 query_params = {} 4513 4514 header_params = {} 4515 4516 form_params = [] 4517 local_var_files = {} 4518 4519 body_params = None 4520 # HTTP header `Accept` 4521 header_params['Accept'] = self.api_client.\ 4522 select_header_accept(['application/json']) 4523 4524 # Authentication setting 4525 auth_settings = [] 4526 4527 return self.api_client.call_api(resource_path, 'DELETE', 4528 path_params, 4529 query_params, 4530 header_params, 4531 body=body_params, 4532 post_params=form_params, 4533 files=local_var_files, 4534 response_type=None, 4535 auth_settings=auth_settings, 4536 callback=params.get('callback'), 4537 _return_http_data_only=params.get('_return_http_data_only'), 4538 _preload_content=params.get('_preload_content', True), 4539 _request_timeout=params.get('_request_timeout'), 4540 collection_formats=collection_formats) 4541 4542 def delete_envelope_transfer_rules(self, account_id, envelope_transfer_rule_id, **kwargs): 4543 """ 4544 Delete envelope transfer rules for an account. 4545 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. 4546 This method makes a synchronous HTTP request by default. To make an 4547 asynchronous HTTP request, please define a `callback` function 4548 to be invoked when receiving the response. 4549 >>> def callback_function(response): 4550 >>> pprint(response) 4551 >>> 4552 >>> thread = api.delete_envelope_transfer_rules(account_id, envelope_transfer_rule_id, callback=callback_function) 4553 4554 :param callback function: The callback function 4555 for asynchronous request. (optional) 4556 :param str account_id: The external account number (int) or account ID Guid. (required) 4557 :param str envelope_transfer_rule_id: (required) 4558 :return: None 4559 If the method is called asynchronously, 4560 returns the request thread. 4561 """ 4562 kwargs['_return_http_data_only'] = True 4563 if kwargs.get('callback'): 4564 return self.delete_envelope_transfer_rules_with_http_info(account_id, envelope_transfer_rule_id, **kwargs) 4565 else: 4566 (data) = self.delete_envelope_transfer_rules_with_http_info(account_id, envelope_transfer_rule_id, **kwargs) 4567 return data 4568 4569 def delete_envelope_transfer_rules_with_http_info(self, account_id, envelope_transfer_rule_id, **kwargs): 4570 """ 4571 Delete envelope transfer rules for an account. 4572 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. 4573 This method makes a synchronous HTTP request by default. To make an 4574 asynchronous HTTP request, please define a `callback` function 4575 to be invoked when receiving the response. 4576 >>> def callback_function(response): 4577 >>> pprint(response) 4578 >>> 4579 >>> thread = api.delete_envelope_transfer_rules_with_http_info(account_id, envelope_transfer_rule_id, callback=callback_function) 4580 4581 :param callback function: The callback function 4582 for asynchronous request. (optional) 4583 :param str account_id: The external account number (int) or account ID Guid. (required) 4584 :param str envelope_transfer_rule_id: (required) 4585 :return: None 4586 If the method is called asynchronously, 4587 returns the request thread. 4588 """ 4589 4590 all_params = ['account_id', 'envelope_transfer_rule_id'] 4591 all_params.append('callback') 4592 all_params.append('_return_http_data_only') 4593 all_params.append('_preload_content') 4594 all_params.append('_request_timeout') 4595 4596 params = locals() 4597 for key, val in iteritems(params['kwargs']): 4598 if key not in all_params: 4599 raise TypeError( 4600 "Got an unexpected keyword argument '%s'" 4601 " to method delete_envelope_transfer_rules" % key 4602 ) 4603 params[key] = val 4604 del params['kwargs'] 4605 # verify the required parameter 'account_id' is set 4606 if ('account_id' not in params) or (params['account_id'] is None): 4607 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_transfer_rules`") 4608 # verify the required parameter 'envelope_transfer_rule_id' is set 4609 if ('envelope_transfer_rule_id' not in params) or (params['envelope_transfer_rule_id'] is None): 4610 raise ValueError("Missing the required parameter `envelope_transfer_rule_id` when calling `delete_envelope_transfer_rules`") 4611 4612 4613 collection_formats = {} 4614 4615 resource_path = '/v2.1/accounts/{accountId}/envelopes/transfer_rules/{envelopeTransferRuleId}'.replace('{format}', 'json') 4616 path_params = {} 4617 if 'account_id' in params: 4618 path_params['accountId'] = params['account_id'] 4619 if 'envelope_transfer_rule_id' in params: 4620 path_params['envelopeTransferRuleId'] = params['envelope_transfer_rule_id'] 4621 4622 query_params = {} 4623 4624 header_params = {} 4625 4626 form_params = [] 4627 local_var_files = {} 4628 4629 body_params = None 4630 # HTTP header `Accept` 4631 header_params['Accept'] = self.api_client.\ 4632 select_header_accept(['application/json']) 4633 4634 # Authentication setting 4635 auth_settings = [] 4636 4637 return self.api_client.call_api(resource_path, 'DELETE', 4638 path_params, 4639 query_params, 4640 header_params, 4641 body=body_params, 4642 post_params=form_params, 4643 files=local_var_files, 4644 response_type=None, 4645 auth_settings=auth_settings, 4646 callback=params.get('callback'), 4647 _return_http_data_only=params.get('_return_http_data_only'), 4648 _preload_content=params.get('_preload_content', True), 4649 _request_timeout=params.get('_request_timeout'), 4650 collection_formats=collection_formats) 4651 4652 def delete_envelope_workflow_definition(self, account_id, envelope_id, **kwargs): 4653 """ 4654 Delete the workflow definition for an envelope. 4655 Deletes the specified envelope's workflow definition if it has one. 4656 This method makes a synchronous HTTP request by default. To make an 4657 asynchronous HTTP request, please define a `callback` function 4658 to be invoked when receiving the response. 4659 >>> def callback_function(response): 4660 >>> pprint(response) 4661 >>> 4662 >>> thread = api.delete_envelope_workflow_definition(account_id, envelope_id, callback=callback_function) 4663 4664 :param callback function: The callback function 4665 for asynchronous request. (optional) 4666 :param str account_id: The external account number (int) or account ID Guid. (required) 4667 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4668 :return: None 4669 If the method is called asynchronously, 4670 returns the request thread. 4671 """ 4672 kwargs['_return_http_data_only'] = True 4673 if kwargs.get('callback'): 4674 return self.delete_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 4675 else: 4676 (data) = self.delete_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 4677 return data 4678 4679 def delete_envelope_workflow_definition_with_http_info(self, account_id, envelope_id, **kwargs): 4680 """ 4681 Delete the workflow definition for an envelope. 4682 Deletes the specified envelope's workflow definition if it has one. 4683 This method makes a synchronous HTTP request by default. To make an 4684 asynchronous HTTP request, please define a `callback` function 4685 to be invoked when receiving the response. 4686 >>> def callback_function(response): 4687 >>> pprint(response) 4688 >>> 4689 >>> thread = api.delete_envelope_workflow_definition_with_http_info(account_id, envelope_id, callback=callback_function) 4690 4691 :param callback function: The callback function 4692 for asynchronous request. (optional) 4693 :param str account_id: The external account number (int) or account ID Guid. (required) 4694 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4695 :return: None 4696 If the method is called asynchronously, 4697 returns the request thread. 4698 """ 4699 4700 all_params = ['account_id', 'envelope_id'] 4701 all_params.append('callback') 4702 all_params.append('_return_http_data_only') 4703 all_params.append('_preload_content') 4704 all_params.append('_request_timeout') 4705 4706 params = locals() 4707 for key, val in iteritems(params['kwargs']): 4708 if key not in all_params: 4709 raise TypeError( 4710 "Got an unexpected keyword argument '%s'" 4711 " to method delete_envelope_workflow_definition" % key 4712 ) 4713 params[key] = val 4714 del params['kwargs'] 4715 # verify the required parameter 'account_id' is set 4716 if ('account_id' not in params) or (params['account_id'] is None): 4717 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_workflow_definition`") 4718 # verify the required parameter 'envelope_id' is set 4719 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4720 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_envelope_workflow_definition`") 4721 4722 4723 collection_formats = {} 4724 4725 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow'.replace('{format}', 'json') 4726 path_params = {} 4727 if 'account_id' in params: 4728 path_params['accountId'] = params['account_id'] 4729 if 'envelope_id' in params: 4730 path_params['envelopeId'] = params['envelope_id'] 4731 4732 query_params = {} 4733 4734 header_params = {} 4735 4736 form_params = [] 4737 local_var_files = {} 4738 4739 body_params = None 4740 # HTTP header `Accept` 4741 header_params['Accept'] = self.api_client.\ 4742 select_header_accept(['application/json']) 4743 4744 # Authentication setting 4745 auth_settings = [] 4746 4747 return self.api_client.call_api(resource_path, 'DELETE', 4748 path_params, 4749 query_params, 4750 header_params, 4751 body=body_params, 4752 post_params=form_params, 4753 files=local_var_files, 4754 response_type=None, 4755 auth_settings=auth_settings, 4756 callback=params.get('callback'), 4757 _return_http_data_only=params.get('_return_http_data_only'), 4758 _preload_content=params.get('_preload_content', True), 4759 _request_timeout=params.get('_request_timeout'), 4760 collection_formats=collection_formats) 4761 4762 def delete_envelope_workflow_step_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 4763 """ 4764 Deletes the envelope workflow step definition for an envelope's workflow by step id. 4765 This method makes a synchronous HTTP request by default. To make an 4766 asynchronous HTTP request, please define a `callback` function 4767 to be invoked when receiving the response. 4768 >>> def callback_function(response): 4769 >>> pprint(response) 4770 >>> 4771 >>> thread = api.delete_envelope_workflow_step_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 4772 4773 :param callback function: The callback function 4774 for asynchronous request. (optional) 4775 :param str account_id: The external account number (int) or account ID Guid. (required) 4776 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4777 :param str workflow_step_id: (required) 4778 :return: None 4779 If the method is called asynchronously, 4780 returns the request thread. 4781 """ 4782 kwargs['_return_http_data_only'] = True 4783 if kwargs.get('callback'): 4784 return self.delete_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 4785 else: 4786 (data) = self.delete_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 4787 return data 4788 4789 def delete_envelope_workflow_step_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 4790 """ 4791 Deletes the envelope workflow step definition for an envelope's workflow by step id. 4792 This method makes a synchronous HTTP request by default. To make an 4793 asynchronous HTTP request, please define a `callback` function 4794 to be invoked when receiving the response. 4795 >>> def callback_function(response): 4796 >>> pprint(response) 4797 >>> 4798 >>> thread = api.delete_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 4799 4800 :param callback function: The callback function 4801 for asynchronous request. (optional) 4802 :param str account_id: The external account number (int) or account ID Guid. (required) 4803 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4804 :param str workflow_step_id: (required) 4805 :return: None 4806 If the method is called asynchronously, 4807 returns the request thread. 4808 """ 4809 4810 all_params = ['account_id', 'envelope_id', 'workflow_step_id'] 4811 all_params.append('callback') 4812 all_params.append('_return_http_data_only') 4813 all_params.append('_preload_content') 4814 all_params.append('_request_timeout') 4815 4816 params = locals() 4817 for key, val in iteritems(params['kwargs']): 4818 if key not in all_params: 4819 raise TypeError( 4820 "Got an unexpected keyword argument '%s'" 4821 " to method delete_envelope_workflow_step_definition" % key 4822 ) 4823 params[key] = val 4824 del params['kwargs'] 4825 # verify the required parameter 'account_id' is set 4826 if ('account_id' not in params) or (params['account_id'] is None): 4827 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_workflow_step_definition`") 4828 # verify the required parameter 'envelope_id' is set 4829 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4830 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_envelope_workflow_step_definition`") 4831 # verify the required parameter 'workflow_step_id' is set 4832 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 4833 raise ValueError("Missing the required parameter `workflow_step_id` when calling `delete_envelope_workflow_step_definition`") 4834 4835 4836 collection_formats = {} 4837 4838 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 4839 path_params = {} 4840 if 'account_id' in params: 4841 path_params['accountId'] = params['account_id'] 4842 if 'envelope_id' in params: 4843 path_params['envelopeId'] = params['envelope_id'] 4844 if 'workflow_step_id' in params: 4845 path_params['workflowStepId'] = params['workflow_step_id'] 4846 4847 query_params = {} 4848 4849 header_params = {} 4850 4851 form_params = [] 4852 local_var_files = {} 4853 4854 body_params = None 4855 # HTTP header `Accept` 4856 header_params['Accept'] = self.api_client.\ 4857 select_header_accept(['application/json']) 4858 4859 # Authentication setting 4860 auth_settings = [] 4861 4862 return self.api_client.call_api(resource_path, 'DELETE', 4863 path_params, 4864 query_params, 4865 header_params, 4866 body=body_params, 4867 post_params=form_params, 4868 files=local_var_files, 4869 response_type=None, 4870 auth_settings=auth_settings, 4871 callback=params.get('callback'), 4872 _return_http_data_only=params.get('_return_http_data_only'), 4873 _preload_content=params.get('_preload_content', True), 4874 _request_timeout=params.get('_request_timeout'), 4875 collection_formats=collection_formats) 4876 4877 def delete_lock(self, account_id, envelope_id, **kwargs): 4878 """ 4879 Deletes an envelope lock. 4880 Deletes the lock from the specified envelope. The `X-DocuSign-Edit` header must be included in the request. 4881 This method makes a synchronous HTTP request by default. To make an 4882 asynchronous HTTP request, please define a `callback` function 4883 to be invoked when receiving the response. 4884 >>> def callback_function(response): 4885 >>> pprint(response) 4886 >>> 4887 >>> thread = api.delete_lock(account_id, envelope_id, callback=callback_function) 4888 4889 :param callback function: The callback function 4890 for asynchronous request. (optional) 4891 :param str account_id: The external account number (int) or account ID Guid. (required) 4892 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4893 :return: LockInformation 4894 If the method is called asynchronously, 4895 returns the request thread. 4896 """ 4897 kwargs['_return_http_data_only'] = True 4898 if kwargs.get('callback'): 4899 return self.delete_lock_with_http_info(account_id, envelope_id, **kwargs) 4900 else: 4901 (data) = self.delete_lock_with_http_info(account_id, envelope_id, **kwargs) 4902 return data 4903 4904 def delete_lock_with_http_info(self, account_id, envelope_id, **kwargs): 4905 """ 4906 Deletes an envelope lock. 4907 Deletes the lock from the specified envelope. The `X-DocuSign-Edit` header must be included in the request. 4908 This method makes a synchronous HTTP request by default. To make an 4909 asynchronous HTTP request, please define a `callback` function 4910 to be invoked when receiving the response. 4911 >>> def callback_function(response): 4912 >>> pprint(response) 4913 >>> 4914 >>> thread = api.delete_lock_with_http_info(account_id, envelope_id, callback=callback_function) 4915 4916 :param callback function: The callback function 4917 for asynchronous request. (optional) 4918 :param str account_id: The external account number (int) or account ID Guid. (required) 4919 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4920 :return: LockInformation 4921 If the method is called asynchronously, 4922 returns the request thread. 4923 """ 4924 4925 all_params = ['account_id', 'envelope_id'] 4926 all_params.append('callback') 4927 all_params.append('_return_http_data_only') 4928 all_params.append('_preload_content') 4929 all_params.append('_request_timeout') 4930 4931 params = locals() 4932 for key, val in iteritems(params['kwargs']): 4933 if key not in all_params: 4934 raise TypeError( 4935 "Got an unexpected keyword argument '%s'" 4936 " to method delete_lock" % key 4937 ) 4938 params[key] = val 4939 del params['kwargs'] 4940 # verify the required parameter 'account_id' is set 4941 if ('account_id' not in params) or (params['account_id'] is None): 4942 raise ValueError("Missing the required parameter `account_id` when calling `delete_lock`") 4943 # verify the required parameter 'envelope_id' is set 4944 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4945 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_lock`") 4946 4947 4948 collection_formats = {} 4949 4950 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/lock'.replace('{format}', 'json') 4951 path_params = {} 4952 if 'account_id' in params: 4953 path_params['accountId'] = params['account_id'] 4954 if 'envelope_id' in params: 4955 path_params['envelopeId'] = params['envelope_id'] 4956 4957 query_params = {} 4958 4959 header_params = {} 4960 4961 form_params = [] 4962 local_var_files = {} 4963 4964 body_params = None 4965 # HTTP header `Accept` 4966 header_params['Accept'] = self.api_client.\ 4967 select_header_accept(['application/json']) 4968 4969 # Authentication setting 4970 auth_settings = [] 4971 4972 return self.api_client.call_api(resource_path, 'DELETE', 4973 path_params, 4974 query_params, 4975 header_params, 4976 body=body_params, 4977 post_params=form_params, 4978 files=local_var_files, 4979 response_type='LockInformation', 4980 auth_settings=auth_settings, 4981 callback=params.get('callback'), 4982 _return_http_data_only=params.get('_return_http_data_only'), 4983 _preload_content=params.get('_preload_content', True), 4984 _request_timeout=params.get('_request_timeout'), 4985 collection_formats=collection_formats) 4986 4987 def delete_recipient(self, account_id, envelope_id, recipient_id, **kwargs): 4988 """ 4989 Deletes a recipient from an envelope. 4990 Deletes the specified recipient file from the specified envelope. This cannot be used if the envelope has been sent. 4991 This method makes a synchronous HTTP request by default. To make an 4992 asynchronous HTTP request, please define a `callback` function 4993 to be invoked when receiving the response. 4994 >>> def callback_function(response): 4995 >>> pprint(response) 4996 >>> 4997 >>> thread = api.delete_recipient(account_id, envelope_id, recipient_id, callback=callback_function) 4998 4999 :param callback function: The callback function 5000 for asynchronous request. (optional) 5001 :param str account_id: The external account number (int) or account ID Guid. (required) 5002 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5003 :param str recipient_id: The ID of the recipient being accessed. (required) 5004 :return: Recipients 5005 If the method is called asynchronously, 5006 returns the request thread. 5007 """ 5008 kwargs['_return_http_data_only'] = True 5009 if kwargs.get('callback'): 5010 return self.delete_recipient_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 5011 else: 5012 (data) = self.delete_recipient_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 5013 return data 5014 5015 def delete_recipient_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 5016 """ 5017 Deletes a recipient from an envelope. 5018 Deletes the specified recipient file from the specified envelope. This cannot be used if the envelope has been sent. 5019 This method makes a synchronous HTTP request by default. To make an 5020 asynchronous HTTP request, please define a `callback` function 5021 to be invoked when receiving the response. 5022 >>> def callback_function(response): 5023 >>> pprint(response) 5024 >>> 5025 >>> thread = api.delete_recipient_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 5026 5027 :param callback function: The callback function 5028 for asynchronous request. (optional) 5029 :param str account_id: The external account number (int) or account ID Guid. (required) 5030 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5031 :param str recipient_id: The ID of the recipient being accessed. (required) 5032 :return: Recipients 5033 If the method is called asynchronously, 5034 returns the request thread. 5035 """ 5036 5037 all_params = ['account_id', 'envelope_id', 'recipient_id'] 5038 all_params.append('callback') 5039 all_params.append('_return_http_data_only') 5040 all_params.append('_preload_content') 5041 all_params.append('_request_timeout') 5042 5043 params = locals() 5044 for key, val in iteritems(params['kwargs']): 5045 if key not in all_params: 5046 raise TypeError( 5047 "Got an unexpected keyword argument '%s'" 5048 " to method delete_recipient" % key 5049 ) 5050 params[key] = val 5051 del params['kwargs'] 5052 # verify the required parameter 'account_id' is set 5053 if ('account_id' not in params) or (params['account_id'] is None): 5054 raise ValueError("Missing the required parameter `account_id` when calling `delete_recipient`") 5055 # verify the required parameter 'envelope_id' is set 5056 if ('envelope_id' not in params) or (params['envelope_id'] is None): 5057 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_recipient`") 5058 # verify the required parameter 'recipient_id' is set 5059 if ('recipient_id' not in params) or (params['recipient_id'] is None): 5060 raise ValueError("Missing the required parameter `recipient_id` when calling `delete_recipient`") 5061 5062 5063 collection_formats = {} 5064 5065 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}'.replace('{format}', 'json') 5066 path_params = {} 5067 if 'account_id' in params: 5068 path_params['accountId'] = params['account_id'] 5069 if 'envelope_id' in params: 5070 path_params['envelopeId'] = params['envelope_id'] 5071 if 'recipient_id' in params: 5072 path_params['recipientId'] = params['recipient_id'] 5073 5074 query_params = {} 5075 5076 header_params = {} 5077 5078 form_params = [] 5079 local_var_files = {} 5080 5081 body_params = None 5082 # HTTP header `Accept` 5083 header_params['Accept'] = self.api_client.\ 5084 select_header_accept(['application/json']) 5085 5086 # Authentication setting 5087 auth_settings = [] 5088 5089 return self.api_client.call_api(resource_path, 'DELETE', 5090 path_params, 5091 query_params, 5092 header_params, 5093 body=body_params, 5094 post_params=form_params, 5095 files=local_var_files, 5096 response_type='Recipients', 5097 auth_settings=auth_settings, 5098 callback=params.get('callback'), 5099 _return_http_data_only=params.get('_return_http_data_only'), 5100 _preload_content=params.get('_preload_content', True), 5101 _request_timeout=params.get('_request_timeout'), 5102 collection_formats=collection_formats) 5103 5104 def delete_recipients(self, account_id, envelope_id, **kwargs): 5105 """ 5106 Deletes recipients from an envelope. 5107 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. 5108 This method makes a synchronous HTTP request by default. To make an 5109 asynchronous HTTP request, please define a `callback` function 5110 to be invoked when receiving the response. 5111 >>> def callback_function(response): 5112 >>> pprint(response) 5113 >>> 5114 >>> thread = api.delete_recipients(account_id, envelope_id, callback=callback_function) 5115 5116 :param callback function: The callback function 5117 for asynchronous request. (optional) 5118 :param str account_id: The external account number (int) or account ID Guid. (required) 5119 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5120 :param Recipients recipients: 5121 :return: Recipients 5122 If the method is called asynchronously, 5123 returns the request thread. 5124 """ 5125 kwargs['_return_http_data_only'] = True 5126 if kwargs.get('callback'): 5127 return self.delete_recipients_with_http_info(account_id, envelope_id, **kwargs) 5128 else: 5129 (data) = self.delete_recipients_with_http_info(account_id, envelope_id, **kwargs) 5130 return data 5131 5132 def delete_recipients_with_http_info(self, account_id, envelope_id, **kwargs): 5133 """ 5134 Deletes recipients from an envelope. 5135 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. 5136 This method makes a synchronous HTTP request by default. To make an 5137 asynchronous HTTP request, please define a `callback` function 5138 to be invoked when receiving the response. 5139 >>> def callback_function(response): 5140 >>> pprint(response) 5141 >>> 5142 >>> thread = api.delete_recipients_with_http_info(account_id, envelope_id, callback=callback_function) 5143 5144 :param callback function: The callback function 5145 for asynchronous request. (optional) 5146 :param str account_id: The external account number (int) or account ID Guid. (required) 5147 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5148 :param Recipients recipients: 5149 :return: Recipients 5150 If the method is called asynchronously, 5151 returns the request thread. 5152 """ 5153 5154 all_params = ['account_id', 'envelope_id', 'recipients'] 5155 all_params.append('callback') 5156 all_params.append('_return_http_data_only') 5157 all_params.append('_preload_content') 5158 all_params.append('_request_timeout') 5159 5160 params = locals() 5161 for key, val in iteritems(params['kwargs']): 5162 if key not in all_params: 5163 raise TypeError( 5164 "Got an unexpected keyword argument '%s'" 5165 " to method delete_recipients" % key 5166 ) 5167 params[key] = val 5168 del params['kwargs'] 5169 # verify the required parameter 'account_id' is set 5170 if ('account_id' not in params) or (params['account_id'] is None): 5171 raise ValueError("Missing the required parameter `account_id` when calling `delete_recipients`") 5172 # verify the required parameter 'envelope_id' is set 5173 if ('envelope_id' not in params) or (params['envelope_id'] is None): 5174 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_recipients`") 5175 5176 5177 collection_formats = {} 5178 5179 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients'.replace('{format}', 'json') 5180 path_params = {} 5181 if 'account_id' in params: 5182 path_params['accountId'] = params['account_id'] 5183 if 'envelope_id' in params: 5184 path_params['envelopeId'] = params['envelope_id'] 5185 5186 query_params = {} 5187 5188 header_params = {} 5189 5190 form_params = [] 5191 local_var_files = {} 5192 5193 body_params = None 5194 if 'recipients' in params: 5195 body_params = params['recipients'] 5196 # HTTP header `Accept` 5197 header_params['Accept'] = self.api_client.\ 5198 select_header_accept(['application/json']) 5199 5200 # Authentication setting 5201 auth_settings = [] 5202 5203 return self.api_client.call_api(resource_path, 'DELETE', 5204 path_params, 5205 query_params, 5206 header_params, 5207 body=body_params, 5208 post_params=form_params, 5209 files=local_var_files, 5210 response_type='Recipients', 5211 auth_settings=auth_settings, 5212 callback=params.get('callback'), 5213 _return_http_data_only=params.get('_return_http_data_only'), 5214 _preload_content=params.get('_preload_content', True), 5215 _request_timeout=params.get('_request_timeout'), 5216 collection_formats=collection_formats) 5217 5218 def delete_tabs(self, account_id, envelope_id, recipient_id, **kwargs): 5219 """ 5220 Deletes the tabs associated with a recipient. 5221 Deletes one or more tabs associated with a recipient in a draft envelope. 5222 This method makes a synchronous HTTP request by default. To make an 5223 asynchronous HTTP request, please define a `callback` function 5224 to be invoked when receiving the response. 5225 >>> def callback_function(response): 5226 >>> pprint(response) 5227 >>> 5228 >>> thread = api.delete_tabs(account_id, envelope_id, recipient_id, callback=callback_function) 5229 5230 :param callback function: The callback function 5231 for asynchronous request. (optional) 5232 :param str account_id: The external account number (int) or account ID Guid. (required) 5233 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5234 :param str recipient_id: The ID of the recipient being accessed. (required) 5235 :param Tabs tabs: 5236 :return: Tabs 5237 If the method is called asynchronously, 5238 returns the request thread. 5239 """ 5240 kwargs['_return_http_data_only'] = True 5241 if kwargs.get('callback'): 5242 return self.delete_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 5243 else: 5244 (data) = self.delete_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 5245 return data 5246 5247 def delete_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 5248 """ 5249 Deletes the tabs associated with a recipient. 5250 Deletes one or more tabs associated with a recipient in a draft envelope. 5251 This method makes a synchronous HTTP request by default. To make an 5252 asynchronous HTTP request, please define a `callback` function 5253 to be invoked when receiving the response. 5254 >>> def callback_function(response): 5255 >>> pprint(response) 5256 >>> 5257 >>> thread = api.delete_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 5258 5259 :param callback function: The callback function 5260 for asynchronous request. (optional) 5261 :param str account_id: The external account number (int) or account ID Guid. (required) 5262 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5263 :param str recipient_id: The ID of the recipient being accessed. (required) 5264 :param Tabs tabs: 5265 :return: Tabs 5266 If the method is called asynchronously, 5267 returns the request thread. 5268 """ 5269 5270 all_params = ['account_id', 'envelope_id', 'recipient_id', 'tabs'] 5271 all_params.append('callback') 5272 all_params.append('_return_http_data_only') 5273 all_params.append('_preload_content') 5274 all_params.append('_request_timeout') 5275 5276 params = locals() 5277 for key, val in iteritems(params['kwargs']): 5278 if key not in all_params: 5279 raise TypeError( 5280 "Got an unexpected keyword argument '%s'" 5281 " to method delete_tabs" % key 5282 ) 5283 params[key] = val 5284 del params['kwargs'] 5285 # verify the required parameter 'account_id' is set 5286 if ('account_id' not in params) or (params['account_id'] is None): 5287 raise ValueError("Missing the required parameter `account_id` when calling `delete_tabs`") 5288 # verify the required parameter 'envelope_id' is set 5289 if ('envelope_id' not in params) or (params['envelope_id'] is None): 5290 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_tabs`") 5291 # verify the required parameter 'recipient_id' is set 5292 if ('recipient_id' not in params) or (params['recipient_id'] is None): 5293 raise ValueError("Missing the required parameter `recipient_id` when calling `delete_tabs`") 5294 5295 5296 collection_formats = {} 5297 5298 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/tabs'.replace('{format}', 'json') 5299 path_params = {} 5300 if 'account_id' in params: 5301 path_params['accountId'] = params['account_id'] 5302 if 'envelope_id' in params: 5303 path_params['envelopeId'] = params['envelope_id'] 5304 if 'recipient_id' in params: 5305 path_params['recipientId'] = params['recipient_id'] 5306 5307 query_params = {} 5308 5309 header_params = {} 5310 5311 form_params = [] 5312 local_var_files = {} 5313 5314 body_params = None 5315 if 'tabs' in params: 5316 body_params = params['tabs'] 5317 # HTTP header `Accept` 5318 header_params['Accept'] = self.api_client.\ 5319 select_header_accept(['application/json']) 5320 5321 # Authentication setting 5322 auth_settings = [] 5323 5324 return self.api_client.call_api(resource_path, 'DELETE', 5325 path_params, 5326 query_params, 5327 header_params, 5328 body=body_params, 5329 post_params=form_params, 5330 files=local_var_files, 5331 response_type='Tabs', 5332 auth_settings=auth_settings, 5333 callback=params.get('callback'), 5334 _return_http_data_only=params.get('_return_http_data_only'), 5335 _preload_content=params.get('_preload_content', True), 5336 _request_timeout=params.get('_request_timeout'), 5337 collection_formats=collection_formats) 5338 5339 def delete_template_delayed_routing_definition(self, account_id, template_id, workflow_step_id, **kwargs): 5340 """ 5341 Deletes the delayed routing rules for the specified template workflow step. 5342 This method makes a synchronous HTTP request by default. To make an 5343 asynchronous HTTP request, please define a `callback` function 5344 to be invoked when receiving the response. 5345 >>> def callback_function(response): 5346 >>> pprint(response) 5347 >>> 5348 >>> thread = api.delete_template_delayed_routing_definition(account_id, template_id, workflow_step_id, callback=callback_function) 5349 5350 :param callback function: The callback function 5351 for asynchronous request. (optional) 5352 :param str account_id: The external account number (int) or account ID Guid. (required) 5353 :param str template_id: The ID of the template being accessed. (required) 5354 :param str workflow_step_id: (required) 5355 :return: None 5356 If the method is called asynchronously, 5357 returns the request thread. 5358 """ 5359 kwargs['_return_http_data_only'] = True 5360 if kwargs.get('callback'): 5361 return self.delete_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 5362 else: 5363 (data) = self.delete_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 5364 return data 5365 5366 def delete_template_delayed_routing_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 5367 """ 5368 Deletes the delayed routing rules for the specified template workflow step. 5369 This method makes a synchronous HTTP request by default. To make an 5370 asynchronous HTTP request, please define a `callback` function 5371 to be invoked when receiving the response. 5372 >>> def callback_function(response): 5373 >>> pprint(response) 5374 >>> 5375 >>> thread = api.delete_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 5376 5377 :param callback function: The callback function 5378 for asynchronous request. (optional) 5379 :param str account_id: The external account number (int) or account ID Guid. (required) 5380 :param str template_id: The ID of the template being accessed. (required) 5381 :param str workflow_step_id: (required) 5382 :return: None 5383 If the method is called asynchronously, 5384 returns the request thread. 5385 """ 5386 5387 all_params = ['account_id', 'template_id', 'workflow_step_id'] 5388 all_params.append('callback') 5389 all_params.append('_return_http_data_only') 5390 all_params.append('_preload_content') 5391 all_params.append('_request_timeout') 5392 5393 params = locals() 5394 for key, val in iteritems(params['kwargs']): 5395 if key not in all_params: 5396 raise TypeError( 5397 "Got an unexpected keyword argument '%s'" 5398 " to method delete_template_delayed_routing_definition" % key 5399 ) 5400 params[key] = val 5401 del params['kwargs'] 5402 # verify the required parameter 'account_id' is set 5403 if ('account_id' not in params) or (params['account_id'] is None): 5404 raise ValueError("Missing the required parameter `account_id` when calling `delete_template_delayed_routing_definition`") 5405 # verify the required parameter 'template_id' is set 5406 if ('template_id' not in params) or (params['template_id'] is None): 5407 raise ValueError("Missing the required parameter `template_id` when calling `delete_template_delayed_routing_definition`") 5408 # verify the required parameter 'workflow_step_id' is set 5409 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 5410 raise ValueError("Missing the required parameter `workflow_step_id` when calling `delete_template_delayed_routing_definition`") 5411 5412 5413 collection_formats = {} 5414 5415 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 5416 path_params = {} 5417 if 'account_id' in params: 5418 path_params['accountId'] = params['account_id'] 5419 if 'template_id' in params: 5420 path_params['templateId'] = params['template_id'] 5421 if 'workflow_step_id' in params: 5422 path_params['workflowStepId'] = params['workflow_step_id'] 5423 5424 query_params = {} 5425 5426 header_params = {} 5427 5428 form_params = [] 5429 local_var_files = {} 5430 5431 body_params = None 5432 # HTTP header `Accept` 5433 header_params['Accept'] = self.api_client.\ 5434 select_header_accept(['application/json']) 5435 5436 # Authentication setting 5437 auth_settings = [] 5438 5439 return self.api_client.call_api(resource_path, 'DELETE', 5440 path_params, 5441 query_params, 5442 header_params, 5443 body=body_params, 5444 post_params=form_params, 5445 files=local_var_files, 5446 response_type=None, 5447 auth_settings=auth_settings, 5448 callback=params.get('callback'), 5449 _return_http_data_only=params.get('_return_http_data_only'), 5450 _preload_content=params.get('_preload_content', True), 5451 _request_timeout=params.get('_request_timeout'), 5452 collection_formats=collection_formats) 5453 5454 def delete_template_scheduled_sending_definition(self, account_id, template_id, **kwargs): 5455 """ 5456 Deletes the scheduled sending rules for the template's workflow. 5457 This method makes a synchronous HTTP request by default. To make an 5458 asynchronous HTTP request, please define a `callback` function 5459 to be invoked when receiving the response. 5460 >>> def callback_function(response): 5461 >>> pprint(response) 5462 >>> 5463 >>> thread = api.delete_template_scheduled_sending_definition(account_id, template_id, callback=callback_function) 5464 5465 :param callback function: The callback function 5466 for asynchronous request. (optional) 5467 :param str account_id: The external account number (int) or account ID Guid. (required) 5468 :param str template_id: The ID of the template being accessed. (required) 5469 :return: None 5470 If the method is called asynchronously, 5471 returns the request thread. 5472 """ 5473 kwargs['_return_http_data_only'] = True 5474 if kwargs.get('callback'): 5475 return self.delete_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 5476 else: 5477 (data) = self.delete_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 5478 return data 5479 5480 def delete_template_scheduled_sending_definition_with_http_info(self, account_id, template_id, **kwargs): 5481 """ 5482 Deletes the scheduled sending rules for the template's workflow. 5483 This method makes a synchronous HTTP request by default. To make an 5484 asynchronous HTTP request, please define a `callback` function 5485 to be invoked when receiving the response. 5486 >>> def callback_function(response): 5487 >>> pprint(response) 5488 >>> 5489 >>> thread = api.delete_template_scheduled_sending_definition_with_http_info(account_id, template_id, callback=callback_function) 5490 5491 :param callback function: The callback function 5492 for asynchronous request. (optional) 5493 :param str account_id: The external account number (int) or account ID Guid. (required) 5494 :param str template_id: The ID of the template being accessed. (required) 5495 :return: None 5496 If the method is called asynchronously, 5497 returns the request thread. 5498 """ 5499 5500 all_params = ['account_id', 'template_id'] 5501 all_params.append('callback') 5502 all_params.append('_return_http_data_only') 5503 all_params.append('_preload_content') 5504 all_params.append('_request_timeout') 5505 5506 params = locals() 5507 for key, val in iteritems(params['kwargs']): 5508 if key not in all_params: 5509 raise TypeError( 5510 "Got an unexpected keyword argument '%s'" 5511 " to method delete_template_scheduled_sending_definition" % key 5512 ) 5513 params[key] = val 5514 del params['kwargs'] 5515 # verify the required parameter 'account_id' is set 5516 if ('account_id' not in params) or (params['account_id'] is None): 5517 raise ValueError("Missing the required parameter `account_id` when calling `delete_template_scheduled_sending_definition`") 5518 # verify the required parameter 'template_id' is set 5519 if ('template_id' not in params) or (params['template_id'] is None): 5520 raise ValueError("Missing the required parameter `template_id` when calling `delete_template_scheduled_sending_definition`") 5521 5522 5523 collection_formats = {} 5524 5525 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/scheduledSending'.replace('{format}', 'json') 5526 path_params = {} 5527 if 'account_id' in params: 5528 path_params['accountId'] = params['account_id'] 5529 if 'template_id' in params: 5530 path_params['templateId'] = params['template_id'] 5531 5532 query_params = {} 5533 5534 header_params = {} 5535 5536 form_params = [] 5537 local_var_files = {} 5538 5539 body_params = None 5540 # HTTP header `Accept` 5541 header_params['Accept'] = self.api_client.\ 5542 select_header_accept(['application/json']) 5543 5544 # Authentication setting 5545 auth_settings = [] 5546 5547 return self.api_client.call_api(resource_path, 'DELETE', 5548 path_params, 5549 query_params, 5550 header_params, 5551 body=body_params, 5552 post_params=form_params, 5553 files=local_var_files, 5554 response_type=None, 5555 auth_settings=auth_settings, 5556 callback=params.get('callback'), 5557 _return_http_data_only=params.get('_return_http_data_only'), 5558 _preload_content=params.get('_preload_content', True), 5559 _request_timeout=params.get('_request_timeout'), 5560 collection_formats=collection_formats) 5561 5562 def delete_template_workflow_definition(self, account_id, template_id, **kwargs): 5563 """ 5564 Delete the workflow definition for a template. 5565 Deletes the specified template's workflow definition if it has one. 5566 This method makes a synchronous HTTP request by default. To make an 5567 asynchronous HTTP request, please define a `callback` function 5568 to be invoked when receiving the response. 5569 >>> def callback_function(response): 5570 >>> pprint(response) 5571 >>> 5572 >>> thread = api.delete_template_workflow_definition(account_id, template_id, callback=callback_function) 5573 5574 :param callback function: The callback function 5575 for asynchronous request. (optional) 5576 :param str account_id: The external account number (int) or account ID Guid. (required) 5577 :param str template_id: The ID of the template being accessed. (required) 5578 :return: None 5579 If the method is called asynchronously, 5580 returns the request thread. 5581 """ 5582 kwargs['_return_http_data_only'] = True 5583 if kwargs.get('callback'): 5584 return self.delete_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 5585 else: 5586 (data) = self.delete_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 5587 return data 5588 5589 def delete_template_workflow_definition_with_http_info(self, account_id, template_id, **kwargs): 5590 """ 5591 Delete the workflow definition for a template. 5592 Deletes the specified template's workflow definition if it has one. 5593 This method makes a synchronous HTTP request by default. To make an 5594 asynchronous HTTP request, please define a `callback` function 5595 to be invoked when receiving the response. 5596 >>> def callback_function(response): 5597 >>> pprint(response) 5598 >>> 5599 >>> thread = api.delete_template_workflow_definition_with_http_info(account_id, template_id, callback=callback_function) 5600 5601 :param callback function: The callback function 5602 for asynchronous request. (optional) 5603 :param str account_id: The external account number (int) or account ID Guid. (required) 5604 :param str template_id: The ID of the template being accessed. (required) 5605 :return: None 5606 If the method is called asynchronously, 5607 returns the request thread. 5608 """ 5609 5610 all_params = ['account_id', 'template_id'] 5611 all_params.append('callback') 5612 all_params.append('_return_http_data_only') 5613 all_params.append('_preload_content') 5614 all_params.append('_request_timeout') 5615 5616 params = locals() 5617 for key, val in iteritems(params['kwargs']): 5618 if key not in all_params: 5619 raise TypeError( 5620 "Got an unexpected keyword argument '%s'" 5621 " to method delete_template_workflow_definition" % key 5622 ) 5623 params[key] = val 5624 del params['kwargs'] 5625 # verify the required parameter 'account_id' is set 5626 if ('account_id' not in params) or (params['account_id'] is None): 5627 raise ValueError("Missing the required parameter `account_id` when calling `delete_template_workflow_definition`") 5628 # verify the required parameter 'template_id' is set 5629 if ('template_id' not in params) or (params['template_id'] is None): 5630 raise ValueError("Missing the required parameter `template_id` when calling `delete_template_workflow_definition`") 5631 5632 5633 collection_formats = {} 5634 5635 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow'.replace('{format}', 'json') 5636 path_params = {} 5637 if 'account_id' in params: 5638 path_params['accountId'] = params['account_id'] 5639 if 'template_id' in params: 5640 path_params['templateId'] = params['template_id'] 5641 5642 query_params = {} 5643 5644 header_params = {} 5645 5646 form_params = [] 5647 local_var_files = {} 5648 5649 body_params = None 5650 # HTTP header `Accept` 5651 header_params['Accept'] = self.api_client.\ 5652 select_header_accept(['application/json']) 5653 5654 # Authentication setting 5655 auth_settings = [] 5656 5657 return self.api_client.call_api(resource_path, 'DELETE', 5658 path_params, 5659 query_params, 5660 header_params, 5661 body=body_params, 5662 post_params=form_params, 5663 files=local_var_files, 5664 response_type=None, 5665 auth_settings=auth_settings, 5666 callback=params.get('callback'), 5667 _return_http_data_only=params.get('_return_http_data_only'), 5668 _preload_content=params.get('_preload_content', True), 5669 _request_timeout=params.get('_request_timeout'), 5670 collection_formats=collection_formats) 5671 5672 def delete_template_workflow_step_definition(self, account_id, template_id, workflow_step_id, **kwargs): 5673 """ 5674 Deletes the workflow step definition for an template's workflow by step id. 5675 This method makes a synchronous HTTP request by default. To make an 5676 asynchronous HTTP request, please define a `callback` function 5677 to be invoked when receiving the response. 5678 >>> def callback_function(response): 5679 >>> pprint(response) 5680 >>> 5681 >>> thread = api.delete_template_workflow_step_definition(account_id, template_id, workflow_step_id, callback=callback_function) 5682 5683 :param callback function: The callback function 5684 for asynchronous request. (optional) 5685 :param str account_id: The external account number (int) or account ID Guid. (required) 5686 :param str template_id: The ID of the template being accessed. (required) 5687 :param str workflow_step_id: (required) 5688 :return: None 5689 If the method is called asynchronously, 5690 returns the request thread. 5691 """ 5692 kwargs['_return_http_data_only'] = True 5693 if kwargs.get('callback'): 5694 return self.delete_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 5695 else: 5696 (data) = self.delete_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 5697 return data 5698 5699 def delete_template_workflow_step_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 5700 """ 5701 Deletes the workflow step definition for an template's workflow by step id. 5702 This method makes a synchronous HTTP request by default. To make an 5703 asynchronous HTTP request, please define a `callback` function 5704 to be invoked when receiving the response. 5705 >>> def callback_function(response): 5706 >>> pprint(response) 5707 >>> 5708 >>> thread = api.delete_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 5709 5710 :param callback function: The callback function 5711 for asynchronous request. (optional) 5712 :param str account_id: The external account number (int) or account ID Guid. (required) 5713 :param str template_id: The ID of the template being accessed. (required) 5714 :param str workflow_step_id: (required) 5715 :return: None 5716 If the method is called asynchronously, 5717 returns the request thread. 5718 """ 5719 5720 all_params = ['account_id', 'template_id', 'workflow_step_id'] 5721 all_params.append('callback') 5722 all_params.append('_return_http_data_only') 5723 all_params.append('_preload_content') 5724 all_params.append('_request_timeout') 5725 5726 params = locals() 5727 for key, val in iteritems(params['kwargs']): 5728 if key not in all_params: 5729 raise TypeError( 5730 "Got an unexpected keyword argument '%s'" 5731 " to method delete_template_workflow_step_definition" % key 5732 ) 5733 params[key] = val 5734 del params['kwargs'] 5735 # verify the required parameter 'account_id' is set 5736 if ('account_id' not in params) or (params['account_id'] is None): 5737 raise ValueError("Missing the required parameter `account_id` when calling `delete_template_workflow_step_definition`") 5738 # verify the required parameter 'template_id' is set 5739 if ('template_id' not in params) or (params['template_id'] is None): 5740 raise ValueError("Missing the required parameter `template_id` when calling `delete_template_workflow_step_definition`") 5741 # verify the required parameter 'workflow_step_id' is set 5742 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 5743 raise ValueError("Missing the required parameter `workflow_step_id` when calling `delete_template_workflow_step_definition`") 5744 5745 5746 collection_formats = {} 5747 5748 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 5749 path_params = {} 5750 if 'account_id' in params: 5751 path_params['accountId'] = params['account_id'] 5752 if 'template_id' in params: 5753 path_params['templateId'] = params['template_id'] 5754 if 'workflow_step_id' in params: 5755 path_params['workflowStepId'] = params['workflow_step_id'] 5756 5757 query_params = {} 5758 5759 header_params = {} 5760 5761 form_params = [] 5762 local_var_files = {} 5763 5764 body_params = None 5765 # HTTP header `Accept` 5766 header_params['Accept'] = self.api_client.\ 5767 select_header_accept(['application/json']) 5768 5769 # Authentication setting 5770 auth_settings = [] 5771 5772 return self.api_client.call_api(resource_path, 'DELETE', 5773 path_params, 5774 query_params, 5775 header_params, 5776 body=body_params, 5777 post_params=form_params, 5778 files=local_var_files, 5779 response_type=None, 5780 auth_settings=auth_settings, 5781 callback=params.get('callback'), 5782 _return_http_data_only=params.get('_return_http_data_only'), 5783 _preload_content=params.get('_preload_content', True), 5784 _request_timeout=params.get('_request_timeout'), 5785 collection_formats=collection_formats) 5786 5787 def delete_templates_from_document(self, account_id, document_id, envelope_id, template_id, **kwargs): 5788 """ 5789 Deletes a template from a document in an existing envelope. 5790 Deletes the specified template from a document in an existing envelope. 5791 This method makes a synchronous HTTP request by default. To make an 5792 asynchronous HTTP request, please define a `callback` function 5793 to be invoked when receiving the response. 5794 >>> def callback_function(response): 5795 >>> pprint(response) 5796 >>> 5797 >>> thread = api.delete_templates_from_document(account_id, document_id, envelope_id, template_id, callback=callback_function) 5798 5799 :param callback function: The callback function 5800 for asynchronous request. (optional) 5801 :param str account_id: The external account number (int) or account ID Guid. (required) 5802 :param str document_id: The ID of the document being accessed. (required) 5803 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5804 :param str template_id: The ID of the template being accessed. (required) 5805 :return: None 5806 If the method is called asynchronously, 5807 returns the request thread. 5808 """ 5809 kwargs['_return_http_data_only'] = True 5810 if kwargs.get('callback'): 5811 return self.delete_templates_from_document_with_http_info(account_id, document_id, envelope_id, template_id, **kwargs) 5812 else: 5813 (data) = self.delete_templates_from_document_with_http_info(account_id, document_id, envelope_id, template_id, **kwargs) 5814 return data 5815 5816 def delete_templates_from_document_with_http_info(self, account_id, document_id, envelope_id, template_id, **kwargs): 5817 """ 5818 Deletes a template from a document in an existing envelope. 5819 Deletes the specified template from a document in an existing envelope. 5820 This method makes a synchronous HTTP request by default. To make an 5821 asynchronous HTTP request, please define a `callback` function 5822 to be invoked when receiving the response. 5823 >>> def callback_function(response): 5824 >>> pprint(response) 5825 >>> 5826 >>> thread = api.delete_templates_from_document_with_http_info(account_id, document_id, envelope_id, template_id, callback=callback_function) 5827 5828 :param callback function: The callback function 5829 for asynchronous request. (optional) 5830 :param str account_id: The external account number (int) or account ID Guid. (required) 5831 :param str document_id: The ID of the document being accessed. (required) 5832 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5833 :param str template_id: The ID of the template being accessed. (required) 5834 :return: None 5835 If the method is called asynchronously, 5836 returns the request thread. 5837 """ 5838 5839 all_params = ['account_id', 'document_id', 'envelope_id', 'template_id'] 5840 all_params.append('callback') 5841 all_params.append('_return_http_data_only') 5842 all_params.append('_preload_content') 5843 all_params.append('_request_timeout') 5844 5845 params = locals() 5846 for key, val in iteritems(params['kwargs']): 5847 if key not in all_params: 5848 raise TypeError( 5849 "Got an unexpected keyword argument '%s'" 5850 " to method delete_templates_from_document" % key 5851 ) 5852 params[key] = val 5853 del params['kwargs'] 5854 # verify the required parameter 'account_id' is set 5855 if ('account_id' not in params) or (params['account_id'] is None): 5856 raise ValueError("Missing the required parameter `account_id` when calling `delete_templates_from_document`") 5857 # verify the required parameter 'document_id' is set 5858 if ('document_id' not in params) or (params['document_id'] is None): 5859 raise ValueError("Missing the required parameter `document_id` when calling `delete_templates_from_document`") 5860 # verify the required parameter 'envelope_id' is set 5861 if ('envelope_id' not in params) or (params['envelope_id'] is None): 5862 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_templates_from_document`") 5863 # verify the required parameter 'template_id' is set 5864 if ('template_id' not in params) or (params['template_id'] is None): 5865 raise ValueError("Missing the required parameter `template_id` when calling `delete_templates_from_document`") 5866 5867 5868 collection_formats = {} 5869 5870 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/templates/{templateId}'.replace('{format}', 'json') 5871 path_params = {} 5872 if 'account_id' in params: 5873 path_params['accountId'] = params['account_id'] 5874 if 'document_id' in params: 5875 path_params['documentId'] = params['document_id'] 5876 if 'envelope_id' in params: 5877 path_params['envelopeId'] = params['envelope_id'] 5878 if 'template_id' in params: 5879 path_params['templateId'] = params['template_id'] 5880 5881 query_params = {} 5882 5883 header_params = {} 5884 5885 form_params = [] 5886 local_var_files = {} 5887 5888 body_params = None 5889 # HTTP header `Accept` 5890 header_params['Accept'] = self.api_client.\ 5891 select_header_accept(['application/json']) 5892 5893 # Authentication setting 5894 auth_settings = [] 5895 5896 return self.api_client.call_api(resource_path, 'DELETE', 5897 path_params, 5898 query_params, 5899 header_params, 5900 body=body_params, 5901 post_params=form_params, 5902 files=local_var_files, 5903 response_type=None, 5904 auth_settings=auth_settings, 5905 callback=params.get('callback'), 5906 _return_http_data_only=params.get('_return_http_data_only'), 5907 _preload_content=params.get('_preload_content', True), 5908 _request_timeout=params.get('_request_timeout'), 5909 collection_formats=collection_formats) 5910 5911 def get_attachment(self, account_id, attachment_id, envelope_id, **kwargs): 5912 """ 5913 Retrieves an attachment from the envelope. 5914 Retrieves an attachment from an envelope. 5915 This method makes a synchronous HTTP request by default. To make an 5916 asynchronous HTTP request, please define a `callback` function 5917 to be invoked when receiving the response. 5918 >>> def callback_function(response): 5919 >>> pprint(response) 5920 >>> 5921 >>> thread = api.get_attachment(account_id, attachment_id, envelope_id, callback=callback_function) 5922 5923 :param callback function: The callback function 5924 for asynchronous request. (optional) 5925 :param str account_id: The external account number (int) or account ID Guid. (required) 5926 :param str attachment_id: (required) 5927 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5928 :return: None 5929 If the method is called asynchronously, 5930 returns the request thread. 5931 """ 5932 kwargs['_return_http_data_only'] = True 5933 if kwargs.get('callback'): 5934 return self.get_attachment_with_http_info(account_id, attachment_id, envelope_id, **kwargs) 5935 else: 5936 (data) = self.get_attachment_with_http_info(account_id, attachment_id, envelope_id, **kwargs) 5937 return data 5938 5939 def get_attachment_with_http_info(self, account_id, attachment_id, envelope_id, **kwargs): 5940 """ 5941 Retrieves an attachment from the envelope. 5942 Retrieves an attachment from an envelope. 5943 This method makes a synchronous HTTP request by default. To make an 5944 asynchronous HTTP request, please define a `callback` function 5945 to be invoked when receiving the response. 5946 >>> def callback_function(response): 5947 >>> pprint(response) 5948 >>> 5949 >>> thread = api.get_attachment_with_http_info(account_id, attachment_id, envelope_id, callback=callback_function) 5950 5951 :param callback function: The callback function 5952 for asynchronous request. (optional) 5953 :param str account_id: The external account number (int) or account ID Guid. (required) 5954 :param str attachment_id: (required) 5955 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5956 :return: None 5957 If the method is called asynchronously, 5958 returns the request thread. 5959 """ 5960 5961 all_params = ['account_id', 'attachment_id', 'envelope_id'] 5962 all_params.append('callback') 5963 all_params.append('_return_http_data_only') 5964 all_params.append('_preload_content') 5965 all_params.append('_request_timeout') 5966 5967 params = locals() 5968 for key, val in iteritems(params['kwargs']): 5969 if key not in all_params: 5970 raise TypeError( 5971 "Got an unexpected keyword argument '%s'" 5972 " to method get_attachment" % key 5973 ) 5974 params[key] = val 5975 del params['kwargs'] 5976 # verify the required parameter 'account_id' is set 5977 if ('account_id' not in params) or (params['account_id'] is None): 5978 raise ValueError("Missing the required parameter `account_id` when calling `get_attachment`") 5979 # verify the required parameter 'attachment_id' is set 5980 if ('attachment_id' not in params) or (params['attachment_id'] is None): 5981 raise ValueError("Missing the required parameter `attachment_id` when calling `get_attachment`") 5982 # verify the required parameter 'envelope_id' is set 5983 if ('envelope_id' not in params) or (params['envelope_id'] is None): 5984 raise ValueError("Missing the required parameter `envelope_id` when calling `get_attachment`") 5985 5986 5987 collection_formats = {} 5988 5989 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments/{attachmentId}'.replace('{format}', 'json') 5990 path_params = {} 5991 if 'account_id' in params: 5992 path_params['accountId'] = params['account_id'] 5993 if 'attachment_id' in params: 5994 path_params['attachmentId'] = params['attachment_id'] 5995 if 'envelope_id' in params: 5996 path_params['envelopeId'] = params['envelope_id'] 5997 5998 query_params = {} 5999 6000 header_params = {} 6001 6002 form_params = [] 6003 local_var_files = {} 6004 6005 body_params = None 6006 # HTTP header `Accept` 6007 header_params['Accept'] = self.api_client.\ 6008 select_header_accept(['application/json']) 6009 6010 # Authentication setting 6011 auth_settings = [] 6012 6013 return self.api_client.call_api(resource_path, 'GET', 6014 path_params, 6015 query_params, 6016 header_params, 6017 body=body_params, 6018 post_params=form_params, 6019 files=local_var_files, 6020 response_type=None, 6021 auth_settings=auth_settings, 6022 callback=params.get('callback'), 6023 _return_http_data_only=params.get('_return_http_data_only'), 6024 _preload_content=params.get('_preload_content', True), 6025 _request_timeout=params.get('_request_timeout'), 6026 collection_formats=collection_formats) 6027 6028 def get_attachments(self, account_id, envelope_id, **kwargs): 6029 """ 6030 Returns a list of attachments associated with the specified envelope 6031 Returns a list of attachments associated with a specified envelope 6032 This method makes a synchronous HTTP request by default. To make an 6033 asynchronous HTTP request, please define a `callback` function 6034 to be invoked when receiving the response. 6035 >>> def callback_function(response): 6036 >>> pprint(response) 6037 >>> 6038 >>> thread = api.get_attachments(account_id, envelope_id, callback=callback_function) 6039 6040 :param callback function: The callback function 6041 for asynchronous request. (optional) 6042 :param str account_id: The external account number (int) or account ID Guid. (required) 6043 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6044 :return: EnvelopeAttachmentsResult 6045 If the method is called asynchronously, 6046 returns the request thread. 6047 """ 6048 kwargs['_return_http_data_only'] = True 6049 if kwargs.get('callback'): 6050 return self.get_attachments_with_http_info(account_id, envelope_id, **kwargs) 6051 else: 6052 (data) = self.get_attachments_with_http_info(account_id, envelope_id, **kwargs) 6053 return data 6054 6055 def get_attachments_with_http_info(self, account_id, envelope_id, **kwargs): 6056 """ 6057 Returns a list of attachments associated with the specified envelope 6058 Returns a list of attachments associated with a specified envelope 6059 This method makes a synchronous HTTP request by default. To make an 6060 asynchronous HTTP request, please define a `callback` function 6061 to be invoked when receiving the response. 6062 >>> def callback_function(response): 6063 >>> pprint(response) 6064 >>> 6065 >>> thread = api.get_attachments_with_http_info(account_id, envelope_id, callback=callback_function) 6066 6067 :param callback function: The callback function 6068 for asynchronous request. (optional) 6069 :param str account_id: The external account number (int) or account ID Guid. (required) 6070 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6071 :return: EnvelopeAttachmentsResult 6072 If the method is called asynchronously, 6073 returns the request thread. 6074 """ 6075 6076 all_params = ['account_id', 'envelope_id'] 6077 all_params.append('callback') 6078 all_params.append('_return_http_data_only') 6079 all_params.append('_preload_content') 6080 all_params.append('_request_timeout') 6081 6082 params = locals() 6083 for key, val in iteritems(params['kwargs']): 6084 if key not in all_params: 6085 raise TypeError( 6086 "Got an unexpected keyword argument '%s'" 6087 " to method get_attachments" % key 6088 ) 6089 params[key] = val 6090 del params['kwargs'] 6091 # verify the required parameter 'account_id' is set 6092 if ('account_id' not in params) or (params['account_id'] is None): 6093 raise ValueError("Missing the required parameter `account_id` when calling `get_attachments`") 6094 # verify the required parameter 'envelope_id' is set 6095 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6096 raise ValueError("Missing the required parameter `envelope_id` when calling `get_attachments`") 6097 6098 6099 collection_formats = {} 6100 6101 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments'.replace('{format}', 'json') 6102 path_params = {} 6103 if 'account_id' in params: 6104 path_params['accountId'] = params['account_id'] 6105 if 'envelope_id' in params: 6106 path_params['envelopeId'] = params['envelope_id'] 6107 6108 query_params = {} 6109 6110 header_params = {} 6111 6112 form_params = [] 6113 local_var_files = {} 6114 6115 body_params = None 6116 # HTTP header `Accept` 6117 header_params['Accept'] = self.api_client.\ 6118 select_header_accept(['application/json']) 6119 6120 # Authentication setting 6121 auth_settings = [] 6122 6123 return self.api_client.call_api(resource_path, 'GET', 6124 path_params, 6125 query_params, 6126 header_params, 6127 body=body_params, 6128 post_params=form_params, 6129 files=local_var_files, 6130 response_type='EnvelopeAttachmentsResult', 6131 auth_settings=auth_settings, 6132 callback=params.get('callback'), 6133 _return_http_data_only=params.get('_return_http_data_only'), 6134 _preload_content=params.get('_preload_content', True), 6135 _request_timeout=params.get('_request_timeout'), 6136 collection_formats=collection_formats) 6137 6138 def get_chunked_upload(self, account_id, chunked_upload_id, **kwargs): 6139 """ 6140 Retrieves the current metadata of a ChunkedUpload. 6141 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. 6142 This method makes a synchronous HTTP request by default. To make an 6143 asynchronous HTTP request, please define a `callback` function 6144 to be invoked when receiving the response. 6145 >>> def callback_function(response): 6146 >>> pprint(response) 6147 >>> 6148 >>> thread = api.get_chunked_upload(account_id, chunked_upload_id, callback=callback_function) 6149 6150 :param callback function: The callback function 6151 for asynchronous request. (optional) 6152 :param str account_id: The external account number (int) or account ID Guid. (required) 6153 :param str chunked_upload_id: (required) 6154 :param str include: 6155 :return: ChunkedUploadResponse 6156 If the method is called asynchronously, 6157 returns the request thread. 6158 """ 6159 kwargs['_return_http_data_only'] = True 6160 if kwargs.get('callback'): 6161 return self.get_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 6162 else: 6163 (data) = self.get_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 6164 return data 6165 6166 def get_chunked_upload_with_http_info(self, account_id, chunked_upload_id, **kwargs): 6167 """ 6168 Retrieves the current metadata of a ChunkedUpload. 6169 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. 6170 This method makes a synchronous HTTP request by default. To make an 6171 asynchronous HTTP request, please define a `callback` function 6172 to be invoked when receiving the response. 6173 >>> def callback_function(response): 6174 >>> pprint(response) 6175 >>> 6176 >>> thread = api.get_chunked_upload_with_http_info(account_id, chunked_upload_id, callback=callback_function) 6177 6178 :param callback function: The callback function 6179 for asynchronous request. (optional) 6180 :param str account_id: The external account number (int) or account ID Guid. (required) 6181 :param str chunked_upload_id: (required) 6182 :param str include: 6183 :return: ChunkedUploadResponse 6184 If the method is called asynchronously, 6185 returns the request thread. 6186 """ 6187 6188 all_params = ['account_id', 'chunked_upload_id', 'include'] 6189 all_params.append('callback') 6190 all_params.append('_return_http_data_only') 6191 all_params.append('_preload_content') 6192 all_params.append('_request_timeout') 6193 6194 params = locals() 6195 for key, val in iteritems(params['kwargs']): 6196 if key not in all_params: 6197 raise TypeError( 6198 "Got an unexpected keyword argument '%s'" 6199 " to method get_chunked_upload" % key 6200 ) 6201 params[key] = val 6202 del params['kwargs'] 6203 # verify the required parameter 'account_id' is set 6204 if ('account_id' not in params) or (params['account_id'] is None): 6205 raise ValueError("Missing the required parameter `account_id` when calling `get_chunked_upload`") 6206 # verify the required parameter 'chunked_upload_id' is set 6207 if ('chunked_upload_id' not in params) or (params['chunked_upload_id'] is None): 6208 raise ValueError("Missing the required parameter `chunked_upload_id` when calling `get_chunked_upload`") 6209 6210 6211 collection_formats = {} 6212 6213 resource_path = '/v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}'.replace('{format}', 'json') 6214 path_params = {} 6215 if 'account_id' in params: 6216 path_params['accountId'] = params['account_id'] 6217 if 'chunked_upload_id' in params: 6218 path_params['chunkedUploadId'] = params['chunked_upload_id'] 6219 6220 query_params = {} 6221 if 'include' in params: 6222 query_params['include'] = params['include'] 6223 6224 header_params = {} 6225 6226 form_params = [] 6227 local_var_files = {} 6228 6229 body_params = None 6230 # HTTP header `Accept` 6231 header_params['Accept'] = self.api_client.\ 6232 select_header_accept(['application/json']) 6233 6234 # Authentication setting 6235 auth_settings = [] 6236 6237 return self.api_client.call_api(resource_path, 'GET', 6238 path_params, 6239 query_params, 6240 header_params, 6241 body=body_params, 6242 post_params=form_params, 6243 files=local_var_files, 6244 response_type='ChunkedUploadResponse', 6245 auth_settings=auth_settings, 6246 callback=params.get('callback'), 6247 _return_http_data_only=params.get('_return_http_data_only'), 6248 _preload_content=params.get('_preload_content', True), 6249 _request_timeout=params.get('_request_timeout'), 6250 collection_formats=collection_formats) 6251 6252 def get_comments_transcript(self, account_id, envelope_id, **kwargs): 6253 """ 6254 Gets comment transcript for envelope and user 6255 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**). 6256 This method makes a synchronous HTTP request by default. To make an 6257 asynchronous HTTP request, please define a `callback` function 6258 to be invoked when receiving the response. 6259 >>> def callback_function(response): 6260 >>> pprint(response) 6261 >>> 6262 >>> thread = api.get_comments_transcript(account_id, envelope_id, callback=callback_function) 6263 6264 :param callback function: The callback function 6265 for asynchronous request. (optional) 6266 :param str account_id: The external account number (int) or account ID Guid. (required) 6267 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6268 :param str encoding: 6269 :return: file 6270 If the method is called asynchronously, 6271 returns the request thread. 6272 """ 6273 kwargs['_return_http_data_only'] = True 6274 if kwargs.get('callback'): 6275 return self.get_comments_transcript_with_http_info(account_id, envelope_id, **kwargs) 6276 else: 6277 (data) = self.get_comments_transcript_with_http_info(account_id, envelope_id, **kwargs) 6278 return data 6279 6280 def get_comments_transcript_with_http_info(self, account_id, envelope_id, **kwargs): 6281 """ 6282 Gets comment transcript for envelope and user 6283 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**). 6284 This method makes a synchronous HTTP request by default. To make an 6285 asynchronous HTTP request, please define a `callback` function 6286 to be invoked when receiving the response. 6287 >>> def callback_function(response): 6288 >>> pprint(response) 6289 >>> 6290 >>> thread = api.get_comments_transcript_with_http_info(account_id, envelope_id, callback=callback_function) 6291 6292 :param callback function: The callback function 6293 for asynchronous request. (optional) 6294 :param str account_id: The external account number (int) or account ID Guid. (required) 6295 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6296 :param str encoding: 6297 :return: file 6298 If the method is called asynchronously, 6299 returns the request thread. 6300 """ 6301 6302 all_params = ['account_id', 'envelope_id', 'encoding'] 6303 all_params.append('callback') 6304 all_params.append('_return_http_data_only') 6305 all_params.append('_preload_content') 6306 all_params.append('_request_timeout') 6307 6308 params = locals() 6309 for key, val in iteritems(params['kwargs']): 6310 if key not in all_params: 6311 raise TypeError( 6312 "Got an unexpected keyword argument '%s'" 6313 " to method get_comments_transcript" % key 6314 ) 6315 params[key] = val 6316 del params['kwargs'] 6317 # verify the required parameter 'account_id' is set 6318 if ('account_id' not in params) or (params['account_id'] is None): 6319 raise ValueError("Missing the required parameter `account_id` when calling `get_comments_transcript`") 6320 # verify the required parameter 'envelope_id' is set 6321 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6322 raise ValueError("Missing the required parameter `envelope_id` when calling `get_comments_transcript`") 6323 6324 6325 collection_formats = {} 6326 6327 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/comments/transcript'.replace('{format}', 'json') 6328 path_params = {} 6329 if 'account_id' in params: 6330 path_params['accountId'] = params['account_id'] 6331 if 'envelope_id' in params: 6332 path_params['envelopeId'] = params['envelope_id'] 6333 6334 query_params = {} 6335 if 'encoding' in params: 6336 query_params['encoding'] = params['encoding'] 6337 6338 header_params = {} 6339 6340 form_params = [] 6341 local_var_files = {} 6342 6343 body_params = None 6344 # HTTP header `Accept` 6345 header_params['Accept'] = self.api_client.\ 6346 select_header_accept(['application/pdf']) 6347 6348 # Authentication setting 6349 auth_settings = [] 6350 6351 return self.api_client.call_api(resource_path, 'GET', 6352 path_params, 6353 query_params, 6354 header_params, 6355 body=body_params, 6356 post_params=form_params, 6357 files=local_var_files, 6358 response_type='file', 6359 auth_settings=auth_settings, 6360 callback=params.get('callback'), 6361 _return_http_data_only=params.get('_return_http_data_only'), 6362 _preload_content=params.get('_preload_content', True), 6363 _request_timeout=params.get('_request_timeout'), 6364 collection_formats=collection_formats) 6365 6366 def get_consumer_disclosure(self, account_id, envelope_id, lang_code, recipient_id, **kwargs): 6367 """ 6368 Reserved: Gets the Electronic Record and Signature Disclosure associated with the account. 6369 Reserved: Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, associated with the account. 6370 This method makes a synchronous HTTP request by default. To make an 6371 asynchronous HTTP request, please define a `callback` function 6372 to be invoked when receiving the response. 6373 >>> def callback_function(response): 6374 >>> pprint(response) 6375 >>> 6376 >>> thread = api.get_consumer_disclosure(account_id, envelope_id, lang_code, recipient_id, callback=callback_function) 6377 6378 :param callback function: The callback function 6379 for asynchronous request. (optional) 6380 :param str account_id: The external account number (int) or account ID Guid. (required) 6381 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6382 :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), 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) 6383 :param str recipient_id: The ID of the recipient being accessed. (required) 6384 :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. 6385 :return: ConsumerDisclosure 6386 If the method is called asynchronously, 6387 returns the request thread. 6388 """ 6389 kwargs['_return_http_data_only'] = True 6390 if kwargs.get('callback'): 6391 return self.get_consumer_disclosure_with_http_info(account_id, envelope_id, lang_code, recipient_id, **kwargs) 6392 else: 6393 (data) = self.get_consumer_disclosure_with_http_info(account_id, envelope_id, lang_code, recipient_id, **kwargs) 6394 return data 6395 6396 def get_consumer_disclosure_with_http_info(self, account_id, envelope_id, lang_code, recipient_id, **kwargs): 6397 """ 6398 Reserved: Gets the Electronic Record and Signature Disclosure associated with the account. 6399 Reserved: Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, associated with the account. 6400 This method makes a synchronous HTTP request by default. To make an 6401 asynchronous HTTP request, please define a `callback` function 6402 to be invoked when receiving the response. 6403 >>> def callback_function(response): 6404 >>> pprint(response) 6405 >>> 6406 >>> thread = api.get_consumer_disclosure_with_http_info(account_id, envelope_id, lang_code, recipient_id, callback=callback_function) 6407 6408 :param callback function: The callback function 6409 for asynchronous request. (optional) 6410 :param str account_id: The external account number (int) or account ID Guid. (required) 6411 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6412 :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), 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) 6413 :param str recipient_id: The ID of the recipient being accessed. (required) 6414 :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. 6415 :return: ConsumerDisclosure 6416 If the method is called asynchronously, 6417 returns the request thread. 6418 """ 6419 6420 all_params = ['account_id', 'envelope_id', 'lang_code', 'recipient_id', 'lang_code2'] 6421 all_params.append('callback') 6422 all_params.append('_return_http_data_only') 6423 all_params.append('_preload_content') 6424 all_params.append('_request_timeout') 6425 6426 params = locals() 6427 for key, val in iteritems(params['kwargs']): 6428 if key not in all_params: 6429 raise TypeError( 6430 "Got an unexpected keyword argument '%s'" 6431 " to method get_consumer_disclosure" % key 6432 ) 6433 params[key] = val 6434 del params['kwargs'] 6435 # verify the required parameter 'account_id' is set 6436 if ('account_id' not in params) or (params['account_id'] is None): 6437 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure`") 6438 # verify the required parameter 'envelope_id' is set 6439 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6440 raise ValueError("Missing the required parameter `envelope_id` when calling `get_consumer_disclosure`") 6441 # verify the required parameter 'lang_code' is set 6442 if ('lang_code' not in params) or (params['lang_code'] is None): 6443 raise ValueError("Missing the required parameter `lang_code` when calling `get_consumer_disclosure`") 6444 # verify the required parameter 'recipient_id' is set 6445 if ('recipient_id' not in params) or (params['recipient_id'] is None): 6446 raise ValueError("Missing the required parameter `recipient_id` when calling `get_consumer_disclosure`") 6447 6448 6449 collection_formats = {} 6450 6451 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 6452 path_params = {} 6453 if 'account_id' in params: 6454 path_params['accountId'] = params['account_id'] 6455 if 'envelope_id' in params: 6456 path_params['envelopeId'] = params['envelope_id'] 6457 if 'lang_code' in params: 6458 path_params['langCode'] = params['lang_code'] 6459 if 'recipient_id' in params: 6460 path_params['recipientId'] = params['recipient_id'] 6461 6462 query_params = {} 6463 if 'lang_code2' in params: 6464 query_params['langCode'] = params['lang_code2'] 6465 6466 header_params = {} 6467 6468 form_params = [] 6469 local_var_files = {} 6470 6471 body_params = None 6472 # HTTP header `Accept` 6473 header_params['Accept'] = self.api_client.\ 6474 select_header_accept(['application/json']) 6475 6476 # Authentication setting 6477 auth_settings = [] 6478 6479 return self.api_client.call_api(resource_path, 'GET', 6480 path_params, 6481 query_params, 6482 header_params, 6483 body=body_params, 6484 post_params=form_params, 6485 files=local_var_files, 6486 response_type='ConsumerDisclosure', 6487 auth_settings=auth_settings, 6488 callback=params.get('callback'), 6489 _return_http_data_only=params.get('_return_http_data_only'), 6490 _preload_content=params.get('_preload_content', True), 6491 _request_timeout=params.get('_request_timeout'), 6492 collection_formats=collection_formats) 6493 6494 def get_consumer_disclosure_default(self, account_id, envelope_id, recipient_id, **kwargs): 6495 """ 6496 Gets the Electronic Record and Signature Disclosure associated with the account. 6497 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. 6498 This method makes a synchronous HTTP request by default. To make an 6499 asynchronous HTTP request, please define a `callback` function 6500 to be invoked when receiving the response. 6501 >>> def callback_function(response): 6502 >>> pprint(response) 6503 >>> 6504 >>> thread = api.get_consumer_disclosure_default(account_id, envelope_id, recipient_id, callback=callback_function) 6505 6506 :param callback function: The callback function 6507 for asynchronous request. (optional) 6508 :param str account_id: The external account number (int) or account ID Guid. (required) 6509 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6510 :param str recipient_id: The ID of the recipient being accessed. (required) 6511 :param str lang_code: 6512 :return: ConsumerDisclosure 6513 If the method is called asynchronously, 6514 returns the request thread. 6515 """ 6516 kwargs['_return_http_data_only'] = True 6517 if kwargs.get('callback'): 6518 return self.get_consumer_disclosure_default_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 6519 else: 6520 (data) = self.get_consumer_disclosure_default_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 6521 return data 6522 6523 def get_consumer_disclosure_default_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 6524 """ 6525 Gets the Electronic Record and Signature Disclosure associated with the account. 6526 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. 6527 This method makes a synchronous HTTP request by default. To make an 6528 asynchronous HTTP request, please define a `callback` function 6529 to be invoked when receiving the response. 6530 >>> def callback_function(response): 6531 >>> pprint(response) 6532 >>> 6533 >>> thread = api.get_consumer_disclosure_default_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 6534 6535 :param callback function: The callback function 6536 for asynchronous request. (optional) 6537 :param str account_id: The external account number (int) or account ID Guid. (required) 6538 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6539 :param str recipient_id: The ID of the recipient being accessed. (required) 6540 :param str lang_code: 6541 :return: ConsumerDisclosure 6542 If the method is called asynchronously, 6543 returns the request thread. 6544 """ 6545 6546 all_params = ['account_id', 'envelope_id', 'recipient_id', 'lang_code'] 6547 all_params.append('callback') 6548 all_params.append('_return_http_data_only') 6549 all_params.append('_preload_content') 6550 all_params.append('_request_timeout') 6551 6552 params = locals() 6553 for key, val in iteritems(params['kwargs']): 6554 if key not in all_params: 6555 raise TypeError( 6556 "Got an unexpected keyword argument '%s'" 6557 " to method get_consumer_disclosure_default" % key 6558 ) 6559 params[key] = val 6560 del params['kwargs'] 6561 # verify the required parameter 'account_id' is set 6562 if ('account_id' not in params) or (params['account_id'] is None): 6563 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure_default`") 6564 # verify the required parameter 'envelope_id' is set 6565 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6566 raise ValueError("Missing the required parameter `envelope_id` when calling `get_consumer_disclosure_default`") 6567 # verify the required parameter 'recipient_id' is set 6568 if ('recipient_id' not in params) or (params['recipient_id'] is None): 6569 raise ValueError("Missing the required parameter `recipient_id` when calling `get_consumer_disclosure_default`") 6570 6571 6572 collection_formats = {} 6573 6574 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/consumer_disclosure'.replace('{format}', 'json') 6575 path_params = {} 6576 if 'account_id' in params: 6577 path_params['accountId'] = params['account_id'] 6578 if 'envelope_id' in params: 6579 path_params['envelopeId'] = params['envelope_id'] 6580 if 'recipient_id' in params: 6581 path_params['recipientId'] = params['recipient_id'] 6582 6583 query_params = {} 6584 if 'lang_code' in params: 6585 query_params['langCode'] = params['lang_code'] 6586 6587 header_params = {} 6588 6589 form_params = [] 6590 local_var_files = {} 6591 6592 body_params = None 6593 # HTTP header `Accept` 6594 header_params['Accept'] = self.api_client.\ 6595 select_header_accept(['application/json']) 6596 6597 # Authentication setting 6598 auth_settings = [] 6599 6600 return self.api_client.call_api(resource_path, 'GET', 6601 path_params, 6602 query_params, 6603 header_params, 6604 body=body_params, 6605 post_params=form_params, 6606 files=local_var_files, 6607 response_type='ConsumerDisclosure', 6608 auth_settings=auth_settings, 6609 callback=params.get('callback'), 6610 _return_http_data_only=params.get('_return_http_data_only'), 6611 _preload_content=params.get('_preload_content', True), 6612 _request_timeout=params.get('_request_timeout'), 6613 collection_formats=collection_formats) 6614 6615 def get_document(self, account_id, document_id, envelope_id, **kwargs): 6616 """ 6617 Gets a document from an envelope. 6618 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 6619 This method makes a synchronous HTTP request by default. To make an 6620 asynchronous HTTP request, please define a `callback` function 6621 to be invoked when receiving the response. 6622 >>> def callback_function(response): 6623 >>> pprint(response) 6624 >>> 6625 >>> thread = api.get_document(account_id, document_id, envelope_id, callback=callback_function) 6626 6627 :param callback function: The callback function 6628 for asynchronous request. (optional) 6629 :param str account_id: The external account number (int) or account ID Guid. (required) 6630 :param str document_id: The ID of the document being accessed. (required) 6631 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6632 :param str certificate: When set to **false**, the envelope signing certificate is removed from the download. 6633 :param str documents_by_userid: 6634 :param str encoding: 6635 :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. 6636 :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). 6637 :param str recipient_id: 6638 :param str shared_user_id: 6639 :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. 6640 :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. 6641 :return: file 6642 If the method is called asynchronously, 6643 returns the request thread. 6644 """ 6645 kwargs['_return_http_data_only'] = True 6646 if kwargs.get('callback'): 6647 return self.get_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 6648 else: 6649 (data) = self.get_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 6650 return data 6651 6652 def get_document_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 6653 """ 6654 Gets a document from an envelope. 6655 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 6656 This method makes a synchronous HTTP request by default. To make an 6657 asynchronous HTTP request, please define a `callback` function 6658 to be invoked when receiving the response. 6659 >>> def callback_function(response): 6660 >>> pprint(response) 6661 >>> 6662 >>> thread = api.get_document_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 6663 6664 :param callback function: The callback function 6665 for asynchronous request. (optional) 6666 :param str account_id: The external account number (int) or account ID Guid. (required) 6667 :param str document_id: The ID of the document being accessed. (required) 6668 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6669 :param str certificate: When set to **false**, the envelope signing certificate is removed from the download. 6670 :param str documents_by_userid: 6671 :param str encoding: 6672 :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. 6673 :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). 6674 :param str recipient_id: 6675 :param str shared_user_id: 6676 :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. 6677 :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. 6678 :return: file 6679 If the method is called asynchronously, 6680 returns the request thread. 6681 """ 6682 6683 all_params = ['account_id', 'document_id', 'envelope_id', 'certificate', 'documents_by_userid', 'encoding', 'encrypt', 'language', 'recipient_id', 'shared_user_id', 'show_changes', 'watermark'] 6684 all_params.append('callback') 6685 all_params.append('_return_http_data_only') 6686 all_params.append('_preload_content') 6687 all_params.append('_request_timeout') 6688 6689 params = locals() 6690 for key, val in iteritems(params['kwargs']): 6691 if key not in all_params: 6692 raise TypeError( 6693 "Got an unexpected keyword argument '%s'" 6694 " to method get_document" % key 6695 ) 6696 params[key] = val 6697 del params['kwargs'] 6698 # verify the required parameter 'account_id' is set 6699 if ('account_id' not in params) or (params['account_id'] is None): 6700 raise ValueError("Missing the required parameter `account_id` when calling `get_document`") 6701 # verify the required parameter 'document_id' is set 6702 if ('document_id' not in params) or (params['document_id'] is None): 6703 raise ValueError("Missing the required parameter `document_id` when calling `get_document`") 6704 # verify the required parameter 'envelope_id' is set 6705 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6706 raise ValueError("Missing the required parameter `envelope_id` when calling `get_document`") 6707 6708 6709 collection_formats = {} 6710 6711 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}'.replace('{format}', 'json') 6712 path_params = {} 6713 if 'account_id' in params: 6714 path_params['accountId'] = params['account_id'] 6715 if 'document_id' in params: 6716 path_params['documentId'] = params['document_id'] 6717 if 'envelope_id' in params: 6718 path_params['envelopeId'] = params['envelope_id'] 6719 6720 query_params = {} 6721 if 'certificate' in params: 6722 query_params['certificate'] = params['certificate'] 6723 if 'documents_by_userid' in params: 6724 query_params['documents_by_userid'] = params['documents_by_userid'] 6725 if 'encoding' in params: 6726 query_params['encoding'] = params['encoding'] 6727 if 'encrypt' in params: 6728 query_params['encrypt'] = params['encrypt'] 6729 if 'language' in params: 6730 query_params['language'] = params['language'] 6731 if 'recipient_id' in params: 6732 query_params['recipient_id'] = params['recipient_id'] 6733 if 'shared_user_id' in params: 6734 query_params['shared_user_id'] = params['shared_user_id'] 6735 if 'show_changes' in params: 6736 query_params['show_changes'] = params['show_changes'] 6737 if 'watermark' in params: 6738 query_params['watermark'] = params['watermark'] 6739 6740 header_params = {} 6741 6742 form_params = [] 6743 local_var_files = {} 6744 6745 body_params = None 6746 # HTTP header `Accept` 6747 header_params['Accept'] = self.api_client.\ 6748 select_header_accept(['application/pdf']) 6749 6750 # Authentication setting 6751 auth_settings = [] 6752 6753 return self.api_client.call_api(resource_path, 'GET', 6754 path_params, 6755 query_params, 6756 header_params, 6757 body=body_params, 6758 post_params=form_params, 6759 files=local_var_files, 6760 response_type='file', 6761 auth_settings=auth_settings, 6762 callback=params.get('callback'), 6763 _return_http_data_only=params.get('_return_http_data_only'), 6764 _preload_content=params.get('_preload_content', True), 6765 _request_timeout=params.get('_request_timeout'), 6766 collection_formats=collection_formats) 6767 6768 def get_document_page_image(self, account_id, document_id, envelope_id, page_number, **kwargs): 6769 """ 6770 Gets a page image from an envelope for display. 6771 Retrieves a page image for display from the specified envelope. 6772 This method makes a synchronous HTTP request by default. To make an 6773 asynchronous HTTP request, please define a `callback` function 6774 to be invoked when receiving the response. 6775 >>> def callback_function(response): 6776 >>> pprint(response) 6777 >>> 6778 >>> thread = api.get_document_page_image(account_id, document_id, envelope_id, page_number, callback=callback_function) 6779 6780 :param callback function: The callback function 6781 for asynchronous request. (optional) 6782 :param str account_id: The external account number (int) or account ID Guid. (required) 6783 :param str document_id: The ID of the document being accessed. (required) 6784 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6785 :param str page_number: The page number being accessed. (required) 6786 :param str dpi: Sets the dpi for the image. 6787 :param str max_height: Sets the maximum height for the page image in pixels. The dpi is recalculated based on this setting. 6788 :param str max_width: Sets the maximum width for the page image in pixels. The dpi is recalculated based on this setting. 6789 :param str show_changes: 6790 :return: file 6791 If the method is called asynchronously, 6792 returns the request thread. 6793 """ 6794 kwargs['_return_http_data_only'] = True 6795 if kwargs.get('callback'): 6796 return self.get_document_page_image_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 6797 else: 6798 (data) = self.get_document_page_image_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 6799 return data 6800 6801 def get_document_page_image_with_http_info(self, account_id, document_id, envelope_id, page_number, **kwargs): 6802 """ 6803 Gets a page image from an envelope for display. 6804 Retrieves a page image for display from the specified envelope. 6805 This method makes a synchronous HTTP request by default. To make an 6806 asynchronous HTTP request, please define a `callback` function 6807 to be invoked when receiving the response. 6808 >>> def callback_function(response): 6809 >>> pprint(response) 6810 >>> 6811 >>> thread = api.get_document_page_image_with_http_info(account_id, document_id, envelope_id, page_number, callback=callback_function) 6812 6813 :param callback function: The callback function 6814 for asynchronous request. (optional) 6815 :param str account_id: The external account number (int) or account ID Guid. (required) 6816 :param str document_id: The ID of the document being accessed. (required) 6817 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6818 :param str page_number: The page number being accessed. (required) 6819 :param str dpi: Sets the dpi for the image. 6820 :param str max_height: Sets the maximum height for the page image in pixels. The dpi is recalculated based on this setting. 6821 :param str max_width: Sets the maximum width for the page image in pixels. The dpi is recalculated based on this setting. 6822 :param str show_changes: 6823 :return: file 6824 If the method is called asynchronously, 6825 returns the request thread. 6826 """ 6827 6828 all_params = ['account_id', 'document_id', 'envelope_id', 'page_number', 'dpi', 'max_height', 'max_width', 'show_changes'] 6829 all_params.append('callback') 6830 all_params.append('_return_http_data_only') 6831 all_params.append('_preload_content') 6832 all_params.append('_request_timeout') 6833 6834 params = locals() 6835 for key, val in iteritems(params['kwargs']): 6836 if key not in all_params: 6837 raise TypeError( 6838 "Got an unexpected keyword argument '%s'" 6839 " to method get_document_page_image" % key 6840 ) 6841 params[key] = val 6842 del params['kwargs'] 6843 # verify the required parameter 'account_id' is set 6844 if ('account_id' not in params) or (params['account_id'] is None): 6845 raise ValueError("Missing the required parameter `account_id` when calling `get_document_page_image`") 6846 # verify the required parameter 'document_id' is set 6847 if ('document_id' not in params) or (params['document_id'] is None): 6848 raise ValueError("Missing the required parameter `document_id` when calling `get_document_page_image`") 6849 # verify the required parameter 'envelope_id' is set 6850 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6851 raise ValueError("Missing the required parameter `envelope_id` when calling `get_document_page_image`") 6852 # verify the required parameter 'page_number' is set 6853 if ('page_number' not in params) or (params['page_number'] is None): 6854 raise ValueError("Missing the required parameter `page_number` when calling `get_document_page_image`") 6855 6856 6857 collection_formats = {} 6858 6859 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/pages/{pageNumber}/page_image'.replace('{format}', 'json') 6860 path_params = {} 6861 if 'account_id' in params: 6862 path_params['accountId'] = params['account_id'] 6863 if 'document_id' in params: 6864 path_params['documentId'] = params['document_id'] 6865 if 'envelope_id' in params: 6866 path_params['envelopeId'] = params['envelope_id'] 6867 if 'page_number' in params: 6868 path_params['pageNumber'] = params['page_number'] 6869 6870 query_params = {} 6871 if 'dpi' in params: 6872 query_params['dpi'] = params['dpi'] 6873 if 'max_height' in params: 6874 query_params['max_height'] = params['max_height'] 6875 if 'max_width' in params: 6876 query_params['max_width'] = params['max_width'] 6877 if 'show_changes' in params: 6878 query_params['show_changes'] = params['show_changes'] 6879 6880 header_params = {} 6881 6882 form_params = [] 6883 local_var_files = {} 6884 6885 body_params = None 6886 # HTTP header `Accept` 6887 header_params['Accept'] = self.api_client.\ 6888 select_header_accept(['image/png']) 6889 6890 # Authentication setting 6891 auth_settings = [] 6892 6893 return self.api_client.call_api(resource_path, 'GET', 6894 path_params, 6895 query_params, 6896 header_params, 6897 body=body_params, 6898 post_params=form_params, 6899 files=local_var_files, 6900 response_type='file', 6901 auth_settings=auth_settings, 6902 callback=params.get('callback'), 6903 _return_http_data_only=params.get('_return_http_data_only'), 6904 _preload_content=params.get('_preload_content', True), 6905 _request_timeout=params.get('_request_timeout'), 6906 collection_formats=collection_formats) 6907 6908 def get_document_tabs(self, account_id, document_id, envelope_id, **kwargs): 6909 """ 6910 Returns tabs on the document. 6911 Returns the tabs on the document specified by `documentId` in the envelope specified by `envelopeId`. 6912 This method makes a synchronous HTTP request by default. To make an 6913 asynchronous HTTP request, please define a `callback` function 6914 to be invoked when receiving the response. 6915 >>> def callback_function(response): 6916 >>> pprint(response) 6917 >>> 6918 >>> thread = api.get_document_tabs(account_id, document_id, envelope_id, callback=callback_function) 6919 6920 :param callback function: The callback function 6921 for asynchronous request. (optional) 6922 :param str account_id: The external account number (int) or account ID Guid. (required) 6923 :param str document_id: The ID of the document being accessed. (required) 6924 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6925 :param str include_metadata: 6926 :param str page_numbers: 6927 :return: Tabs 6928 If the method is called asynchronously, 6929 returns the request thread. 6930 """ 6931 kwargs['_return_http_data_only'] = True 6932 if kwargs.get('callback'): 6933 return self.get_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 6934 else: 6935 (data) = self.get_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 6936 return data 6937 6938 def get_document_tabs_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 6939 """ 6940 Returns tabs on the document. 6941 Returns the tabs on the document specified by `documentId` in the envelope specified by `envelopeId`. 6942 This method makes a synchronous HTTP request by default. To make an 6943 asynchronous HTTP request, please define a `callback` function 6944 to be invoked when receiving the response. 6945 >>> def callback_function(response): 6946 >>> pprint(response) 6947 >>> 6948 >>> thread = api.get_document_tabs_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 6949 6950 :param callback function: The callback function 6951 for asynchronous request. (optional) 6952 :param str account_id: The external account number (int) or account ID Guid. (required) 6953 :param str document_id: The ID of the document being accessed. (required) 6954 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6955 :param str include_metadata: 6956 :param str page_numbers: 6957 :return: Tabs 6958 If the method is called asynchronously, 6959 returns the request thread. 6960 """ 6961 6962 all_params = ['account_id', 'document_id', 'envelope_id', 'include_metadata', 'page_numbers'] 6963 all_params.append('callback') 6964 all_params.append('_return_http_data_only') 6965 all_params.append('_preload_content') 6966 all_params.append('_request_timeout') 6967 6968 params = locals() 6969 for key, val in iteritems(params['kwargs']): 6970 if key not in all_params: 6971 raise TypeError( 6972 "Got an unexpected keyword argument '%s'" 6973 " to method get_document_tabs" % key 6974 ) 6975 params[key] = val 6976 del params['kwargs'] 6977 # verify the required parameter 'account_id' is set 6978 if ('account_id' not in params) or (params['account_id'] is None): 6979 raise ValueError("Missing the required parameter `account_id` when calling `get_document_tabs`") 6980 # verify the required parameter 'document_id' is set 6981 if ('document_id' not in params) or (params['document_id'] is None): 6982 raise ValueError("Missing the required parameter `document_id` when calling `get_document_tabs`") 6983 # verify the required parameter 'envelope_id' is set 6984 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6985 raise ValueError("Missing the required parameter `envelope_id` when calling `get_document_tabs`") 6986 6987 6988 collection_formats = {} 6989 6990 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/tabs'.replace('{format}', 'json') 6991 path_params = {} 6992 if 'account_id' in params: 6993 path_params['accountId'] = params['account_id'] 6994 if 'document_id' in params: 6995 path_params['documentId'] = params['document_id'] 6996 if 'envelope_id' in params: 6997 path_params['envelopeId'] = params['envelope_id'] 6998 6999 query_params = {} 7000 if 'include_metadata' in params: 7001 query_params['include_metadata'] = params['include_metadata'] 7002 if 'page_numbers' in params: 7003 query_params['page_numbers'] = params['page_numbers'] 7004 7005 header_params = {} 7006 7007 form_params = [] 7008 local_var_files = {} 7009 7010 body_params = None 7011 # HTTP header `Accept` 7012 header_params['Accept'] = self.api_client.\ 7013 select_header_accept(['application/json']) 7014 7015 # Authentication setting 7016 auth_settings = [] 7017 7018 return self.api_client.call_api(resource_path, 'GET', 7019 path_params, 7020 query_params, 7021 header_params, 7022 body=body_params, 7023 post_params=form_params, 7024 files=local_var_files, 7025 response_type='Tabs', 7026 auth_settings=auth_settings, 7027 callback=params.get('callback'), 7028 _return_http_data_only=params.get('_return_http_data_only'), 7029 _preload_content=params.get('_preload_content', True), 7030 _request_timeout=params.get('_request_timeout'), 7031 collection_formats=collection_formats) 7032 7033 def get_email_settings(self, account_id, envelope_id, **kwargs): 7034 """ 7035 Gets the email setting overrides for an envelope. 7036 Retrieves the email override settings for the specified envelope. 7037 This method makes a synchronous HTTP request by default. To make an 7038 asynchronous HTTP request, please define a `callback` function 7039 to be invoked when receiving the response. 7040 >>> def callback_function(response): 7041 >>> pprint(response) 7042 >>> 7043 >>> thread = api.get_email_settings(account_id, envelope_id, callback=callback_function) 7044 7045 :param callback function: The callback function 7046 for asynchronous request. (optional) 7047 :param str account_id: The external account number (int) or account ID Guid. (required) 7048 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7049 :return: EmailSettings 7050 If the method is called asynchronously, 7051 returns the request thread. 7052 """ 7053 kwargs['_return_http_data_only'] = True 7054 if kwargs.get('callback'): 7055 return self.get_email_settings_with_http_info(account_id, envelope_id, **kwargs) 7056 else: 7057 (data) = self.get_email_settings_with_http_info(account_id, envelope_id, **kwargs) 7058 return data 7059 7060 def get_email_settings_with_http_info(self, account_id, envelope_id, **kwargs): 7061 """ 7062 Gets the email setting overrides for an envelope. 7063 Retrieves the email override settings for the specified envelope. 7064 This method makes a synchronous HTTP request by default. To make an 7065 asynchronous HTTP request, please define a `callback` function 7066 to be invoked when receiving the response. 7067 >>> def callback_function(response): 7068 >>> pprint(response) 7069 >>> 7070 >>> thread = api.get_email_settings_with_http_info(account_id, envelope_id, callback=callback_function) 7071 7072 :param callback function: The callback function 7073 for asynchronous request. (optional) 7074 :param str account_id: The external account number (int) or account ID Guid. (required) 7075 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7076 :return: EmailSettings 7077 If the method is called asynchronously, 7078 returns the request thread. 7079 """ 7080 7081 all_params = ['account_id', 'envelope_id'] 7082 all_params.append('callback') 7083 all_params.append('_return_http_data_only') 7084 all_params.append('_preload_content') 7085 all_params.append('_request_timeout') 7086 7087 params = locals() 7088 for key, val in iteritems(params['kwargs']): 7089 if key not in all_params: 7090 raise TypeError( 7091 "Got an unexpected keyword argument '%s'" 7092 " to method get_email_settings" % key 7093 ) 7094 params[key] = val 7095 del params['kwargs'] 7096 # verify the required parameter 'account_id' is set 7097 if ('account_id' not in params) or (params['account_id'] is None): 7098 raise ValueError("Missing the required parameter `account_id` when calling `get_email_settings`") 7099 # verify the required parameter 'envelope_id' is set 7100 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7101 raise ValueError("Missing the required parameter `envelope_id` when calling `get_email_settings`") 7102 7103 7104 collection_formats = {} 7105 7106 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/email_settings'.replace('{format}', 'json') 7107 path_params = {} 7108 if 'account_id' in params: 7109 path_params['accountId'] = params['account_id'] 7110 if 'envelope_id' in params: 7111 path_params['envelopeId'] = params['envelope_id'] 7112 7113 query_params = {} 7114 7115 header_params = {} 7116 7117 form_params = [] 7118 local_var_files = {} 7119 7120 body_params = None 7121 # HTTP header `Accept` 7122 header_params['Accept'] = self.api_client.\ 7123 select_header_accept(['application/json']) 7124 7125 # Authentication setting 7126 auth_settings = [] 7127 7128 return self.api_client.call_api(resource_path, 'GET', 7129 path_params, 7130 query_params, 7131 header_params, 7132 body=body_params, 7133 post_params=form_params, 7134 files=local_var_files, 7135 response_type='EmailSettings', 7136 auth_settings=auth_settings, 7137 callback=params.get('callback'), 7138 _return_http_data_only=params.get('_return_http_data_only'), 7139 _preload_content=params.get('_preload_content', True), 7140 _request_timeout=params.get('_request_timeout'), 7141 collection_formats=collection_formats) 7142 7143 def get_envelope(self, account_id, envelope_id, **kwargs): 7144 """ 7145 Gets the status of a envelope. 7146 Retrieves the overall status for the specified envelope. 7147 This method makes a synchronous HTTP request by default. To make an 7148 asynchronous HTTP request, please define a `callback` function 7149 to be invoked when receiving the response. 7150 >>> def callback_function(response): 7151 >>> pprint(response) 7152 >>> 7153 >>> thread = api.get_envelope(account_id, envelope_id, callback=callback_function) 7154 7155 :param callback function: The callback function 7156 for asynchronous request. (optional) 7157 :param str account_id: The external account number (int) or account ID Guid. (required) 7158 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7159 :param str advanced_update: When true, envelope information can be added or modified. 7160 :param str include: 7161 :return: Envelope 7162 If the method is called asynchronously, 7163 returns the request thread. 7164 """ 7165 kwargs['_return_http_data_only'] = True 7166 if kwargs.get('callback'): 7167 return self.get_envelope_with_http_info(account_id, envelope_id, **kwargs) 7168 else: 7169 (data) = self.get_envelope_with_http_info(account_id, envelope_id, **kwargs) 7170 return data 7171 7172 def get_envelope_with_http_info(self, account_id, envelope_id, **kwargs): 7173 """ 7174 Gets the status of a envelope. 7175 Retrieves the overall status for the specified envelope. 7176 This method makes a synchronous HTTP request by default. To make an 7177 asynchronous HTTP request, please define a `callback` function 7178 to be invoked when receiving the response. 7179 >>> def callback_function(response): 7180 >>> pprint(response) 7181 >>> 7182 >>> thread = api.get_envelope_with_http_info(account_id, envelope_id, callback=callback_function) 7183 7184 :param callback function: The callback function 7185 for asynchronous request. (optional) 7186 :param str account_id: The external account number (int) or account ID Guid. (required) 7187 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7188 :param str advanced_update: When true, envelope information can be added or modified. 7189 :param str include: 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'] 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 7233 header_params = {} 7234 7235 form_params = [] 7236 local_var_files = {} 7237 7238 body_params = None 7239 # HTTP header `Accept` 7240 header_params['Accept'] = self.api_client.\ 7241 select_header_accept(['application/json']) 7242 7243 # Authentication setting 7244 auth_settings = [] 7245 7246 return self.api_client.call_api(resource_path, 'GET', 7247 path_params, 7248 query_params, 7249 header_params, 7250 body=body_params, 7251 post_params=form_params, 7252 files=local_var_files, 7253 response_type='Envelope', 7254 auth_settings=auth_settings, 7255 callback=params.get('callback'), 7256 _return_http_data_only=params.get('_return_http_data_only'), 7257 _preload_content=params.get('_preload_content', True), 7258 _request_timeout=params.get('_request_timeout'), 7259 collection_formats=collection_formats) 7260 7261 def get_envelope_delayed_routing_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 7262 """ 7263 Returns the delayed routing rules for an envelope's workflow step definition. 7264 This method makes a synchronous HTTP request by default. To make an 7265 asynchronous HTTP request, please define a `callback` function 7266 to be invoked when receiving the response. 7267 >>> def callback_function(response): 7268 >>> pprint(response) 7269 >>> 7270 >>> thread = api.get_envelope_delayed_routing_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 7271 7272 :param callback function: The callback function 7273 for asynchronous request. (optional) 7274 :param str account_id: The external account number (int) or account ID Guid. (required) 7275 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7276 :param str workflow_step_id: (required) 7277 :return: DelayedRouting 7278 If the method is called asynchronously, 7279 returns the request thread. 7280 """ 7281 kwargs['_return_http_data_only'] = True 7282 if kwargs.get('callback'): 7283 return self.get_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 7284 else: 7285 (data) = self.get_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 7286 return data 7287 7288 def get_envelope_delayed_routing_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 7289 """ 7290 Returns the delayed routing rules for an envelope's workflow step definition. 7291 This method makes a synchronous HTTP request by default. To make an 7292 asynchronous HTTP request, please define a `callback` function 7293 to be invoked when receiving the response. 7294 >>> def callback_function(response): 7295 >>> pprint(response) 7296 >>> 7297 >>> thread = api.get_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 7298 7299 :param callback function: The callback function 7300 for asynchronous request. (optional) 7301 :param str account_id: The external account number (int) or account ID Guid. (required) 7302 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7303 :param str workflow_step_id: (required) 7304 :return: DelayedRouting 7305 If the method is called asynchronously, 7306 returns the request thread. 7307 """ 7308 7309 all_params = ['account_id', 'envelope_id', 'workflow_step_id'] 7310 all_params.append('callback') 7311 all_params.append('_return_http_data_only') 7312 all_params.append('_preload_content') 7313 all_params.append('_request_timeout') 7314 7315 params = locals() 7316 for key, val in iteritems(params['kwargs']): 7317 if key not in all_params: 7318 raise TypeError( 7319 "Got an unexpected keyword argument '%s'" 7320 " to method get_envelope_delayed_routing_definition" % key 7321 ) 7322 params[key] = val 7323 del params['kwargs'] 7324 # verify the required parameter 'account_id' is set 7325 if ('account_id' not in params) or (params['account_id'] is None): 7326 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_delayed_routing_definition`") 7327 # verify the required parameter 'envelope_id' is set 7328 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7329 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_delayed_routing_definition`") 7330 # verify the required parameter 'workflow_step_id' is set 7331 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 7332 raise ValueError("Missing the required parameter `workflow_step_id` when calling `get_envelope_delayed_routing_definition`") 7333 7334 7335 collection_formats = {} 7336 7337 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 7338 path_params = {} 7339 if 'account_id' in params: 7340 path_params['accountId'] = params['account_id'] 7341 if 'envelope_id' in params: 7342 path_params['envelopeId'] = params['envelope_id'] 7343 if 'workflow_step_id' in params: 7344 path_params['workflowStepId'] = params['workflow_step_id'] 7345 7346 query_params = {} 7347 7348 header_params = {} 7349 7350 form_params = [] 7351 local_var_files = {} 7352 7353 body_params = None 7354 # HTTP header `Accept` 7355 header_params['Accept'] = self.api_client.\ 7356 select_header_accept(['application/json']) 7357 7358 # Authentication setting 7359 auth_settings = [] 7360 7361 return self.api_client.call_api(resource_path, 'GET', 7362 path_params, 7363 query_params, 7364 header_params, 7365 body=body_params, 7366 post_params=form_params, 7367 files=local_var_files, 7368 response_type='DelayedRouting', 7369 auth_settings=auth_settings, 7370 callback=params.get('callback'), 7371 _return_http_data_only=params.get('_return_http_data_only'), 7372 _preload_content=params.get('_preload_content', True), 7373 _request_timeout=params.get('_request_timeout'), 7374 collection_formats=collection_formats) 7375 7376 def get_envelope_doc_gen_form_fields(self, account_id, envelope_id, **kwargs): 7377 """ 7378 Returns formfields for an envelope 7379 This method makes a synchronous HTTP request by default. To make an 7380 asynchronous HTTP request, please define a `callback` function 7381 to be invoked when receiving the response. 7382 >>> def callback_function(response): 7383 >>> pprint(response) 7384 >>> 7385 >>> thread = api.get_envelope_doc_gen_form_fields(account_id, envelope_id, callback=callback_function) 7386 7387 :param callback function: The callback function 7388 for asynchronous request. (optional) 7389 :param str account_id: The external account number (int) or account ID Guid. (required) 7390 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7391 :return: DocGenFormFieldResponse 7392 If the method is called asynchronously, 7393 returns the request thread. 7394 """ 7395 kwargs['_return_http_data_only'] = True 7396 if kwargs.get('callback'): 7397 return self.get_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, **kwargs) 7398 else: 7399 (data) = self.get_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, **kwargs) 7400 return data 7401 7402 def get_envelope_doc_gen_form_fields_with_http_info(self, account_id, envelope_id, **kwargs): 7403 """ 7404 Returns formfields for an envelope 7405 This method makes a synchronous HTTP request by default. To make an 7406 asynchronous HTTP request, please define a `callback` function 7407 to be invoked when receiving the response. 7408 >>> def callback_function(response): 7409 >>> pprint(response) 7410 >>> 7411 >>> thread = api.get_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, callback=callback_function) 7412 7413 :param callback function: The callback function 7414 for asynchronous request. (optional) 7415 :param str account_id: The external account number (int) or account ID Guid. (required) 7416 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7417 :return: DocGenFormFieldResponse 7418 If the method is called asynchronously, 7419 returns the request thread. 7420 """ 7421 7422 all_params = ['account_id', 'envelope_id'] 7423 all_params.append('callback') 7424 all_params.append('_return_http_data_only') 7425 all_params.append('_preload_content') 7426 all_params.append('_request_timeout') 7427 7428 params = locals() 7429 for key, val in iteritems(params['kwargs']): 7430 if key not in all_params: 7431 raise TypeError( 7432 "Got an unexpected keyword argument '%s'" 7433 " to method get_envelope_doc_gen_form_fields" % key 7434 ) 7435 params[key] = val 7436 del params['kwargs'] 7437 # verify the required parameter 'account_id' is set 7438 if ('account_id' not in params) or (params['account_id'] is None): 7439 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_doc_gen_form_fields`") 7440 # verify the required parameter 'envelope_id' is set 7441 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7442 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_doc_gen_form_fields`") 7443 7444 7445 collection_formats = {} 7446 7447 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/docGenFormFields'.replace('{format}', 'json') 7448 path_params = {} 7449 if 'account_id' in params: 7450 path_params['accountId'] = params['account_id'] 7451 if 'envelope_id' in params: 7452 path_params['envelopeId'] = params['envelope_id'] 7453 7454 query_params = {} 7455 7456 header_params = {} 7457 7458 form_params = [] 7459 local_var_files = {} 7460 7461 body_params = None 7462 # HTTP header `Accept` 7463 header_params['Accept'] = self.api_client.\ 7464 select_header_accept(['application/json']) 7465 7466 # Authentication setting 7467 auth_settings = [] 7468 7469 return self.api_client.call_api(resource_path, 'GET', 7470 path_params, 7471 query_params, 7472 header_params, 7473 body=body_params, 7474 post_params=form_params, 7475 files=local_var_files, 7476 response_type='DocGenFormFieldResponse', 7477 auth_settings=auth_settings, 7478 callback=params.get('callback'), 7479 _return_http_data_only=params.get('_return_http_data_only'), 7480 _preload_content=params.get('_preload_content', True), 7481 _request_timeout=params.get('_request_timeout'), 7482 collection_formats=collection_formats) 7483 7484 def get_envelope_document_html_definitions(self, account_id, document_id, envelope_id, **kwargs): 7485 """ 7486 Get the Original HTML Definition used to generate the Responsive HTML for a given document. 7487 7488 This method makes a synchronous HTTP request by default. To make an 7489 asynchronous HTTP request, please define a `callback` function 7490 to be invoked when receiving the response. 7491 >>> def callback_function(response): 7492 >>> pprint(response) 7493 >>> 7494 >>> thread = api.get_envelope_document_html_definitions(account_id, document_id, envelope_id, callback=callback_function) 7495 7496 :param callback function: The callback function 7497 for asynchronous request. (optional) 7498 :param str account_id: The external account number (int) or account ID Guid. (required) 7499 :param str document_id: The ID of the document being accessed. (required) 7500 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7501 :return: DocumentHtmlDefinitionOriginals 7502 If the method is called asynchronously, 7503 returns the request thread. 7504 """ 7505 kwargs['_return_http_data_only'] = True 7506 if kwargs.get('callback'): 7507 return self.get_envelope_document_html_definitions_with_http_info(account_id, document_id, envelope_id, **kwargs) 7508 else: 7509 (data) = self.get_envelope_document_html_definitions_with_http_info(account_id, document_id, envelope_id, **kwargs) 7510 return data 7511 7512 def get_envelope_document_html_definitions_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 7513 """ 7514 Get the Original HTML Definition used to generate the Responsive HTML for a given document. 7515 7516 This method makes a synchronous HTTP request by default. To make an 7517 asynchronous HTTP request, please define a `callback` function 7518 to be invoked when receiving the response. 7519 >>> def callback_function(response): 7520 >>> pprint(response) 7521 >>> 7522 >>> thread = api.get_envelope_document_html_definitions_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 7523 7524 :param callback function: The callback function 7525 for asynchronous request. (optional) 7526 :param str account_id: The external account number (int) or account ID Guid. (required) 7527 :param str document_id: The ID of the document being accessed. (required) 7528 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7529 :return: DocumentHtmlDefinitionOriginals 7530 If the method is called asynchronously, 7531 returns the request thread. 7532 """ 7533 7534 all_params = ['account_id', 'document_id', 'envelope_id'] 7535 all_params.append('callback') 7536 all_params.append('_return_http_data_only') 7537 all_params.append('_preload_content') 7538 all_params.append('_request_timeout') 7539 7540 params = locals() 7541 for key, val in iteritems(params['kwargs']): 7542 if key not in all_params: 7543 raise TypeError( 7544 "Got an unexpected keyword argument '%s'" 7545 " to method get_envelope_document_html_definitions" % key 7546 ) 7547 params[key] = val 7548 del params['kwargs'] 7549 # verify the required parameter 'account_id' is set 7550 if ('account_id' not in params) or (params['account_id'] is None): 7551 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_document_html_definitions`") 7552 # verify the required parameter 'document_id' is set 7553 if ('document_id' not in params) or (params['document_id'] is None): 7554 raise ValueError("Missing the required parameter `document_id` when calling `get_envelope_document_html_definitions`") 7555 # verify the required parameter 'envelope_id' is set 7556 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7557 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_document_html_definitions`") 7558 7559 7560 collection_formats = {} 7561 7562 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/html_definitions'.replace('{format}', 'json') 7563 path_params = {} 7564 if 'account_id' in params: 7565 path_params['accountId'] = params['account_id'] 7566 if 'document_id' in params: 7567 path_params['documentId'] = params['document_id'] 7568 if 'envelope_id' in params: 7569 path_params['envelopeId'] = params['envelope_id'] 7570 7571 query_params = {} 7572 7573 header_params = {} 7574 7575 form_params = [] 7576 local_var_files = {} 7577 7578 body_params = None 7579 # HTTP header `Accept` 7580 header_params['Accept'] = self.api_client.\ 7581 select_header_accept(['application/json']) 7582 7583 # Authentication setting 7584 auth_settings = [] 7585 7586 return self.api_client.call_api(resource_path, 'GET', 7587 path_params, 7588 query_params, 7589 header_params, 7590 body=body_params, 7591 post_params=form_params, 7592 files=local_var_files, 7593 response_type='DocumentHtmlDefinitionOriginals', 7594 auth_settings=auth_settings, 7595 callback=params.get('callback'), 7596 _return_http_data_only=params.get('_return_http_data_only'), 7597 _preload_content=params.get('_preload_content', True), 7598 _request_timeout=params.get('_request_timeout'), 7599 collection_formats=collection_formats) 7600 7601 def get_envelope_html_definitions(self, account_id, envelope_id, **kwargs): 7602 """ 7603 Get the Original HTML Definition used to generate the Responsive HTML for the envelope. 7604 7605 This method makes a synchronous HTTP request by default. To make an 7606 asynchronous HTTP request, please define a `callback` function 7607 to be invoked when receiving the response. 7608 >>> def callback_function(response): 7609 >>> pprint(response) 7610 >>> 7611 >>> thread = api.get_envelope_html_definitions(account_id, envelope_id, callback=callback_function) 7612 7613 :param callback function: The callback function 7614 for asynchronous request. (optional) 7615 :param str account_id: The external account number (int) or account ID Guid. (required) 7616 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7617 :return: DocumentHtmlDefinitionOriginals 7618 If the method is called asynchronously, 7619 returns the request thread. 7620 """ 7621 kwargs['_return_http_data_only'] = True 7622 if kwargs.get('callback'): 7623 return self.get_envelope_html_definitions_with_http_info(account_id, envelope_id, **kwargs) 7624 else: 7625 (data) = self.get_envelope_html_definitions_with_http_info(account_id, envelope_id, **kwargs) 7626 return data 7627 7628 def get_envelope_html_definitions_with_http_info(self, account_id, envelope_id, **kwargs): 7629 """ 7630 Get the Original HTML Definition used to generate the Responsive HTML for the envelope. 7631 7632 This method makes a synchronous HTTP request by default. To make an 7633 asynchronous HTTP request, please define a `callback` function 7634 to be invoked when receiving the response. 7635 >>> def callback_function(response): 7636 >>> pprint(response) 7637 >>> 7638 >>> thread = api.get_envelope_html_definitions_with_http_info(account_id, envelope_id, callback=callback_function) 7639 7640 :param callback function: The callback function 7641 for asynchronous request. (optional) 7642 :param str account_id: The external account number (int) or account ID Guid. (required) 7643 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7644 :return: DocumentHtmlDefinitionOriginals 7645 If the method is called asynchronously, 7646 returns the request thread. 7647 """ 7648 7649 all_params = ['account_id', 'envelope_id'] 7650 all_params.append('callback') 7651 all_params.append('_return_http_data_only') 7652 all_params.append('_preload_content') 7653 all_params.append('_request_timeout') 7654 7655 params = locals() 7656 for key, val in iteritems(params['kwargs']): 7657 if key not in all_params: 7658 raise TypeError( 7659 "Got an unexpected keyword argument '%s'" 7660 " to method get_envelope_html_definitions" % key 7661 ) 7662 params[key] = val 7663 del params['kwargs'] 7664 # verify the required parameter 'account_id' is set 7665 if ('account_id' not in params) or (params['account_id'] is None): 7666 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_html_definitions`") 7667 # verify the required parameter 'envelope_id' is set 7668 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7669 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_html_definitions`") 7670 7671 7672 collection_formats = {} 7673 7674 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/html_definitions'.replace('{format}', 'json') 7675 path_params = {} 7676 if 'account_id' in params: 7677 path_params['accountId'] = params['account_id'] 7678 if 'envelope_id' in params: 7679 path_params['envelopeId'] = params['envelope_id'] 7680 7681 query_params = {} 7682 7683 header_params = {} 7684 7685 form_params = [] 7686 local_var_files = {} 7687 7688 body_params = None 7689 # HTTP header `Accept` 7690 header_params['Accept'] = self.api_client.\ 7691 select_header_accept(['application/json']) 7692 7693 # Authentication setting 7694 auth_settings = [] 7695 7696 return self.api_client.call_api(resource_path, 'GET', 7697 path_params, 7698 query_params, 7699 header_params, 7700 body=body_params, 7701 post_params=form_params, 7702 files=local_var_files, 7703 response_type='DocumentHtmlDefinitionOriginals', 7704 auth_settings=auth_settings, 7705 callback=params.get('callback'), 7706 _return_http_data_only=params.get('_return_http_data_only'), 7707 _preload_content=params.get('_preload_content', True), 7708 _request_timeout=params.get('_request_timeout'), 7709 collection_formats=collection_formats) 7710 7711 def get_envelope_scheduled_sending_definition(self, account_id, envelope_id, **kwargs): 7712 """ 7713 Returns the scheduled sending rules for an envelope's workflow definition. 7714 This method makes a synchronous HTTP request by default. To make an 7715 asynchronous HTTP request, please define a `callback` function 7716 to be invoked when receiving the response. 7717 >>> def callback_function(response): 7718 >>> pprint(response) 7719 >>> 7720 >>> thread = api.get_envelope_scheduled_sending_definition(account_id, envelope_id, callback=callback_function) 7721 7722 :param callback function: The callback function 7723 for asynchronous request. (optional) 7724 :param str account_id: The external account number (int) or account ID Guid. (required) 7725 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7726 :return: ScheduledSending 7727 If the method is called asynchronously, 7728 returns the request thread. 7729 """ 7730 kwargs['_return_http_data_only'] = True 7731 if kwargs.get('callback'): 7732 return self.get_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 7733 else: 7734 (data) = self.get_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 7735 return data 7736 7737 def get_envelope_scheduled_sending_definition_with_http_info(self, account_id, envelope_id, **kwargs): 7738 """ 7739 Returns the scheduled sending rules for an envelope's workflow definition. 7740 This method makes a synchronous HTTP request by default. To make an 7741 asynchronous HTTP request, please define a `callback` function 7742 to be invoked when receiving the response. 7743 >>> def callback_function(response): 7744 >>> pprint(response) 7745 >>> 7746 >>> thread = api.get_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, callback=callback_function) 7747 7748 :param callback function: The callback function 7749 for asynchronous request. (optional) 7750 :param str account_id: The external account number (int) or account ID Guid. (required) 7751 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7752 :return: ScheduledSending 7753 If the method is called asynchronously, 7754 returns the request thread. 7755 """ 7756 7757 all_params = ['account_id', 'envelope_id'] 7758 all_params.append('callback') 7759 all_params.append('_return_http_data_only') 7760 all_params.append('_preload_content') 7761 all_params.append('_request_timeout') 7762 7763 params = locals() 7764 for key, val in iteritems(params['kwargs']): 7765 if key not in all_params: 7766 raise TypeError( 7767 "Got an unexpected keyword argument '%s'" 7768 " to method get_envelope_scheduled_sending_definition" % key 7769 ) 7770 params[key] = val 7771 del params['kwargs'] 7772 # verify the required parameter 'account_id' is set 7773 if ('account_id' not in params) or (params['account_id'] is None): 7774 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_scheduled_sending_definition`") 7775 # verify the required parameter 'envelope_id' is set 7776 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7777 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_scheduled_sending_definition`") 7778 7779 7780 collection_formats = {} 7781 7782 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/scheduledSending'.replace('{format}', 'json') 7783 path_params = {} 7784 if 'account_id' in params: 7785 path_params['accountId'] = params['account_id'] 7786 if 'envelope_id' in params: 7787 path_params['envelopeId'] = params['envelope_id'] 7788 7789 query_params = {} 7790 7791 header_params = {} 7792 7793 form_params = [] 7794 local_var_files = {} 7795 7796 body_params = None 7797 # HTTP header `Accept` 7798 header_params['Accept'] = self.api_client.\ 7799 select_header_accept(['application/json']) 7800 7801 # Authentication setting 7802 auth_settings = [] 7803 7804 return self.api_client.call_api(resource_path, 'GET', 7805 path_params, 7806 query_params, 7807 header_params, 7808 body=body_params, 7809 post_params=form_params, 7810 files=local_var_files, 7811 response_type='ScheduledSending', 7812 auth_settings=auth_settings, 7813 callback=params.get('callback'), 7814 _return_http_data_only=params.get('_return_http_data_only'), 7815 _preload_content=params.get('_preload_content', True), 7816 _request_timeout=params.get('_request_timeout'), 7817 collection_formats=collection_formats) 7818 7819 def get_envelope_transfer_rules(self, account_id, **kwargs): 7820 """ 7821 Returns a list of envelope transfer rules in the specified account. 7822 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. 7823 This method makes a synchronous HTTP request by default. To make an 7824 asynchronous HTTP request, please define a `callback` function 7825 to be invoked when receiving the response. 7826 >>> def callback_function(response): 7827 >>> pprint(response) 7828 >>> 7829 >>> thread = api.get_envelope_transfer_rules(account_id, callback=callback_function) 7830 7831 :param callback function: The callback function 7832 for asynchronous request. (optional) 7833 :param str account_id: The external account number (int) or account ID Guid. (required) 7834 :param str count: 7835 :param str start_position: 7836 :return: EnvelopeTransferRuleInformation 7837 If the method is called asynchronously, 7838 returns the request thread. 7839 """ 7840 kwargs['_return_http_data_only'] = True 7841 if kwargs.get('callback'): 7842 return self.get_envelope_transfer_rules_with_http_info(account_id, **kwargs) 7843 else: 7844 (data) = self.get_envelope_transfer_rules_with_http_info(account_id, **kwargs) 7845 return data 7846 7847 def get_envelope_transfer_rules_with_http_info(self, account_id, **kwargs): 7848 """ 7849 Returns a list of envelope transfer rules in the specified account. 7850 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. 7851 This method makes a synchronous HTTP request by default. To make an 7852 asynchronous HTTP request, please define a `callback` function 7853 to be invoked when receiving the response. 7854 >>> def callback_function(response): 7855 >>> pprint(response) 7856 >>> 7857 >>> thread = api.get_envelope_transfer_rules_with_http_info(account_id, callback=callback_function) 7858 7859 :param callback function: The callback function 7860 for asynchronous request. (optional) 7861 :param str account_id: The external account number (int) or account ID Guid. (required) 7862 :param str count: 7863 :param str start_position: 7864 :return: EnvelopeTransferRuleInformation 7865 If the method is called asynchronously, 7866 returns the request thread. 7867 """ 7868 7869 all_params = ['account_id', 'count', 'start_position'] 7870 all_params.append('callback') 7871 all_params.append('_return_http_data_only') 7872 all_params.append('_preload_content') 7873 all_params.append('_request_timeout') 7874 7875 params = locals() 7876 for key, val in iteritems(params['kwargs']): 7877 if key not in all_params: 7878 raise TypeError( 7879 "Got an unexpected keyword argument '%s'" 7880 " to method get_envelope_transfer_rules" % key 7881 ) 7882 params[key] = val 7883 del params['kwargs'] 7884 # verify the required parameter 'account_id' is set 7885 if ('account_id' not in params) or (params['account_id'] is None): 7886 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_transfer_rules`") 7887 7888 7889 collection_formats = {} 7890 7891 resource_path = '/v2.1/accounts/{accountId}/envelopes/transfer_rules'.replace('{format}', 'json') 7892 path_params = {} 7893 if 'account_id' in params: 7894 path_params['accountId'] = params['account_id'] 7895 7896 query_params = {} 7897 if 'count' in params: 7898 query_params['count'] = params['count'] 7899 if 'start_position' in params: 7900 query_params['start_position'] = params['start_position'] 7901 7902 header_params = {} 7903 7904 form_params = [] 7905 local_var_files = {} 7906 7907 body_params = None 7908 # HTTP header `Accept` 7909 header_params['Accept'] = self.api_client.\ 7910 select_header_accept(['application/json']) 7911 7912 # Authentication setting 7913 auth_settings = [] 7914 7915 return self.api_client.call_api(resource_path, 'GET', 7916 path_params, 7917 query_params, 7918 header_params, 7919 body=body_params, 7920 post_params=form_params, 7921 files=local_var_files, 7922 response_type='EnvelopeTransferRuleInformation', 7923 auth_settings=auth_settings, 7924 callback=params.get('callback'), 7925 _return_http_data_only=params.get('_return_http_data_only'), 7926 _preload_content=params.get('_preload_content', True), 7927 _request_timeout=params.get('_request_timeout'), 7928 collection_formats=collection_formats) 7929 7930 def get_envelope_workflow_definition(self, account_id, envelope_id, **kwargs): 7931 """ 7932 Returns the workflow definition for an envelope. 7933 Returns an envelope's workflow definition if the envelope specified by `envelopeId` has one. 7934 This method makes a synchronous HTTP request by default. To make an 7935 asynchronous HTTP request, please define a `callback` function 7936 to be invoked when receiving the response. 7937 >>> def callback_function(response): 7938 >>> pprint(response) 7939 >>> 7940 >>> thread = api.get_envelope_workflow_definition(account_id, envelope_id, callback=callback_function) 7941 7942 :param callback function: The callback function 7943 for asynchronous request. (optional) 7944 :param str account_id: The external account number (int) or account ID Guid. (required) 7945 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7946 :return: Workflow 7947 If the method is called asynchronously, 7948 returns the request thread. 7949 """ 7950 kwargs['_return_http_data_only'] = True 7951 if kwargs.get('callback'): 7952 return self.get_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 7953 else: 7954 (data) = self.get_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 7955 return data 7956 7957 def get_envelope_workflow_definition_with_http_info(self, account_id, envelope_id, **kwargs): 7958 """ 7959 Returns the workflow definition for an envelope. 7960 Returns an envelope's workflow definition if the envelope specified by `envelopeId` has one. 7961 This method makes a synchronous HTTP request by default. To make an 7962 asynchronous HTTP request, please define a `callback` function 7963 to be invoked when receiving the response. 7964 >>> def callback_function(response): 7965 >>> pprint(response) 7966 >>> 7967 >>> thread = api.get_envelope_workflow_definition_with_http_info(account_id, envelope_id, callback=callback_function) 7968 7969 :param callback function: The callback function 7970 for asynchronous request. (optional) 7971 :param str account_id: The external account number (int) or account ID Guid. (required) 7972 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7973 :return: Workflow 7974 If the method is called asynchronously, 7975 returns the request thread. 7976 """ 7977 7978 all_params = ['account_id', 'envelope_id'] 7979 all_params.append('callback') 7980 all_params.append('_return_http_data_only') 7981 all_params.append('_preload_content') 7982 all_params.append('_request_timeout') 7983 7984 params = locals() 7985 for key, val in iteritems(params['kwargs']): 7986 if key not in all_params: 7987 raise TypeError( 7988 "Got an unexpected keyword argument '%s'" 7989 " to method get_envelope_workflow_definition" % key 7990 ) 7991 params[key] = val 7992 del params['kwargs'] 7993 # verify the required parameter 'account_id' is set 7994 if ('account_id' not in params) or (params['account_id'] is None): 7995 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_workflow_definition`") 7996 # verify the required parameter 'envelope_id' is set 7997 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7998 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_workflow_definition`") 7999 8000 8001 collection_formats = {} 8002 8003 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow'.replace('{format}', 'json') 8004 path_params = {} 8005 if 'account_id' in params: 8006 path_params['accountId'] = params['account_id'] 8007 if 'envelope_id' in params: 8008 path_params['envelopeId'] = params['envelope_id'] 8009 8010 query_params = {} 8011 8012 header_params = {} 8013 8014 form_params = [] 8015 local_var_files = {} 8016 8017 body_params = None 8018 # HTTP header `Accept` 8019 header_params['Accept'] = self.api_client.\ 8020 select_header_accept(['application/json']) 8021 8022 # Authentication setting 8023 auth_settings = [] 8024 8025 return self.api_client.call_api(resource_path, 'GET', 8026 path_params, 8027 query_params, 8028 header_params, 8029 body=body_params, 8030 post_params=form_params, 8031 files=local_var_files, 8032 response_type='Workflow', 8033 auth_settings=auth_settings, 8034 callback=params.get('callback'), 8035 _return_http_data_only=params.get('_return_http_data_only'), 8036 _preload_content=params.get('_preload_content', True), 8037 _request_timeout=params.get('_request_timeout'), 8038 collection_formats=collection_formats) 8039 8040 def get_envelope_workflow_step_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 8041 """ 8042 Returns the workflow step definition for an envelope by step id. 8043 This method makes a synchronous HTTP request by default. To make an 8044 asynchronous HTTP request, please define a `callback` function 8045 to be invoked when receiving the response. 8046 >>> def callback_function(response): 8047 >>> pprint(response) 8048 >>> 8049 >>> thread = api.get_envelope_workflow_step_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 8050 8051 :param callback function: The callback function 8052 for asynchronous request. (optional) 8053 :param str account_id: The external account number (int) or account ID Guid. (required) 8054 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8055 :param str workflow_step_id: (required) 8056 :return: WorkflowStep 8057 If the method is called asynchronously, 8058 returns the request thread. 8059 """ 8060 kwargs['_return_http_data_only'] = True 8061 if kwargs.get('callback'): 8062 return self.get_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 8063 else: 8064 (data) = self.get_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 8065 return data 8066 8067 def get_envelope_workflow_step_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 8068 """ 8069 Returns the workflow step definition for an envelope by step id. 8070 This method makes a synchronous HTTP request by default. To make an 8071 asynchronous HTTP request, please define a `callback` function 8072 to be invoked when receiving the response. 8073 >>> def callback_function(response): 8074 >>> pprint(response) 8075 >>> 8076 >>> thread = api.get_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 8077 8078 :param callback function: The callback function 8079 for asynchronous request. (optional) 8080 :param str account_id: The external account number (int) or account ID Guid. (required) 8081 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8082 :param str workflow_step_id: (required) 8083 :return: WorkflowStep 8084 If the method is called asynchronously, 8085 returns the request thread. 8086 """ 8087 8088 all_params = ['account_id', 'envelope_id', 'workflow_step_id'] 8089 all_params.append('callback') 8090 all_params.append('_return_http_data_only') 8091 all_params.append('_preload_content') 8092 all_params.append('_request_timeout') 8093 8094 params = locals() 8095 for key, val in iteritems(params['kwargs']): 8096 if key not in all_params: 8097 raise TypeError( 8098 "Got an unexpected keyword argument '%s'" 8099 " to method get_envelope_workflow_step_definition" % key 8100 ) 8101 params[key] = val 8102 del params['kwargs'] 8103 # verify the required parameter 'account_id' is set 8104 if ('account_id' not in params) or (params['account_id'] is None): 8105 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_workflow_step_definition`") 8106 # verify the required parameter 'envelope_id' is set 8107 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8108 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_workflow_step_definition`") 8109 # verify the required parameter 'workflow_step_id' is set 8110 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 8111 raise ValueError("Missing the required parameter `workflow_step_id` when calling `get_envelope_workflow_step_definition`") 8112 8113 8114 collection_formats = {} 8115 8116 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 8117 path_params = {} 8118 if 'account_id' in params: 8119 path_params['accountId'] = params['account_id'] 8120 if 'envelope_id' in params: 8121 path_params['envelopeId'] = params['envelope_id'] 8122 if 'workflow_step_id' in params: 8123 path_params['workflowStepId'] = params['workflow_step_id'] 8124 8125 query_params = {} 8126 8127 header_params = {} 8128 8129 form_params = [] 8130 local_var_files = {} 8131 8132 body_params = None 8133 # HTTP header `Accept` 8134 header_params['Accept'] = self.api_client.\ 8135 select_header_accept(['application/json']) 8136 8137 # Authentication setting 8138 auth_settings = [] 8139 8140 return self.api_client.call_api(resource_path, 'GET', 8141 path_params, 8142 query_params, 8143 header_params, 8144 body=body_params, 8145 post_params=form_params, 8146 files=local_var_files, 8147 response_type='WorkflowStep', 8148 auth_settings=auth_settings, 8149 callback=params.get('callback'), 8150 _return_http_data_only=params.get('_return_http_data_only'), 8151 _preload_content=params.get('_preload_content', True), 8152 _request_timeout=params.get('_request_timeout'), 8153 collection_formats=collection_formats) 8154 8155 def get_form_data(self, account_id, envelope_id, **kwargs): 8156 """ 8157 Returns envelope form data for an existing envelope. 8158 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/) 8159 This method makes a synchronous HTTP request by default. To make an 8160 asynchronous HTTP request, please define a `callback` function 8161 to be invoked when receiving the response. 8162 >>> def callback_function(response): 8163 >>> pprint(response) 8164 >>> 8165 >>> thread = api.get_form_data(account_id, envelope_id, callback=callback_function) 8166 8167 :param callback function: The callback function 8168 for asynchronous request. (optional) 8169 :param str account_id: The external account number (int) or account ID Guid. (required) 8170 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8171 :return: EnvelopeFormData 8172 If the method is called asynchronously, 8173 returns the request thread. 8174 """ 8175 kwargs['_return_http_data_only'] = True 8176 if kwargs.get('callback'): 8177 return self.get_form_data_with_http_info(account_id, envelope_id, **kwargs) 8178 else: 8179 (data) = self.get_form_data_with_http_info(account_id, envelope_id, **kwargs) 8180 return data 8181 8182 def get_form_data_with_http_info(self, account_id, envelope_id, **kwargs): 8183 """ 8184 Returns envelope form data for an existing envelope. 8185 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/) 8186 This method makes a synchronous HTTP request by default. To make an 8187 asynchronous HTTP request, please define a `callback` function 8188 to be invoked when receiving the response. 8189 >>> def callback_function(response): 8190 >>> pprint(response) 8191 >>> 8192 >>> thread = api.get_form_data_with_http_info(account_id, envelope_id, callback=callback_function) 8193 8194 :param callback function: The callback function 8195 for asynchronous request. (optional) 8196 :param str account_id: The external account number (int) or account ID Guid. (required) 8197 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8198 :return: EnvelopeFormData 8199 If the method is called asynchronously, 8200 returns the request thread. 8201 """ 8202 8203 all_params = ['account_id', 'envelope_id'] 8204 all_params.append('callback') 8205 all_params.append('_return_http_data_only') 8206 all_params.append('_preload_content') 8207 all_params.append('_request_timeout') 8208 8209 params = locals() 8210 for key, val in iteritems(params['kwargs']): 8211 if key not in all_params: 8212 raise TypeError( 8213 "Got an unexpected keyword argument '%s'" 8214 " to method get_form_data" % key 8215 ) 8216 params[key] = val 8217 del params['kwargs'] 8218 # verify the required parameter 'account_id' is set 8219 if ('account_id' not in params) or (params['account_id'] is None): 8220 raise ValueError("Missing the required parameter `account_id` when calling `get_form_data`") 8221 # verify the required parameter 'envelope_id' is set 8222 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8223 raise ValueError("Missing the required parameter `envelope_id` when calling `get_form_data`") 8224 8225 8226 collection_formats = {} 8227 8228 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/form_data'.replace('{format}', 'json') 8229 path_params = {} 8230 if 'account_id' in params: 8231 path_params['accountId'] = params['account_id'] 8232 if 'envelope_id' in params: 8233 path_params['envelopeId'] = params['envelope_id'] 8234 8235 query_params = {} 8236 8237 header_params = {} 8238 8239 form_params = [] 8240 local_var_files = {} 8241 8242 body_params = None 8243 # HTTP header `Accept` 8244 header_params['Accept'] = self.api_client.\ 8245 select_header_accept(['application/json']) 8246 8247 # Authentication setting 8248 auth_settings = [] 8249 8250 return self.api_client.call_api(resource_path, 'GET', 8251 path_params, 8252 query_params, 8253 header_params, 8254 body=body_params, 8255 post_params=form_params, 8256 files=local_var_files, 8257 response_type='EnvelopeFormData', 8258 auth_settings=auth_settings, 8259 callback=params.get('callback'), 8260 _return_http_data_only=params.get('_return_http_data_only'), 8261 _preload_content=params.get('_preload_content', True), 8262 _request_timeout=params.get('_request_timeout'), 8263 collection_formats=collection_formats) 8264 8265 def get_lock(self, account_id, envelope_id, **kwargs): 8266 """ 8267 Gets envelope lock information. 8268 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. 8269 This method makes a synchronous HTTP request by default. To make an 8270 asynchronous HTTP request, please define a `callback` function 8271 to be invoked when receiving the response. 8272 >>> def callback_function(response): 8273 >>> pprint(response) 8274 >>> 8275 >>> thread = api.get_lock(account_id, envelope_id, callback=callback_function) 8276 8277 :param callback function: The callback function 8278 for asynchronous request. (optional) 8279 :param str account_id: The external account number (int) or account ID Guid. (required) 8280 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8281 :return: LockInformation 8282 If the method is called asynchronously, 8283 returns the request thread. 8284 """ 8285 kwargs['_return_http_data_only'] = True 8286 if kwargs.get('callback'): 8287 return self.get_lock_with_http_info(account_id, envelope_id, **kwargs) 8288 else: 8289 (data) = self.get_lock_with_http_info(account_id, envelope_id, **kwargs) 8290 return data 8291 8292 def get_lock_with_http_info(self, account_id, envelope_id, **kwargs): 8293 """ 8294 Gets envelope lock information. 8295 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. 8296 This method makes a synchronous HTTP request by default. To make an 8297 asynchronous HTTP request, please define a `callback` function 8298 to be invoked when receiving the response. 8299 >>> def callback_function(response): 8300 >>> pprint(response) 8301 >>> 8302 >>> thread = api.get_lock_with_http_info(account_id, envelope_id, callback=callback_function) 8303 8304 :param callback function: The callback function 8305 for asynchronous request. (optional) 8306 :param str account_id: The external account number (int) or account ID Guid. (required) 8307 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8308 :return: LockInformation 8309 If the method is called asynchronously, 8310 returns the request thread. 8311 """ 8312 8313 all_params = ['account_id', 'envelope_id'] 8314 all_params.append('callback') 8315 all_params.append('_return_http_data_only') 8316 all_params.append('_preload_content') 8317 all_params.append('_request_timeout') 8318 8319 params = locals() 8320 for key, val in iteritems(params['kwargs']): 8321 if key not in all_params: 8322 raise TypeError( 8323 "Got an unexpected keyword argument '%s'" 8324 " to method get_lock" % key 8325 ) 8326 params[key] = val 8327 del params['kwargs'] 8328 # verify the required parameter 'account_id' is set 8329 if ('account_id' not in params) or (params['account_id'] is None): 8330 raise ValueError("Missing the required parameter `account_id` when calling `get_lock`") 8331 # verify the required parameter 'envelope_id' is set 8332 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8333 raise ValueError("Missing the required parameter `envelope_id` when calling `get_lock`") 8334 8335 8336 collection_formats = {} 8337 8338 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/lock'.replace('{format}', 'json') 8339 path_params = {} 8340 if 'account_id' in params: 8341 path_params['accountId'] = params['account_id'] 8342 if 'envelope_id' in params: 8343 path_params['envelopeId'] = params['envelope_id'] 8344 8345 query_params = {} 8346 8347 header_params = {} 8348 8349 form_params = [] 8350 local_var_files = {} 8351 8352 body_params = None 8353 # HTTP header `Accept` 8354 header_params['Accept'] = self.api_client.\ 8355 select_header_accept(['application/json']) 8356 8357 # Authentication setting 8358 auth_settings = [] 8359 8360 return self.api_client.call_api(resource_path, 'GET', 8361 path_params, 8362 query_params, 8363 header_params, 8364 body=body_params, 8365 post_params=form_params, 8366 files=local_var_files, 8367 response_type='LockInformation', 8368 auth_settings=auth_settings, 8369 callback=params.get('callback'), 8370 _return_http_data_only=params.get('_return_http_data_only'), 8371 _preload_content=params.get('_preload_content', True), 8372 _request_timeout=params.get('_request_timeout'), 8373 collection_formats=collection_formats) 8374 8375 def get_notification_settings(self, account_id, envelope_id, **kwargs): 8376 """ 8377 Gets envelope notification information. 8378 Retrieves the envelope notification, reminders and expirations, information for an existing envelope. 8379 This method makes a synchronous HTTP request by default. To make an 8380 asynchronous HTTP request, please define a `callback` function 8381 to be invoked when receiving the response. 8382 >>> def callback_function(response): 8383 >>> pprint(response) 8384 >>> 8385 >>> thread = api.get_notification_settings(account_id, envelope_id, callback=callback_function) 8386 8387 :param callback function: The callback function 8388 for asynchronous request. (optional) 8389 :param str account_id: The external account number (int) or account ID Guid. (required) 8390 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8391 :return: Notification 8392 If the method is called asynchronously, 8393 returns the request thread. 8394 """ 8395 kwargs['_return_http_data_only'] = True 8396 if kwargs.get('callback'): 8397 return self.get_notification_settings_with_http_info(account_id, envelope_id, **kwargs) 8398 else: 8399 (data) = self.get_notification_settings_with_http_info(account_id, envelope_id, **kwargs) 8400 return data 8401 8402 def get_notification_settings_with_http_info(self, account_id, envelope_id, **kwargs): 8403 """ 8404 Gets envelope notification information. 8405 Retrieves the envelope notification, reminders and expirations, information for an existing envelope. 8406 This method makes a synchronous HTTP request by default. To make an 8407 asynchronous HTTP request, please define a `callback` function 8408 to be invoked when receiving the response. 8409 >>> def callback_function(response): 8410 >>> pprint(response) 8411 >>> 8412 >>> thread = api.get_notification_settings_with_http_info(account_id, envelope_id, callback=callback_function) 8413 8414 :param callback function: The callback function 8415 for asynchronous request. (optional) 8416 :param str account_id: The external account number (int) or account ID Guid. (required) 8417 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8418 :return: Notification 8419 If the method is called asynchronously, 8420 returns the request thread. 8421 """ 8422 8423 all_params = ['account_id', 'envelope_id'] 8424 all_params.append('callback') 8425 all_params.append('_return_http_data_only') 8426 all_params.append('_preload_content') 8427 all_params.append('_request_timeout') 8428 8429 params = locals() 8430 for key, val in iteritems(params['kwargs']): 8431 if key not in all_params: 8432 raise TypeError( 8433 "Got an unexpected keyword argument '%s'" 8434 " to method get_notification_settings" % key 8435 ) 8436 params[key] = val 8437 del params['kwargs'] 8438 # verify the required parameter 'account_id' is set 8439 if ('account_id' not in params) or (params['account_id'] is None): 8440 raise ValueError("Missing the required parameter `account_id` when calling `get_notification_settings`") 8441 # verify the required parameter 'envelope_id' is set 8442 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8443 raise ValueError("Missing the required parameter `envelope_id` when calling `get_notification_settings`") 8444 8445 8446 collection_formats = {} 8447 8448 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/notification'.replace('{format}', 'json') 8449 path_params = {} 8450 if 'account_id' in params: 8451 path_params['accountId'] = params['account_id'] 8452 if 'envelope_id' in params: 8453 path_params['envelopeId'] = params['envelope_id'] 8454 8455 query_params = {} 8456 8457 header_params = {} 8458 8459 form_params = [] 8460 local_var_files = {} 8461 8462 body_params = None 8463 # HTTP header `Accept` 8464 header_params['Accept'] = self.api_client.\ 8465 select_header_accept(['application/json']) 8466 8467 # Authentication setting 8468 auth_settings = [] 8469 8470 return self.api_client.call_api(resource_path, 'GET', 8471 path_params, 8472 query_params, 8473 header_params, 8474 body=body_params, 8475 post_params=form_params, 8476 files=local_var_files, 8477 response_type='Notification', 8478 auth_settings=auth_settings, 8479 callback=params.get('callback'), 8480 _return_http_data_only=params.get('_return_http_data_only'), 8481 _preload_content=params.get('_preload_content', True), 8482 _request_timeout=params.get('_request_timeout'), 8483 collection_formats=collection_formats) 8484 8485 def get_page_tabs(self, account_id, document_id, envelope_id, page_number, **kwargs): 8486 """ 8487 Returns tabs on the specified page. 8488 Returns the tabs from the page specified by `pageNumber` of the document specified by `documentId` in the envelope specified by `envelopeId`. 8489 This method makes a synchronous HTTP request by default. To make an 8490 asynchronous HTTP request, please define a `callback` function 8491 to be invoked when receiving the response. 8492 >>> def callback_function(response): 8493 >>> pprint(response) 8494 >>> 8495 >>> thread = api.get_page_tabs(account_id, document_id, envelope_id, page_number, callback=callback_function) 8496 8497 :param callback function: The callback function 8498 for asynchronous request. (optional) 8499 :param str account_id: The external account number (int) or account ID Guid. (required) 8500 :param str document_id: The ID of the document being accessed. (required) 8501 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8502 :param str page_number: The page number being accessed. (required) 8503 :return: Tabs 8504 If the method is called asynchronously, 8505 returns the request thread. 8506 """ 8507 kwargs['_return_http_data_only'] = True 8508 if kwargs.get('callback'): 8509 return self.get_page_tabs_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 8510 else: 8511 (data) = self.get_page_tabs_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 8512 return data 8513 8514 def get_page_tabs_with_http_info(self, account_id, document_id, envelope_id, page_number, **kwargs): 8515 """ 8516 Returns tabs on the specified page. 8517 Returns the tabs from the page specified by `pageNumber` of the document specified by `documentId` in the envelope specified by `envelopeId`. 8518 This method makes a synchronous HTTP request by default. To make an 8519 asynchronous HTTP request, please define a `callback` function 8520 to be invoked when receiving the response. 8521 >>> def callback_function(response): 8522 >>> pprint(response) 8523 >>> 8524 >>> thread = api.get_page_tabs_with_http_info(account_id, document_id, envelope_id, page_number, callback=callback_function) 8525 8526 :param callback function: The callback function 8527 for asynchronous request. (optional) 8528 :param str account_id: The external account number (int) or account ID Guid. (required) 8529 :param str document_id: The ID of the document being accessed. (required) 8530 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8531 :param str page_number: The page number being accessed. (required) 8532 :return: Tabs 8533 If the method is called asynchronously, 8534 returns the request thread. 8535 """ 8536 8537 all_params = ['account_id', 'document_id', 'envelope_id', 'page_number'] 8538 all_params.append('callback') 8539 all_params.append('_return_http_data_only') 8540 all_params.append('_preload_content') 8541 all_params.append('_request_timeout') 8542 8543 params = locals() 8544 for key, val in iteritems(params['kwargs']): 8545 if key not in all_params: 8546 raise TypeError( 8547 "Got an unexpected keyword argument '%s'" 8548 " to method get_page_tabs" % key 8549 ) 8550 params[key] = val 8551 del params['kwargs'] 8552 # verify the required parameter 'account_id' is set 8553 if ('account_id' not in params) or (params['account_id'] is None): 8554 raise ValueError("Missing the required parameter `account_id` when calling `get_page_tabs`") 8555 # verify the required parameter 'document_id' is set 8556 if ('document_id' not in params) or (params['document_id'] is None): 8557 raise ValueError("Missing the required parameter `document_id` when calling `get_page_tabs`") 8558 # verify the required parameter 'envelope_id' is set 8559 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8560 raise ValueError("Missing the required parameter `envelope_id` when calling `get_page_tabs`") 8561 # verify the required parameter 'page_number' is set 8562 if ('page_number' not in params) or (params['page_number'] is None): 8563 raise ValueError("Missing the required parameter `page_number` when calling `get_page_tabs`") 8564 8565 8566 collection_formats = {} 8567 8568 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/pages/{pageNumber}/tabs'.replace('{format}', 'json') 8569 path_params = {} 8570 if 'account_id' in params: 8571 path_params['accountId'] = params['account_id'] 8572 if 'document_id' in params: 8573 path_params['documentId'] = params['document_id'] 8574 if 'envelope_id' in params: 8575 path_params['envelopeId'] = params['envelope_id'] 8576 if 'page_number' in params: 8577 path_params['pageNumber'] = params['page_number'] 8578 8579 query_params = {} 8580 8581 header_params = {} 8582 8583 form_params = [] 8584 local_var_files = {} 8585 8586 body_params = None 8587 # HTTP header `Accept` 8588 header_params['Accept'] = self.api_client.\ 8589 select_header_accept(['application/json']) 8590 8591 # Authentication setting 8592 auth_settings = [] 8593 8594 return self.api_client.call_api(resource_path, 'GET', 8595 path_params, 8596 query_params, 8597 header_params, 8598 body=body_params, 8599 post_params=form_params, 8600 files=local_var_files, 8601 response_type='Tabs', 8602 auth_settings=auth_settings, 8603 callback=params.get('callback'), 8604 _return_http_data_only=params.get('_return_http_data_only'), 8605 _preload_content=params.get('_preload_content', True), 8606 _request_timeout=params.get('_request_timeout'), 8607 collection_formats=collection_formats) 8608 8609 def get_pages(self, account_id, document_id, envelope_id, **kwargs): 8610 """ 8611 Returns document page image(s) based on input. 8612 Returns images of the pages in a document for display based on the parameters that you specify. 8613 This method makes a synchronous HTTP request by default. To make an 8614 asynchronous HTTP request, please define a `callback` function 8615 to be invoked when receiving the response. 8616 >>> def callback_function(response): 8617 >>> pprint(response) 8618 >>> 8619 >>> thread = api.get_pages(account_id, document_id, envelope_id, callback=callback_function) 8620 8621 :param callback function: The callback function 8622 for asynchronous request. (optional) 8623 :param str account_id: The external account number (int) or account ID Guid. (required) 8624 :param str document_id: The ID of the document being accessed. (required) 8625 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8626 :param str count: 8627 :param str dpi: 8628 :param str max_height: 8629 :param str max_width: 8630 :param str nocache: 8631 :param str show_changes: 8632 :param str start_position: 8633 :return: PageImages 8634 If the method is called asynchronously, 8635 returns the request thread. 8636 """ 8637 kwargs['_return_http_data_only'] = True 8638 if kwargs.get('callback'): 8639 return self.get_pages_with_http_info(account_id, document_id, envelope_id, **kwargs) 8640 else: 8641 (data) = self.get_pages_with_http_info(account_id, document_id, envelope_id, **kwargs) 8642 return data 8643 8644 def get_pages_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 8645 """ 8646 Returns document page image(s) based on input. 8647 Returns images of the pages in a document for display based on the parameters that you specify. 8648 This method makes a synchronous HTTP request by default. To make an 8649 asynchronous HTTP request, please define a `callback` function 8650 to be invoked when receiving the response. 8651 >>> def callback_function(response): 8652 >>> pprint(response) 8653 >>> 8654 >>> thread = api.get_pages_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 8655 8656 :param callback function: The callback function 8657 for asynchronous request. (optional) 8658 :param str account_id: The external account number (int) or account ID Guid. (required) 8659 :param str document_id: The ID of the document being accessed. (required) 8660 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8661 :param str count: 8662 :param str dpi: 8663 :param str max_height: 8664 :param str max_width: 8665 :param str nocache: 8666 :param str show_changes: 8667 :param str start_position: 8668 :return: PageImages 8669 If the method is called asynchronously, 8670 returns the request thread. 8671 """ 8672 8673 all_params = ['account_id', 'document_id', 'envelope_id', 'count', 'dpi', 'max_height', 'max_width', 'nocache', 'show_changes', 'start_position'] 8674 all_params.append('callback') 8675 all_params.append('_return_http_data_only') 8676 all_params.append('_preload_content') 8677 all_params.append('_request_timeout') 8678 8679 params = locals() 8680 for key, val in iteritems(params['kwargs']): 8681 if key not in all_params: 8682 raise TypeError( 8683 "Got an unexpected keyword argument '%s'" 8684 " to method get_pages" % key 8685 ) 8686 params[key] = val 8687 del params['kwargs'] 8688 # verify the required parameter 'account_id' is set 8689 if ('account_id' not in params) or (params['account_id'] is None): 8690 raise ValueError("Missing the required parameter `account_id` when calling `get_pages`") 8691 # verify the required parameter 'document_id' is set 8692 if ('document_id' not in params) or (params['document_id'] is None): 8693 raise ValueError("Missing the required parameter `document_id` when calling `get_pages`") 8694 # verify the required parameter 'envelope_id' is set 8695 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8696 raise ValueError("Missing the required parameter `envelope_id` when calling `get_pages`") 8697 8698 8699 collection_formats = {} 8700 8701 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/pages'.replace('{format}', 'json') 8702 path_params = {} 8703 if 'account_id' in params: 8704 path_params['accountId'] = params['account_id'] 8705 if 'document_id' in params: 8706 path_params['documentId'] = params['document_id'] 8707 if 'envelope_id' in params: 8708 path_params['envelopeId'] = params['envelope_id'] 8709 8710 query_params = {} 8711 if 'count' in params: 8712 query_params['count'] = params['count'] 8713 if 'dpi' in params: 8714 query_params['dpi'] = params['dpi'] 8715 if 'max_height' in params: 8716 query_params['max_height'] = params['max_height'] 8717 if 'max_width' in params: 8718 query_params['max_width'] = params['max_width'] 8719 if 'nocache' in params: 8720 query_params['nocache'] = params['nocache'] 8721 if 'show_changes' in params: 8722 query_params['show_changes'] = params['show_changes'] 8723 if 'start_position' in params: 8724 query_params['start_position'] = params['start_position'] 8725 8726 header_params = {} 8727 8728 form_params = [] 8729 local_var_files = {} 8730 8731 body_params = None 8732 # HTTP header `Accept` 8733 header_params['Accept'] = self.api_client.\ 8734 select_header_accept(['application/json']) 8735 8736 # Authentication setting 8737 auth_settings = [] 8738 8739 return self.api_client.call_api(resource_path, 'GET', 8740 path_params, 8741 query_params, 8742 header_params, 8743 body=body_params, 8744 post_params=form_params, 8745 files=local_var_files, 8746 response_type='PageImages', 8747 auth_settings=auth_settings, 8748 callback=params.get('callback'), 8749 _return_http_data_only=params.get('_return_http_data_only'), 8750 _preload_content=params.get('_preload_content', True), 8751 _request_timeout=params.get('_request_timeout'), 8752 collection_formats=collection_formats) 8753 8754 def get_recipient_document_visibility(self, account_id, envelope_id, recipient_id, **kwargs): 8755 """ 8756 Returns document visibility for the recipients 8757 This method returns information about document visibility for a recipient. 8758 This method makes a synchronous HTTP request by default. To make an 8759 asynchronous HTTP request, please define a `callback` function 8760 to be invoked when receiving the response. 8761 >>> def callback_function(response): 8762 >>> pprint(response) 8763 >>> 8764 >>> thread = api.get_recipient_document_visibility(account_id, envelope_id, recipient_id, callback=callback_function) 8765 8766 :param callback function: The callback function 8767 for asynchronous request. (optional) 8768 :param str account_id: The external account number (int) or account ID Guid. (required) 8769 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8770 :param str recipient_id: The ID of the recipient being accessed. (required) 8771 :return: DocumentVisibilityList 8772 If the method is called asynchronously, 8773 returns the request thread. 8774 """ 8775 kwargs['_return_http_data_only'] = True 8776 if kwargs.get('callback'): 8777 return self.get_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 8778 else: 8779 (data) = self.get_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 8780 return data 8781 8782 def get_recipient_document_visibility_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 8783 """ 8784 Returns document visibility for the recipients 8785 This method returns information about document visibility for a recipient. 8786 This method makes a synchronous HTTP request by default. To make an 8787 asynchronous HTTP request, please define a `callback` function 8788 to be invoked when receiving the response. 8789 >>> def callback_function(response): 8790 >>> pprint(response) 8791 >>> 8792 >>> thread = api.get_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 8793 8794 :param callback function: The callback function 8795 for asynchronous request. (optional) 8796 :param str account_id: The external account number (int) or account ID Guid. (required) 8797 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8798 :param str recipient_id: The ID of the recipient being accessed. (required) 8799 :return: DocumentVisibilityList 8800 If the method is called asynchronously, 8801 returns the request thread. 8802 """ 8803 8804 all_params = ['account_id', 'envelope_id', 'recipient_id'] 8805 all_params.append('callback') 8806 all_params.append('_return_http_data_only') 8807 all_params.append('_preload_content') 8808 all_params.append('_request_timeout') 8809 8810 params = locals() 8811 for key, val in iteritems(params['kwargs']): 8812 if key not in all_params: 8813 raise TypeError( 8814 "Got an unexpected keyword argument '%s'" 8815 " to method get_recipient_document_visibility" % key 8816 ) 8817 params[key] = val 8818 del params['kwargs'] 8819 # verify the required parameter 'account_id' is set 8820 if ('account_id' not in params) or (params['account_id'] is None): 8821 raise ValueError("Missing the required parameter `account_id` when calling `get_recipient_document_visibility`") 8822 # verify the required parameter 'envelope_id' is set 8823 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8824 raise ValueError("Missing the required parameter `envelope_id` when calling `get_recipient_document_visibility`") 8825 # verify the required parameter 'recipient_id' is set 8826 if ('recipient_id' not in params) or (params['recipient_id'] is None): 8827 raise ValueError("Missing the required parameter `recipient_id` when calling `get_recipient_document_visibility`") 8828 8829 8830 collection_formats = {} 8831 8832 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/document_visibility'.replace('{format}', 'json') 8833 path_params = {} 8834 if 'account_id' in params: 8835 path_params['accountId'] = params['account_id'] 8836 if 'envelope_id' in params: 8837 path_params['envelopeId'] = params['envelope_id'] 8838 if 'recipient_id' in params: 8839 path_params['recipientId'] = params['recipient_id'] 8840 8841 query_params = {} 8842 8843 header_params = {} 8844 8845 form_params = [] 8846 local_var_files = {} 8847 8848 body_params = None 8849 # HTTP header `Accept` 8850 header_params['Accept'] = self.api_client.\ 8851 select_header_accept(['application/json']) 8852 8853 # Authentication setting 8854 auth_settings = [] 8855 8856 return self.api_client.call_api(resource_path, 'GET', 8857 path_params, 8858 query_params, 8859 header_params, 8860 body=body_params, 8861 post_params=form_params, 8862 files=local_var_files, 8863 response_type='DocumentVisibilityList', 8864 auth_settings=auth_settings, 8865 callback=params.get('callback'), 8866 _return_http_data_only=params.get('_return_http_data_only'), 8867 _preload_content=params.get('_preload_content', True), 8868 _request_timeout=params.get('_request_timeout'), 8869 collection_formats=collection_formats) 8870 8871 def get_recipient_initials_image(self, account_id, envelope_id, recipient_id, **kwargs): 8872 """ 8873 Gets the initials image for a user. 8874 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. 8875 This method makes a synchronous HTTP request by default. To make an 8876 asynchronous HTTP request, please define a `callback` function 8877 to be invoked when receiving the response. 8878 >>> def callback_function(response): 8879 >>> pprint(response) 8880 >>> 8881 >>> thread = api.get_recipient_initials_image(account_id, envelope_id, recipient_id, callback=callback_function) 8882 8883 :param callback function: The callback function 8884 for asynchronous request. (optional) 8885 :param str account_id: The external account number (int) or account ID Guid. (required) 8886 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8887 :param str recipient_id: The ID of the recipient being accessed. (required) 8888 :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. 8889 :return: file 8890 If the method is called asynchronously, 8891 returns the request thread. 8892 """ 8893 kwargs['_return_http_data_only'] = True 8894 if kwargs.get('callback'): 8895 return self.get_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 8896 else: 8897 (data) = self.get_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 8898 return data 8899 8900 def get_recipient_initials_image_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 8901 """ 8902 Gets the initials image for a user. 8903 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. 8904 This method makes a synchronous HTTP request by default. To make an 8905 asynchronous HTTP request, please define a `callback` function 8906 to be invoked when receiving the response. 8907 >>> def callback_function(response): 8908 >>> pprint(response) 8909 >>> 8910 >>> thread = api.get_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 8911 8912 :param callback function: The callback function 8913 for asynchronous request. (optional) 8914 :param str account_id: The external account number (int) or account ID Guid. (required) 8915 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8916 :param str recipient_id: The ID of the recipient being accessed. (required) 8917 :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. 8918 :return: file 8919 If the method is called asynchronously, 8920 returns the request thread. 8921 """ 8922 8923 all_params = ['account_id', 'envelope_id', 'recipient_id', 'include_chrome'] 8924 all_params.append('callback') 8925 all_params.append('_return_http_data_only') 8926 all_params.append('_preload_content') 8927 all_params.append('_request_timeout') 8928 8929 params = locals() 8930 for key, val in iteritems(params['kwargs']): 8931 if key not in all_params: 8932 raise TypeError( 8933 "Got an unexpected keyword argument '%s'" 8934 " to method get_recipient_initials_image" % key 8935 ) 8936 params[key] = val 8937 del params['kwargs'] 8938 # verify the required parameter 'account_id' is set 8939 if ('account_id' not in params) or (params['account_id'] is None): 8940 raise ValueError("Missing the required parameter `account_id` when calling `get_recipient_initials_image`") 8941 # verify the required parameter 'envelope_id' is set 8942 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8943 raise ValueError("Missing the required parameter `envelope_id` when calling `get_recipient_initials_image`") 8944 # verify the required parameter 'recipient_id' is set 8945 if ('recipient_id' not in params) or (params['recipient_id'] is None): 8946 raise ValueError("Missing the required parameter `recipient_id` when calling `get_recipient_initials_image`") 8947 8948 8949 collection_formats = {} 8950 8951 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/initials_image'.replace('{format}', 'json') 8952 path_params = {} 8953 if 'account_id' in params: 8954 path_params['accountId'] = params['account_id'] 8955 if 'envelope_id' in params: 8956 path_params['envelopeId'] = params['envelope_id'] 8957 if 'recipient_id' in params: 8958 path_params['recipientId'] = params['recipient_id'] 8959 8960 query_params = {} 8961 if 'include_chrome' in params: 8962 query_params['include_chrome'] = params['include_chrome'] 8963 8964 header_params = {} 8965 8966 form_params = [] 8967 local_var_files = {} 8968 8969 body_params = None 8970 # HTTP header `Accept` 8971 header_params['Accept'] = self.api_client.\ 8972 select_header_accept(['image/gif']) 8973 8974 # Authentication setting 8975 auth_settings = [] 8976 8977 return self.api_client.call_api(resource_path, 'GET', 8978 path_params, 8979 query_params, 8980 header_params, 8981 body=body_params, 8982 post_params=form_params, 8983 files=local_var_files, 8984 response_type='file', 8985 auth_settings=auth_settings, 8986 callback=params.get('callback'), 8987 _return_http_data_only=params.get('_return_http_data_only'), 8988 _preload_content=params.get('_preload_content', True), 8989 _request_timeout=params.get('_request_timeout'), 8990 collection_formats=collection_formats) 8991 8992 def get_recipient_signature(self, account_id, envelope_id, recipient_id, **kwargs): 8993 """ 8994 Gets signature information for a signer or sign-in-person recipient. 8995 Retrieves signature information for a signer or sign-in-person recipient. 8996 This method makes a synchronous HTTP request by default. To make an 8997 asynchronous HTTP request, please define a `callback` function 8998 to be invoked when receiving the response. 8999 >>> def callback_function(response): 9000 >>> pprint(response) 9001 >>> 9002 >>> thread = api.get_recipient_signature(account_id, envelope_id, recipient_id, callback=callback_function) 9003 9004 :param callback function: The callback function 9005 for asynchronous request. (optional) 9006 :param str account_id: The external account number (int) or account ID Guid. (required) 9007 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9008 :param str recipient_id: The ID of the recipient being accessed. (required) 9009 :return: UserSignature 9010 If the method is called asynchronously, 9011 returns the request thread. 9012 """ 9013 kwargs['_return_http_data_only'] = True 9014 if kwargs.get('callback'): 9015 return self.get_recipient_signature_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 9016 else: 9017 (data) = self.get_recipient_signature_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 9018 return data 9019 9020 def get_recipient_signature_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 9021 """ 9022 Gets signature information for a signer or sign-in-person recipient. 9023 Retrieves signature information for a signer or sign-in-person recipient. 9024 This method makes a synchronous HTTP request by default. To make an 9025 asynchronous HTTP request, please define a `callback` function 9026 to be invoked when receiving the response. 9027 >>> def callback_function(response): 9028 >>> pprint(response) 9029 >>> 9030 >>> thread = api.get_recipient_signature_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 9031 9032 :param callback function: The callback function 9033 for asynchronous request. (optional) 9034 :param str account_id: The external account number (int) or account ID Guid. (required) 9035 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9036 :param str recipient_id: The ID of the recipient being accessed. (required) 9037 :return: UserSignature 9038 If the method is called asynchronously, 9039 returns the request thread. 9040 """ 9041 9042 all_params = ['account_id', 'envelope_id', 'recipient_id'] 9043 all_params.append('callback') 9044 all_params.append('_return_http_data_only') 9045 all_params.append('_preload_content') 9046 all_params.append('_request_timeout') 9047 9048 params = locals() 9049 for key, val in iteritems(params['kwargs']): 9050 if key not in all_params: 9051 raise TypeError( 9052 "Got an unexpected keyword argument '%s'" 9053 " to method get_recipient_signature" % key 9054 ) 9055 params[key] = val 9056 del params['kwargs'] 9057 # verify the required parameter 'account_id' is set 9058 if ('account_id' not in params) or (params['account_id'] is None): 9059 raise ValueError("Missing the required parameter `account_id` when calling `get_recipient_signature`") 9060 # verify the required parameter 'envelope_id' is set 9061 if ('envelope_id' not in params) or (params['envelope_id'] is None): 9062 raise ValueError("Missing the required parameter `envelope_id` when calling `get_recipient_signature`") 9063 # verify the required parameter 'recipient_id' is set 9064 if ('recipient_id' not in params) or (params['recipient_id'] is None): 9065 raise ValueError("Missing the required parameter `recipient_id` when calling `get_recipient_signature`") 9066 9067 9068 collection_formats = {} 9069 9070 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/signature'.replace('{format}', 'json') 9071 path_params = {} 9072 if 'account_id' in params: 9073 path_params['accountId'] = params['account_id'] 9074 if 'envelope_id' in params: 9075 path_params['envelopeId'] = params['envelope_id'] 9076 if 'recipient_id' in params: 9077 path_params['recipientId'] = params['recipient_id'] 9078 9079 query_params = {} 9080 9081 header_params = {} 9082 9083 form_params = [] 9084 local_var_files = {} 9085 9086 body_params = None 9087 # HTTP header `Accept` 9088 header_params['Accept'] = self.api_client.\ 9089 select_header_accept(['application/json']) 9090 9091 # Authentication setting 9092 auth_settings = [] 9093 9094 return self.api_client.call_api(resource_path, 'GET', 9095 path_params, 9096 query_params, 9097 header_params, 9098 body=body_params, 9099 post_params=form_params, 9100 files=local_var_files, 9101 response_type='UserSignature', 9102 auth_settings=auth_settings, 9103 callback=params.get('callback'), 9104 _return_http_data_only=params.get('_return_http_data_only'), 9105 _preload_content=params.get('_preload_content', True), 9106 _request_timeout=params.get('_request_timeout'), 9107 collection_formats=collection_formats) 9108 9109 def get_recipient_signature_image(self, account_id, envelope_id, recipient_id, **kwargs): 9110 """ 9111 Retrieve signature image information for a signer/sign-in-person recipient. 9112 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. 9113 This method makes a synchronous HTTP request by default. To make an 9114 asynchronous HTTP request, please define a `callback` function 9115 to be invoked when receiving the response. 9116 >>> def callback_function(response): 9117 >>> pprint(response) 9118 >>> 9119 >>> thread = api.get_recipient_signature_image(account_id, envelope_id, recipient_id, callback=callback_function) 9120 9121 :param callback function: The callback function 9122 for asynchronous request. (optional) 9123 :param str account_id: The external account number (int) or account ID Guid. (required) 9124 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9125 :param str recipient_id: The ID of the recipient being accessed. (required) 9126 :param str include_chrome: When set to **true**, indicates the chromed version of the signature image should be retrieved. 9127 :return: file 9128 If the method is called asynchronously, 9129 returns the request thread. 9130 """ 9131 kwargs['_return_http_data_only'] = True 9132 if kwargs.get('callback'): 9133 return self.get_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 9134 else: 9135 (data) = self.get_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 9136 return data 9137 9138 def get_recipient_signature_image_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 9139 """ 9140 Retrieve signature image information for a signer/sign-in-person recipient. 9141 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. 9142 This method makes a synchronous HTTP request by default. To make an 9143 asynchronous HTTP request, please define a `callback` function 9144 to be invoked when receiving the response. 9145 >>> def callback_function(response): 9146 >>> pprint(response) 9147 >>> 9148 >>> thread = api.get_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 9149 9150 :param callback function: The callback function 9151 for asynchronous request. (optional) 9152 :param str account_id: The external account number (int) or account ID Guid. (required) 9153 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9154 :param str recipient_id: The ID of the recipient being accessed. (required) 9155 :param str include_chrome: When set to **true**, indicates the chromed version of the signature image should be retrieved. 9156 :return: file 9157 If the method is called asynchronously, 9158 returns the request thread. 9159 """ 9160 9161 all_params = ['account_id', 'envelope_id', 'recipient_id', 'include_chrome'] 9162 all_params.append('callback') 9163 all_params.append('_return_http_data_only') 9164 all_params.append('_preload_content') 9165 all_params.append('_request_timeout') 9166 9167 params = locals() 9168 for key, val in iteritems(params['kwargs']): 9169 if key not in all_params: 9170 raise TypeError( 9171 "Got an unexpected keyword argument '%s'" 9172 " to method get_recipient_signature_image" % key 9173 ) 9174 params[key] = val 9175 del params['kwargs'] 9176 # verify the required parameter 'account_id' is set 9177 if ('account_id' not in params) or (params['account_id'] is None): 9178 raise ValueError("Missing the required parameter `account_id` when calling `get_recipient_signature_image`") 9179 # verify the required parameter 'envelope_id' is set 9180 if ('envelope_id' not in params) or (params['envelope_id'] is None): 9181 raise ValueError("Missing the required parameter `envelope_id` when calling `get_recipient_signature_image`") 9182 # verify the required parameter 'recipient_id' is set 9183 if ('recipient_id' not in params) or (params['recipient_id'] is None): 9184 raise ValueError("Missing the required parameter `recipient_id` when calling `get_recipient_signature_image`") 9185 9186 9187 collection_formats = {} 9188 9189 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/signature_image'.replace('{format}', 'json') 9190 path_params = {} 9191 if 'account_id' in params: 9192 path_params['accountId'] = params['account_id'] 9193 if 'envelope_id' in params: 9194 path_params['envelopeId'] = params['envelope_id'] 9195 if 'recipient_id' in params: 9196 path_params['recipientId'] = params['recipient_id'] 9197 9198 query_params = {} 9199 if 'include_chrome' in params: 9200 query_params['include_chrome'] = params['include_chrome'] 9201 9202 header_params = {} 9203 9204 form_params = [] 9205 local_var_files = {} 9206 9207 body_params = None 9208 # HTTP header `Accept` 9209 header_params['Accept'] = self.api_client.\ 9210 select_header_accept(['image/gif']) 9211 9212 # Authentication setting 9213 auth_settings = [] 9214 9215 return self.api_client.call_api(resource_path, 'GET', 9216 path_params, 9217 query_params, 9218 header_params, 9219 body=body_params, 9220 post_params=form_params, 9221 files=local_var_files, 9222 response_type='file', 9223 auth_settings=auth_settings, 9224 callback=params.get('callback'), 9225 _return_http_data_only=params.get('_return_http_data_only'), 9226 _preload_content=params.get('_preload_content', True), 9227 _request_timeout=params.get('_request_timeout'), 9228 collection_formats=collection_formats) 9229 9230 def get_tabs_blob(self, account_id, envelope_id, **kwargs): 9231 """ 9232 Get encrypted tabs for envelope. 9233 9234 This method makes a synchronous HTTP request by default. To make an 9235 asynchronous HTTP request, please define a `callback` function 9236 to be invoked when receiving the response. 9237 >>> def callback_function(response): 9238 >>> pprint(response) 9239 >>> 9240 >>> thread = api.get_tabs_blob(account_id, envelope_id, callback=callback_function) 9241 9242 :param callback function: The callback function 9243 for asynchronous request. (optional) 9244 :param str account_id: The external account number (int) or account ID Guid. (required) 9245 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9246 :return: None 9247 If the method is called asynchronously, 9248 returns the request thread. 9249 """ 9250 kwargs['_return_http_data_only'] = True 9251 if kwargs.get('callback'): 9252 return self.get_tabs_blob_with_http_info(account_id, envelope_id, **kwargs) 9253 else: 9254 (data) = self.get_tabs_blob_with_http_info(account_id, envelope_id, **kwargs) 9255 return data 9256 9257 def get_tabs_blob_with_http_info(self, account_id, envelope_id, **kwargs): 9258 """ 9259 Get encrypted tabs for envelope. 9260 9261 This method makes a synchronous HTTP request by default. To make an 9262 asynchronous HTTP request, please define a `callback` function 9263 to be invoked when receiving the response. 9264 >>> def callback_function(response): 9265 >>> pprint(response) 9266 >>> 9267 >>> thread = api.get_tabs_blob_with_http_info(account_id, envelope_id, callback=callback_function) 9268 9269 :param callback function: The callback function 9270 for asynchronous request. (optional) 9271 :param str account_id: The external account number (int) or account ID Guid. (required) 9272 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9273 :return: None 9274 If the method is called asynchronously, 9275 returns the request thread. 9276 """ 9277 9278 all_params = ['account_id', 'envelope_id'] 9279 all_params.append('callback') 9280 all_params.append('_return_http_data_only') 9281 all_params.append('_preload_content') 9282 all_params.append('_request_timeout') 9283 9284 params = locals() 9285 for key, val in iteritems(params['kwargs']): 9286 if key not in all_params: 9287 raise TypeError( 9288 "Got an unexpected keyword argument '%s'" 9289 " to method get_tabs_blob" % key 9290 ) 9291 params[key] = val 9292 del params['kwargs'] 9293 # verify the required parameter 'account_id' is set 9294 if ('account_id' not in params) or (params['account_id'] is None): 9295 raise ValueError("Missing the required parameter `account_id` when calling `get_tabs_blob`") 9296 # verify the required parameter 'envelope_id' is set 9297 if ('envelope_id' not in params) or (params['envelope_id'] is None): 9298 raise ValueError("Missing the required parameter `envelope_id` when calling `get_tabs_blob`") 9299 9300 9301 collection_formats = {} 9302 9303 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/tabs_blob'.replace('{format}', 'json') 9304 path_params = {} 9305 if 'account_id' in params: 9306 path_params['accountId'] = params['account_id'] 9307 if 'envelope_id' in params: 9308 path_params['envelopeId'] = params['envelope_id'] 9309 9310 query_params = {} 9311 9312 header_params = {} 9313 9314 form_params = [] 9315 local_var_files = {} 9316 9317 body_params = None 9318 # HTTP header `Accept` 9319 header_params['Accept'] = self.api_client.\ 9320 select_header_accept(['application/json']) 9321 9322 # Authentication setting 9323 auth_settings = [] 9324 9325 return self.api_client.call_api(resource_path, 'GET', 9326 path_params, 9327 query_params, 9328 header_params, 9329 body=body_params, 9330 post_params=form_params, 9331 files=local_var_files, 9332 response_type=None, 9333 auth_settings=auth_settings, 9334 callback=params.get('callback'), 9335 _return_http_data_only=params.get('_return_http_data_only'), 9336 _preload_content=params.get('_preload_content', True), 9337 _request_timeout=params.get('_request_timeout'), 9338 collection_formats=collection_formats) 9339 9340 def get_template_delayed_routing_definition(self, account_id, template_id, workflow_step_id, **kwargs): 9341 """ 9342 Returns the delayed routing rules for a template's workflow step definition. 9343 This method makes a synchronous HTTP request by default. To make an 9344 asynchronous HTTP request, please define a `callback` function 9345 to be invoked when receiving the response. 9346 >>> def callback_function(response): 9347 >>> pprint(response) 9348 >>> 9349 >>> thread = api.get_template_delayed_routing_definition(account_id, template_id, workflow_step_id, callback=callback_function) 9350 9351 :param callback function: The callback function 9352 for asynchronous request. (optional) 9353 :param str account_id: The external account number (int) or account ID Guid. (required) 9354 :param str template_id: The ID of the template being accessed. (required) 9355 :param str workflow_step_id: (required) 9356 :return: DelayedRouting 9357 If the method is called asynchronously, 9358 returns the request thread. 9359 """ 9360 kwargs['_return_http_data_only'] = True 9361 if kwargs.get('callback'): 9362 return self.get_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 9363 else: 9364 (data) = self.get_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 9365 return data 9366 9367 def get_template_delayed_routing_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 9368 """ 9369 Returns the delayed routing rules for a template's workflow step definition. 9370 This method makes a synchronous HTTP request by default. To make an 9371 asynchronous HTTP request, please define a `callback` function 9372 to be invoked when receiving the response. 9373 >>> def callback_function(response): 9374 >>> pprint(response) 9375 >>> 9376 >>> thread = api.get_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 9377 9378 :param callback function: The callback function 9379 for asynchronous request. (optional) 9380 :param str account_id: The external account number (int) or account ID Guid. (required) 9381 :param str template_id: The ID of the template being accessed. (required) 9382 :param str workflow_step_id: (required) 9383 :return: DelayedRouting 9384 If the method is called asynchronously, 9385 returns the request thread. 9386 """ 9387 9388 all_params = ['account_id', 'template_id', 'workflow_step_id'] 9389 all_params.append('callback') 9390 all_params.append('_return_http_data_only') 9391 all_params.append('_preload_content') 9392 all_params.append('_request_timeout') 9393 9394 params = locals() 9395 for key, val in iteritems(params['kwargs']): 9396 if key not in all_params: 9397 raise TypeError( 9398 "Got an unexpected keyword argument '%s'" 9399 " to method get_template_delayed_routing_definition" % key 9400 ) 9401 params[key] = val 9402 del params['kwargs'] 9403 # verify the required parameter 'account_id' is set 9404 if ('account_id' not in params) or (params['account_id'] is None): 9405 raise ValueError("Missing the required parameter `account_id` when calling `get_template_delayed_routing_definition`") 9406 # verify the required parameter 'template_id' is set 9407 if ('template_id' not in params) or (params['template_id'] is None): 9408 raise ValueError("Missing the required parameter `template_id` when calling `get_template_delayed_routing_definition`") 9409 # verify the required parameter 'workflow_step_id' is set 9410 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 9411 raise ValueError("Missing the required parameter `workflow_step_id` when calling `get_template_delayed_routing_definition`") 9412 9413 9414 collection_formats = {} 9415 9416 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 9417 path_params = {} 9418 if 'account_id' in params: 9419 path_params['accountId'] = params['account_id'] 9420 if 'template_id' in params: 9421 path_params['templateId'] = params['template_id'] 9422 if 'workflow_step_id' in params: 9423 path_params['workflowStepId'] = params['workflow_step_id'] 9424 9425 query_params = {} 9426 9427 header_params = {} 9428 9429 form_params = [] 9430 local_var_files = {} 9431 9432 body_params = None 9433 # HTTP header `Accept` 9434 header_params['Accept'] = self.api_client.\ 9435 select_header_accept(['application/json']) 9436 9437 # Authentication setting 9438 auth_settings = [] 9439 9440 return self.api_client.call_api(resource_path, 'GET', 9441 path_params, 9442 query_params, 9443 header_params, 9444 body=body_params, 9445 post_params=form_params, 9446 files=local_var_files, 9447 response_type='DelayedRouting', 9448 auth_settings=auth_settings, 9449 callback=params.get('callback'), 9450 _return_http_data_only=params.get('_return_http_data_only'), 9451 _preload_content=params.get('_preload_content', True), 9452 _request_timeout=params.get('_request_timeout'), 9453 collection_formats=collection_formats) 9454 9455 def get_template_recipient_document_visibility(self, account_id, recipient_id, template_id, **kwargs): 9456 """ 9457 Returns document visibility for the recipients 9458 This method returns information about document visibility for a template recipient. 9459 This method makes a synchronous HTTP request by default. To make an 9460 asynchronous HTTP request, please define a `callback` function 9461 to be invoked when receiving the response. 9462 >>> def callback_function(response): 9463 >>> pprint(response) 9464 >>> 9465 >>> thread = api.get_template_recipient_document_visibility(account_id, recipient_id, template_id, callback=callback_function) 9466 9467 :param callback function: The callback function 9468 for asynchronous request. (optional) 9469 :param str account_id: The external account number (int) or account ID Guid. (required) 9470 :param str recipient_id: The ID of the recipient being accessed. (required) 9471 :param str template_id: The ID of the template being accessed. (required) 9472 :return: DocumentVisibilityList 9473 If the method is called asynchronously, 9474 returns the request thread. 9475 """ 9476 kwargs['_return_http_data_only'] = True 9477 if kwargs.get('callback'): 9478 return self.get_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, **kwargs) 9479 else: 9480 (data) = self.get_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, **kwargs) 9481 return data 9482 9483 def get_template_recipient_document_visibility_with_http_info(self, account_id, recipient_id, template_id, **kwargs): 9484 """ 9485 Returns document visibility for the recipients 9486 This method returns information about document visibility for a template recipient. 9487 This method makes a synchronous HTTP request by default. To make an 9488 asynchronous HTTP request, please define a `callback` function 9489 to be invoked when receiving the response. 9490 >>> def callback_function(response): 9491 >>> pprint(response) 9492 >>> 9493 >>> thread = api.get_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, callback=callback_function) 9494 9495 :param callback function: The callback function 9496 for asynchronous request. (optional) 9497 :param str account_id: The external account number (int) or account ID Guid. (required) 9498 :param str recipient_id: The ID of the recipient being accessed. (required) 9499 :param str template_id: The ID of the template being accessed. (required) 9500 :return: DocumentVisibilityList 9501 If the method is called asynchronously, 9502 returns the request thread. 9503 """ 9504 9505 all_params = ['account_id', 'recipient_id', 'template_id'] 9506 all_params.append('callback') 9507 all_params.append('_return_http_data_only') 9508 all_params.append('_preload_content') 9509 all_params.append('_request_timeout') 9510 9511 params = locals() 9512 for key, val in iteritems(params['kwargs']): 9513 if key not in all_params: 9514 raise TypeError( 9515 "Got an unexpected keyword argument '%s'" 9516 " to method get_template_recipient_document_visibility" % key 9517 ) 9518 params[key] = val 9519 del params['kwargs'] 9520 # verify the required parameter 'account_id' is set 9521 if ('account_id' not in params) or (params['account_id'] is None): 9522 raise ValueError("Missing the required parameter `account_id` when calling `get_template_recipient_document_visibility`") 9523 # verify the required parameter 'recipient_id' is set 9524 if ('recipient_id' not in params) or (params['recipient_id'] is None): 9525 raise ValueError("Missing the required parameter `recipient_id` when calling `get_template_recipient_document_visibility`") 9526 # verify the required parameter 'template_id' is set 9527 if ('template_id' not in params) or (params['template_id'] is None): 9528 raise ValueError("Missing the required parameter `template_id` when calling `get_template_recipient_document_visibility`") 9529 9530 9531 collection_formats = {} 9532 9533 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/recipients/{recipientId}/document_visibility'.replace('{format}', 'json') 9534 path_params = {} 9535 if 'account_id' in params: 9536 path_params['accountId'] = params['account_id'] 9537 if 'recipient_id' in params: 9538 path_params['recipientId'] = params['recipient_id'] 9539 if 'template_id' in params: 9540 path_params['templateId'] = params['template_id'] 9541 9542 query_params = {} 9543 9544 header_params = {} 9545 9546 form_params = [] 9547 local_var_files = {} 9548 9549 body_params = None 9550 # HTTP header `Accept` 9551 header_params['Accept'] = self.api_client.\ 9552 select_header_accept(['application/json']) 9553 9554 # Authentication setting 9555 auth_settings = [] 9556 9557 return self.api_client.call_api(resource_path, 'GET', 9558 path_params, 9559 query_params, 9560 header_params, 9561 body=body_params, 9562 post_params=form_params, 9563 files=local_var_files, 9564 response_type='DocumentVisibilityList', 9565 auth_settings=auth_settings, 9566 callback=params.get('callback'), 9567 _return_http_data_only=params.get('_return_http_data_only'), 9568 _preload_content=params.get('_preload_content', True), 9569 _request_timeout=params.get('_request_timeout'), 9570 collection_formats=collection_formats) 9571 9572 def get_template_scheduled_sending_definition(self, account_id, template_id, **kwargs): 9573 """ 9574 Returns the scheduled sending rules for a template's workflow definition. 9575 This method makes a synchronous HTTP request by default. To make an 9576 asynchronous HTTP request, please define a `callback` function 9577 to be invoked when receiving the response. 9578 >>> def callback_function(response): 9579 >>> pprint(response) 9580 >>> 9581 >>> thread = api.get_template_scheduled_sending_definition(account_id, template_id, callback=callback_function) 9582 9583 :param callback function: The callback function 9584 for asynchronous request. (optional) 9585 :param str account_id: The external account number (int) or account ID Guid. (required) 9586 :param str template_id: The ID of the template being accessed. (required) 9587 :return: ScheduledSending 9588 If the method is called asynchronously, 9589 returns the request thread. 9590 """ 9591 kwargs['_return_http_data_only'] = True 9592 if kwargs.get('callback'): 9593 return self.get_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 9594 else: 9595 (data) = self.get_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 9596 return data 9597 9598 def get_template_scheduled_sending_definition_with_http_info(self, account_id, template_id, **kwargs): 9599 """ 9600 Returns the scheduled sending rules for a template's workflow definition. 9601 This method makes a synchronous HTTP request by default. To make an 9602 asynchronous HTTP request, please define a `callback` function 9603 to be invoked when receiving the response. 9604 >>> def callback_function(response): 9605 >>> pprint(response) 9606 >>> 9607 >>> thread = api.get_template_scheduled_sending_definition_with_http_info(account_id, template_id, callback=callback_function) 9608 9609 :param callback function: The callback function 9610 for asynchronous request. (optional) 9611 :param str account_id: The external account number (int) or account ID Guid. (required) 9612 :param str template_id: The ID of the template being accessed. (required) 9613 :return: ScheduledSending 9614 If the method is called asynchronously, 9615 returns the request thread. 9616 """ 9617 9618 all_params = ['account_id', 'template_id'] 9619 all_params.append('callback') 9620 all_params.append('_return_http_data_only') 9621 all_params.append('_preload_content') 9622 all_params.append('_request_timeout') 9623 9624 params = locals() 9625 for key, val in iteritems(params['kwargs']): 9626 if key not in all_params: 9627 raise TypeError( 9628 "Got an unexpected keyword argument '%s'" 9629 " to method get_template_scheduled_sending_definition" % key 9630 ) 9631 params[key] = val 9632 del params['kwargs'] 9633 # verify the required parameter 'account_id' is set 9634 if ('account_id' not in params) or (params['account_id'] is None): 9635 raise ValueError("Missing the required parameter `account_id` when calling `get_template_scheduled_sending_definition`") 9636 # verify the required parameter 'template_id' is set 9637 if ('template_id' not in params) or (params['template_id'] is None): 9638 raise ValueError("Missing the required parameter `template_id` when calling `get_template_scheduled_sending_definition`") 9639 9640 9641 collection_formats = {} 9642 9643 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/scheduledSending'.replace('{format}', 'json') 9644 path_params = {} 9645 if 'account_id' in params: 9646 path_params['accountId'] = params['account_id'] 9647 if 'template_id' in params: 9648 path_params['templateId'] = params['template_id'] 9649 9650 query_params = {} 9651 9652 header_params = {} 9653 9654 form_params = [] 9655 local_var_files = {} 9656 9657 body_params = None 9658 # HTTP header `Accept` 9659 header_params['Accept'] = self.api_client.\ 9660 select_header_accept(['application/json']) 9661 9662 # Authentication setting 9663 auth_settings = [] 9664 9665 return self.api_client.call_api(resource_path, 'GET', 9666 path_params, 9667 query_params, 9668 header_params, 9669 body=body_params, 9670 post_params=form_params, 9671 files=local_var_files, 9672 response_type='ScheduledSending', 9673 auth_settings=auth_settings, 9674 callback=params.get('callback'), 9675 _return_http_data_only=params.get('_return_http_data_only'), 9676 _preload_content=params.get('_preload_content', True), 9677 _request_timeout=params.get('_request_timeout'), 9678 collection_formats=collection_formats) 9679 9680 def get_template_workflow_definition(self, account_id, template_id, **kwargs): 9681 """ 9682 Returns the workflow definition for a template. 9683 Returns template's workflow definition if the template specified by `templateId` has one. 9684 This method makes a synchronous HTTP request by default. To make an 9685 asynchronous HTTP request, please define a `callback` function 9686 to be invoked when receiving the response. 9687 >>> def callback_function(response): 9688 >>> pprint(response) 9689 >>> 9690 >>> thread = api.get_template_workflow_definition(account_id, template_id, callback=callback_function) 9691 9692 :param callback function: The callback function 9693 for asynchronous request. (optional) 9694 :param str account_id: The external account number (int) or account ID Guid. (required) 9695 :param str template_id: The ID of the template being accessed. (required) 9696 :return: Workflow 9697 If the method is called asynchronously, 9698 returns the request thread. 9699 """ 9700 kwargs['_return_http_data_only'] = True 9701 if kwargs.get('callback'): 9702 return self.get_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 9703 else: 9704 (data) = self.get_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 9705 return data 9706 9707 def get_template_workflow_definition_with_http_info(self, account_id, template_id, **kwargs): 9708 """ 9709 Returns the workflow definition for a template. 9710 Returns template's workflow definition if the template specified by `templateId` has one. 9711 This method makes a synchronous HTTP request by default. To make an 9712 asynchronous HTTP request, please define a `callback` function 9713 to be invoked when receiving the response. 9714 >>> def callback_function(response): 9715 >>> pprint(response) 9716 >>> 9717 >>> thread = api.get_template_workflow_definition_with_http_info(account_id, template_id, callback=callback_function) 9718 9719 :param callback function: The callback function 9720 for asynchronous request. (optional) 9721 :param str account_id: The external account number (int) or account ID Guid. (required) 9722 :param str template_id: The ID of the template being accessed. (required) 9723 :return: Workflow 9724 If the method is called asynchronously, 9725 returns the request thread. 9726 """ 9727 9728 all_params = ['account_id', 'template_id'] 9729 all_params.append('callback') 9730 all_params.append('_return_http_data_only') 9731 all_params.append('_preload_content') 9732 all_params.append('_request_timeout') 9733 9734 params = locals() 9735 for key, val in iteritems(params['kwargs']): 9736 if key not in all_params: 9737 raise TypeError( 9738 "Got an unexpected keyword argument '%s'" 9739 " to method get_template_workflow_definition" % key 9740 ) 9741 params[key] = val 9742 del params['kwargs'] 9743 # verify the required parameter 'account_id' is set 9744 if ('account_id' not in params) or (params['account_id'] is None): 9745 raise ValueError("Missing the required parameter `account_id` when calling `get_template_workflow_definition`") 9746 # verify the required parameter 'template_id' is set 9747 if ('template_id' not in params) or (params['template_id'] is None): 9748 raise ValueError("Missing the required parameter `template_id` when calling `get_template_workflow_definition`") 9749 9750 9751 collection_formats = {} 9752 9753 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow'.replace('{format}', 'json') 9754 path_params = {} 9755 if 'account_id' in params: 9756 path_params['accountId'] = params['account_id'] 9757 if 'template_id' in params: 9758 path_params['templateId'] = params['template_id'] 9759 9760 query_params = {} 9761 9762 header_params = {} 9763 9764 form_params = [] 9765 local_var_files = {} 9766 9767 body_params = None 9768 # HTTP header `Accept` 9769 header_params['Accept'] = self.api_client.\ 9770 select_header_accept(['application/json']) 9771 9772 # Authentication setting 9773 auth_settings = [] 9774 9775 return self.api_client.call_api(resource_path, 'GET', 9776 path_params, 9777 query_params, 9778 header_params, 9779 body=body_params, 9780 post_params=form_params, 9781 files=local_var_files, 9782 response_type='Workflow', 9783 auth_settings=auth_settings, 9784 callback=params.get('callback'), 9785 _return_http_data_only=params.get('_return_http_data_only'), 9786 _preload_content=params.get('_preload_content', True), 9787 _request_timeout=params.get('_request_timeout'), 9788 collection_formats=collection_formats) 9789 9790 def get_template_workflow_step_definition(self, account_id, template_id, workflow_step_id, **kwargs): 9791 """ 9792 Returns the workflow step definition for a template by step id. 9793 This method makes a synchronous HTTP request by default. To make an 9794 asynchronous HTTP request, please define a `callback` function 9795 to be invoked when receiving the response. 9796 >>> def callback_function(response): 9797 >>> pprint(response) 9798 >>> 9799 >>> thread = api.get_template_workflow_step_definition(account_id, template_id, workflow_step_id, callback=callback_function) 9800 9801 :param callback function: The callback function 9802 for asynchronous request. (optional) 9803 :param str account_id: The external account number (int) or account ID Guid. (required) 9804 :param str template_id: The ID of the template being accessed. (required) 9805 :param str workflow_step_id: (required) 9806 :return: WorkflowStep 9807 If the method is called asynchronously, 9808 returns the request thread. 9809 """ 9810 kwargs['_return_http_data_only'] = True 9811 if kwargs.get('callback'): 9812 return self.get_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 9813 else: 9814 (data) = self.get_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 9815 return data 9816 9817 def get_template_workflow_step_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 9818 """ 9819 Returns the workflow step definition for a template by step id. 9820 This method makes a synchronous HTTP request by default. To make an 9821 asynchronous HTTP request, please define a `callback` function 9822 to be invoked when receiving the response. 9823 >>> def callback_function(response): 9824 >>> pprint(response) 9825 >>> 9826 >>> thread = api.get_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 9827 9828 :param callback function: The callback function 9829 for asynchronous request. (optional) 9830 :param str account_id: The external account number (int) or account ID Guid. (required) 9831 :param str template_id: The ID of the template being accessed. (required) 9832 :param str workflow_step_id: (required) 9833 :return: WorkflowStep 9834 If the method is called asynchronously, 9835 returns the request thread. 9836 """ 9837 9838 all_params = ['account_id', 'template_id', 'workflow_step_id'] 9839 all_params.append('callback') 9840 all_params.append('_return_http_data_only') 9841 all_params.append('_preload_content') 9842 all_params.append('_request_timeout') 9843 9844 params = locals() 9845 for key, val in iteritems(params['kwargs']): 9846 if key not in all_params: 9847 raise TypeError( 9848 "Got an unexpected keyword argument '%s'" 9849 " to method get_template_workflow_step_definition" % key 9850 ) 9851 params[key] = val 9852 del params['kwargs'] 9853 # verify the required parameter 'account_id' is set 9854 if ('account_id' not in params) or (params['account_id'] is None): 9855 raise ValueError("Missing the required parameter `account_id` when calling `get_template_workflow_step_definition`") 9856 # verify the required parameter 'template_id' is set 9857 if ('template_id' not in params) or (params['template_id'] is None): 9858 raise ValueError("Missing the required parameter `template_id` when calling `get_template_workflow_step_definition`") 9859 # verify the required parameter 'workflow_step_id' is set 9860 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 9861 raise ValueError("Missing the required parameter `workflow_step_id` when calling `get_template_workflow_step_definition`") 9862 9863 9864 collection_formats = {} 9865 9866 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 9867 path_params = {} 9868 if 'account_id' in params: 9869 path_params['accountId'] = params['account_id'] 9870 if 'template_id' in params: 9871 path_params['templateId'] = params['template_id'] 9872 if 'workflow_step_id' in params: 9873 path_params['workflowStepId'] = params['workflow_step_id'] 9874 9875 query_params = {} 9876 9877 header_params = {} 9878 9879 form_params = [] 9880 local_var_files = {} 9881 9882 body_params = None 9883 # HTTP header `Accept` 9884 header_params['Accept'] = self.api_client.\ 9885 select_header_accept(['application/json']) 9886 9887 # Authentication setting 9888 auth_settings = [] 9889 9890 return self.api_client.call_api(resource_path, 'GET', 9891 path_params, 9892 query_params, 9893 header_params, 9894 body=body_params, 9895 post_params=form_params, 9896 files=local_var_files, 9897 response_type='WorkflowStep', 9898 auth_settings=auth_settings, 9899 callback=params.get('callback'), 9900 _return_http_data_only=params.get('_return_http_data_only'), 9901 _preload_content=params.get('_preload_content', True), 9902 _request_timeout=params.get('_request_timeout'), 9903 collection_formats=collection_formats) 9904 9905 def list_audit_events(self, account_id, envelope_id, **kwargs): 9906 """ 9907 Gets the envelope audit events for an envelope. 9908 Gets the envelope audit events for the specified envelope. 9909 This method makes a synchronous HTTP request by default. To make an 9910 asynchronous HTTP request, please define a `callback` function 9911 to be invoked when receiving the response. 9912 >>> def callback_function(response): 9913 >>> pprint(response) 9914 >>> 9915 >>> thread = api.list_audit_events(account_id, envelope_id, callback=callback_function) 9916 9917 :param callback function: The callback function 9918 for asynchronous request. (optional) 9919 :param str account_id: The external account number (int) or account ID Guid. (required) 9920 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9921 :return: EnvelopeAuditEventResponse 9922 If the method is called asynchronously, 9923 returns the request thread. 9924 """ 9925 kwargs['_return_http_data_only'] = True 9926 if kwargs.get('callback'): 9927 return self.list_audit_events_with_http_info(account_id, envelope_id, **kwargs) 9928 else: 9929 (data) = self.list_audit_events_with_http_info(account_id, envelope_id, **kwargs) 9930 return data 9931 9932 def list_audit_events_with_http_info(self, account_id, envelope_id, **kwargs): 9933 """ 9934 Gets the envelope audit events for an envelope. 9935 Gets the envelope audit events for the specified envelope. 9936 This method makes a synchronous HTTP request by default. To make an 9937 asynchronous HTTP request, please define a `callback` function 9938 to be invoked when receiving the response. 9939 >>> def callback_function(response): 9940 >>> pprint(response) 9941 >>> 9942 >>> thread = api.list_audit_events_with_http_info(account_id, envelope_id, callback=callback_function) 9943 9944 :param callback function: The callback function 9945 for asynchronous request. (optional) 9946 :param str account_id: The external account number (int) or account ID Guid. (required) 9947 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9948 :return: EnvelopeAuditEventResponse 9949 If the method is called asynchronously, 9950 returns the request thread. 9951 """ 9952 9953 all_params = ['account_id', 'envelope_id'] 9954 all_params.append('callback') 9955 all_params.append('_return_http_data_only') 9956 all_params.append('_preload_content') 9957 all_params.append('_request_timeout') 9958 9959 params = locals() 9960 for key, val in iteritems(params['kwargs']): 9961 if key not in all_params: 9962 raise TypeError( 9963 "Got an unexpected keyword argument '%s'" 9964 " to method list_audit_events" % key 9965 ) 9966 params[key] = val 9967 del params['kwargs'] 9968 # verify the required parameter 'account_id' is set 9969 if ('account_id' not in params) or (params['account_id'] is None): 9970 raise ValueError("Missing the required parameter `account_id` when calling `list_audit_events`") 9971 # verify the required parameter 'envelope_id' is set 9972 if ('envelope_id' not in params) or (params['envelope_id'] is None): 9973 raise ValueError("Missing the required parameter `envelope_id` when calling `list_audit_events`") 9974 9975 9976 collection_formats = {} 9977 9978 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/audit_events'.replace('{format}', 'json') 9979 path_params = {} 9980 if 'account_id' in params: 9981 path_params['accountId'] = params['account_id'] 9982 if 'envelope_id' in params: 9983 path_params['envelopeId'] = params['envelope_id'] 9984 9985 query_params = {} 9986 9987 header_params = {} 9988 9989 form_params = [] 9990 local_var_files = {} 9991 9992 body_params = None 9993 # HTTP header `Accept` 9994 header_params['Accept'] = self.api_client.\ 9995 select_header_accept(['application/json']) 9996 9997 # Authentication setting 9998 auth_settings = [] 9999 10000 return self.api_client.call_api(resource_path, 'GET', 10001 path_params, 10002 query_params, 10003 header_params, 10004 body=body_params, 10005 post_params=form_params, 10006 files=local_var_files, 10007 response_type='EnvelopeAuditEventResponse', 10008 auth_settings=auth_settings, 10009 callback=params.get('callback'), 10010 _return_http_data_only=params.get('_return_http_data_only'), 10011 _preload_content=params.get('_preload_content', True), 10012 _request_timeout=params.get('_request_timeout'), 10013 collection_formats=collection_formats) 10014 10015 def list_custom_fields(self, account_id, envelope_id, **kwargs): 10016 """ 10017 Gets the custom field information for the specified envelope. 10018 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. 10019 This method makes a synchronous HTTP request by default. To make an 10020 asynchronous HTTP request, please define a `callback` function 10021 to be invoked when receiving the response. 10022 >>> def callback_function(response): 10023 >>> pprint(response) 10024 >>> 10025 >>> thread = api.list_custom_fields(account_id, envelope_id, callback=callback_function) 10026 10027 :param callback function: The callback function 10028 for asynchronous request. (optional) 10029 :param str account_id: The external account number (int) or account ID Guid. (required) 10030 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10031 :return: CustomFieldsEnvelope 10032 If the method is called asynchronously, 10033 returns the request thread. 10034 """ 10035 kwargs['_return_http_data_only'] = True 10036 if kwargs.get('callback'): 10037 return self.list_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 10038 else: 10039 (data) = self.list_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 10040 return data 10041 10042 def list_custom_fields_with_http_info(self, account_id, envelope_id, **kwargs): 10043 """ 10044 Gets the custom field information for the specified envelope. 10045 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. 10046 This method makes a synchronous HTTP request by default. To make an 10047 asynchronous HTTP request, please define a `callback` function 10048 to be invoked when receiving the response. 10049 >>> def callback_function(response): 10050 >>> pprint(response) 10051 >>> 10052 >>> thread = api.list_custom_fields_with_http_info(account_id, envelope_id, callback=callback_function) 10053 10054 :param callback function: The callback function 10055 for asynchronous request. (optional) 10056 :param str account_id: The external account number (int) or account ID Guid. (required) 10057 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10058 :return: CustomFieldsEnvelope 10059 If the method is called asynchronously, 10060 returns the request thread. 10061 """ 10062 10063 all_params = ['account_id', 'envelope_id'] 10064 all_params.append('callback') 10065 all_params.append('_return_http_data_only') 10066 all_params.append('_preload_content') 10067 all_params.append('_request_timeout') 10068 10069 params = locals() 10070 for key, val in iteritems(params['kwargs']): 10071 if key not in all_params: 10072 raise TypeError( 10073 "Got an unexpected keyword argument '%s'" 10074 " to method list_custom_fields" % key 10075 ) 10076 params[key] = val 10077 del params['kwargs'] 10078 # verify the required parameter 'account_id' is set 10079 if ('account_id' not in params) or (params['account_id'] is None): 10080 raise ValueError("Missing the required parameter `account_id` when calling `list_custom_fields`") 10081 # verify the required parameter 'envelope_id' is set 10082 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10083 raise ValueError("Missing the required parameter `envelope_id` when calling `list_custom_fields`") 10084 10085 10086 collection_formats = {} 10087 10088 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/custom_fields'.replace('{format}', 'json') 10089 path_params = {} 10090 if 'account_id' in params: 10091 path_params['accountId'] = params['account_id'] 10092 if 'envelope_id' in params: 10093 path_params['envelopeId'] = params['envelope_id'] 10094 10095 query_params = {} 10096 10097 header_params = {} 10098 10099 form_params = [] 10100 local_var_files = {} 10101 10102 body_params = None 10103 # HTTP header `Accept` 10104 header_params['Accept'] = self.api_client.\ 10105 select_header_accept(['application/json']) 10106 10107 # Authentication setting 10108 auth_settings = [] 10109 10110 return self.api_client.call_api(resource_path, 'GET', 10111 path_params, 10112 query_params, 10113 header_params, 10114 body=body_params, 10115 post_params=form_params, 10116 files=local_var_files, 10117 response_type='CustomFieldsEnvelope', 10118 auth_settings=auth_settings, 10119 callback=params.get('callback'), 10120 _return_http_data_only=params.get('_return_http_data_only'), 10121 _preload_content=params.get('_preload_content', True), 10122 _request_timeout=params.get('_request_timeout'), 10123 collection_formats=collection_formats) 10124 10125 def list_document_fields(self, account_id, document_id, envelope_id, **kwargs): 10126 """ 10127 Gets the custom document fields from an existing envelope document. 10128 Retrieves the custom document field information from an existing envelope document. 10129 This method makes a synchronous HTTP request by default. To make an 10130 asynchronous HTTP request, please define a `callback` function 10131 to be invoked when receiving the response. 10132 >>> def callback_function(response): 10133 >>> pprint(response) 10134 >>> 10135 >>> thread = api.list_document_fields(account_id, document_id, envelope_id, callback=callback_function) 10136 10137 :param callback function: The callback function 10138 for asynchronous request. (optional) 10139 :param str account_id: The external account number (int) or account ID Guid. (required) 10140 :param str document_id: The ID of the document being accessed. (required) 10141 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10142 :return: DocumentFieldsInformation 10143 If the method is called asynchronously, 10144 returns the request thread. 10145 """ 10146 kwargs['_return_http_data_only'] = True 10147 if kwargs.get('callback'): 10148 return self.list_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 10149 else: 10150 (data) = self.list_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 10151 return data 10152 10153 def list_document_fields_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 10154 """ 10155 Gets the custom document fields from an existing envelope document. 10156 Retrieves the custom document field information from an existing envelope document. 10157 This method makes a synchronous HTTP request by default. To make an 10158 asynchronous HTTP request, please define a `callback` function 10159 to be invoked when receiving the response. 10160 >>> def callback_function(response): 10161 >>> pprint(response) 10162 >>> 10163 >>> thread = api.list_document_fields_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 10164 10165 :param callback function: The callback function 10166 for asynchronous request. (optional) 10167 :param str account_id: The external account number (int) or account ID Guid. (required) 10168 :param str document_id: The ID of the document being accessed. (required) 10169 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10170 :return: DocumentFieldsInformation 10171 If the method is called asynchronously, 10172 returns the request thread. 10173 """ 10174 10175 all_params = ['account_id', 'document_id', 'envelope_id'] 10176 all_params.append('callback') 10177 all_params.append('_return_http_data_only') 10178 all_params.append('_preload_content') 10179 all_params.append('_request_timeout') 10180 10181 params = locals() 10182 for key, val in iteritems(params['kwargs']): 10183 if key not in all_params: 10184 raise TypeError( 10185 "Got an unexpected keyword argument '%s'" 10186 " to method list_document_fields" % key 10187 ) 10188 params[key] = val 10189 del params['kwargs'] 10190 # verify the required parameter 'account_id' is set 10191 if ('account_id' not in params) or (params['account_id'] is None): 10192 raise ValueError("Missing the required parameter `account_id` when calling `list_document_fields`") 10193 # verify the required parameter 'document_id' is set 10194 if ('document_id' not in params) or (params['document_id'] is None): 10195 raise ValueError("Missing the required parameter `document_id` when calling `list_document_fields`") 10196 # verify the required parameter 'envelope_id' is set 10197 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10198 raise ValueError("Missing the required parameter `envelope_id` when calling `list_document_fields`") 10199 10200 10201 collection_formats = {} 10202 10203 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/fields'.replace('{format}', 'json') 10204 path_params = {} 10205 if 'account_id' in params: 10206 path_params['accountId'] = params['account_id'] 10207 if 'document_id' in params: 10208 path_params['documentId'] = params['document_id'] 10209 if 'envelope_id' in params: 10210 path_params['envelopeId'] = params['envelope_id'] 10211 10212 query_params = {} 10213 10214 header_params = {} 10215 10216 form_params = [] 10217 local_var_files = {} 10218 10219 body_params = None 10220 # HTTP header `Accept` 10221 header_params['Accept'] = self.api_client.\ 10222 select_header_accept(['application/json']) 10223 10224 # Authentication setting 10225 auth_settings = [] 10226 10227 return self.api_client.call_api(resource_path, 'GET', 10228 path_params, 10229 query_params, 10230 header_params, 10231 body=body_params, 10232 post_params=form_params, 10233 files=local_var_files, 10234 response_type='DocumentFieldsInformation', 10235 auth_settings=auth_settings, 10236 callback=params.get('callback'), 10237 _return_http_data_only=params.get('_return_http_data_only'), 10238 _preload_content=params.get('_preload_content', True), 10239 _request_timeout=params.get('_request_timeout'), 10240 collection_formats=collection_formats) 10241 10242 def list_documents(self, account_id, envelope_id, **kwargs): 10243 """ 10244 Gets a list of envelope documents. 10245 Retrieves a list of documents associated with the specified envelope. 10246 This method makes a synchronous HTTP request by default. To make an 10247 asynchronous HTTP request, please define a `callback` function 10248 to be invoked when receiving the response. 10249 >>> def callback_function(response): 10250 >>> pprint(response) 10251 >>> 10252 >>> thread = api.list_documents(account_id, envelope_id, callback=callback_function) 10253 10254 :param callback function: The callback function 10255 for asynchronous request. (optional) 10256 :param str account_id: The external account number (int) or account ID Guid. (required) 10257 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10258 :param str documents_by_userid: 10259 :param str include_docgen_formfields: 10260 :param str include_document_size: 10261 :param str include_metadata: 10262 :param str include_tabs: 10263 :param str recipient_id: 10264 :param str shared_user_id: 10265 :return: EnvelopeDocumentsResult 10266 If the method is called asynchronously, 10267 returns the request thread. 10268 """ 10269 kwargs['_return_http_data_only'] = True 10270 if kwargs.get('callback'): 10271 return self.list_documents_with_http_info(account_id, envelope_id, **kwargs) 10272 else: 10273 (data) = self.list_documents_with_http_info(account_id, envelope_id, **kwargs) 10274 return data 10275 10276 def list_documents_with_http_info(self, account_id, envelope_id, **kwargs): 10277 """ 10278 Gets a list of envelope documents. 10279 Retrieves a list of documents associated with the specified envelope. 10280 This method makes a synchronous HTTP request by default. To make an 10281 asynchronous HTTP request, please define a `callback` function 10282 to be invoked when receiving the response. 10283 >>> def callback_function(response): 10284 >>> pprint(response) 10285 >>> 10286 >>> thread = api.list_documents_with_http_info(account_id, envelope_id, callback=callback_function) 10287 10288 :param callback function: The callback function 10289 for asynchronous request. (optional) 10290 :param str account_id: The external account number (int) or account ID Guid. (required) 10291 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10292 :param str documents_by_userid: 10293 :param str include_docgen_formfields: 10294 :param str include_document_size: 10295 :param str include_metadata: 10296 :param str include_tabs: 10297 :param str recipient_id: 10298 :param str shared_user_id: 10299 :return: EnvelopeDocumentsResult 10300 If the method is called asynchronously, 10301 returns the request thread. 10302 """ 10303 10304 all_params = ['account_id', 'envelope_id', 'documents_by_userid', 'include_docgen_formfields', 'include_document_size', 'include_metadata', 'include_tabs', 'recipient_id', 'shared_user_id'] 10305 all_params.append('callback') 10306 all_params.append('_return_http_data_only') 10307 all_params.append('_preload_content') 10308 all_params.append('_request_timeout') 10309 10310 params = locals() 10311 for key, val in iteritems(params['kwargs']): 10312 if key not in all_params: 10313 raise TypeError( 10314 "Got an unexpected keyword argument '%s'" 10315 " to method list_documents" % key 10316 ) 10317 params[key] = val 10318 del params['kwargs'] 10319 # verify the required parameter 'account_id' is set 10320 if ('account_id' not in params) or (params['account_id'] is None): 10321 raise ValueError("Missing the required parameter `account_id` when calling `list_documents`") 10322 # verify the required parameter 'envelope_id' is set 10323 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10324 raise ValueError("Missing the required parameter `envelope_id` when calling `list_documents`") 10325 10326 10327 collection_formats = {} 10328 10329 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents'.replace('{format}', 'json') 10330 path_params = {} 10331 if 'account_id' in params: 10332 path_params['accountId'] = params['account_id'] 10333 if 'envelope_id' in params: 10334 path_params['envelopeId'] = params['envelope_id'] 10335 10336 query_params = {} 10337 if 'documents_by_userid' in params: 10338 query_params['documents_by_userid'] = params['documents_by_userid'] 10339 if 'include_docgen_formfields' in params: 10340 query_params['include_docgen_formfields'] = params['include_docgen_formfields'] 10341 if 'include_document_size' in params: 10342 query_params['include_document_size'] = params['include_document_size'] 10343 if 'include_metadata' in params: 10344 query_params['include_metadata'] = params['include_metadata'] 10345 if 'include_tabs' in params: 10346 query_params['include_tabs'] = params['include_tabs'] 10347 if 'recipient_id' in params: 10348 query_params['recipient_id'] = params['recipient_id'] 10349 if 'shared_user_id' in params: 10350 query_params['shared_user_id'] = params['shared_user_id'] 10351 10352 header_params = {} 10353 10354 form_params = [] 10355 local_var_files = {} 10356 10357 body_params = None 10358 # HTTP header `Accept` 10359 header_params['Accept'] = self.api_client.\ 10360 select_header_accept(['application/json']) 10361 10362 # Authentication setting 10363 auth_settings = [] 10364 10365 return self.api_client.call_api(resource_path, 'GET', 10366 path_params, 10367 query_params, 10368 header_params, 10369 body=body_params, 10370 post_params=form_params, 10371 files=local_var_files, 10372 response_type='EnvelopeDocumentsResult', 10373 auth_settings=auth_settings, 10374 callback=params.get('callback'), 10375 _return_http_data_only=params.get('_return_http_data_only'), 10376 _preload_content=params.get('_preload_content', True), 10377 _request_timeout=params.get('_request_timeout'), 10378 collection_formats=collection_formats) 10379 10380 def list_recipients(self, account_id, envelope_id, **kwargs): 10381 """ 10382 Gets the status of recipients for an envelope. 10383 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. 10384 This method makes a synchronous HTTP request by default. To make an 10385 asynchronous HTTP request, please define a `callback` function 10386 to be invoked when receiving the response. 10387 >>> def callback_function(response): 10388 >>> pprint(response) 10389 >>> 10390 >>> thread = api.list_recipients(account_id, envelope_id, callback=callback_function) 10391 10392 :param callback function: The callback function 10393 for asynchronous request. (optional) 10394 :param str account_id: The external account number (int) or account ID Guid. (required) 10395 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10396 :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. 10397 :param str include_extended: When set to **true**, the extended properties are included in the response. 10398 :param str include_metadata: 10399 :param str include_tabs: When set to **true**, the tab information associated with the recipient is included in the response. 10400 :return: Recipients 10401 If the method is called asynchronously, 10402 returns the request thread. 10403 """ 10404 kwargs['_return_http_data_only'] = True 10405 if kwargs.get('callback'): 10406 return self.list_recipients_with_http_info(account_id, envelope_id, **kwargs) 10407 else: 10408 (data) = self.list_recipients_with_http_info(account_id, envelope_id, **kwargs) 10409 return data 10410 10411 def list_recipients_with_http_info(self, account_id, envelope_id, **kwargs): 10412 """ 10413 Gets the status of recipients for an envelope. 10414 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. 10415 This method makes a synchronous HTTP request by default. To make an 10416 asynchronous HTTP request, please define a `callback` function 10417 to be invoked when receiving the response. 10418 >>> def callback_function(response): 10419 >>> pprint(response) 10420 >>> 10421 >>> thread = api.list_recipients_with_http_info(account_id, envelope_id, callback=callback_function) 10422 10423 :param callback function: The callback function 10424 for asynchronous request. (optional) 10425 :param str account_id: The external account number (int) or account ID Guid. (required) 10426 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10427 :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. 10428 :param str include_extended: When set to **true**, the extended properties are included in the response. 10429 :param str include_metadata: 10430 :param str include_tabs: When set to **true**, the tab information associated with the recipient is included in the response. 10431 :return: Recipients 10432 If the method is called asynchronously, 10433 returns the request thread. 10434 """ 10435 10436 all_params = ['account_id', 'envelope_id', 'include_anchor_tab_locations', 'include_extended', 'include_metadata', 'include_tabs'] 10437 all_params.append('callback') 10438 all_params.append('_return_http_data_only') 10439 all_params.append('_preload_content') 10440 all_params.append('_request_timeout') 10441 10442 params = locals() 10443 for key, val in iteritems(params['kwargs']): 10444 if key not in all_params: 10445 raise TypeError( 10446 "Got an unexpected keyword argument '%s'" 10447 " to method list_recipients" % key 10448 ) 10449 params[key] = val 10450 del params['kwargs'] 10451 # verify the required parameter 'account_id' is set 10452 if ('account_id' not in params) or (params['account_id'] is None): 10453 raise ValueError("Missing the required parameter `account_id` when calling `list_recipients`") 10454 # verify the required parameter 'envelope_id' is set 10455 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10456 raise ValueError("Missing the required parameter `envelope_id` when calling `list_recipients`") 10457 10458 10459 collection_formats = {} 10460 10461 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients'.replace('{format}', 'json') 10462 path_params = {} 10463 if 'account_id' in params: 10464 path_params['accountId'] = params['account_id'] 10465 if 'envelope_id' in params: 10466 path_params['envelopeId'] = params['envelope_id'] 10467 10468 query_params = {} 10469 if 'include_anchor_tab_locations' in params: 10470 query_params['include_anchor_tab_locations'] = params['include_anchor_tab_locations'] 10471 if 'include_extended' in params: 10472 query_params['include_extended'] = params['include_extended'] 10473 if 'include_metadata' in params: 10474 query_params['include_metadata'] = params['include_metadata'] 10475 if 'include_tabs' in params: 10476 query_params['include_tabs'] = params['include_tabs'] 10477 10478 header_params = {} 10479 10480 form_params = [] 10481 local_var_files = {} 10482 10483 body_params = None 10484 # HTTP header `Accept` 10485 header_params['Accept'] = self.api_client.\ 10486 select_header_accept(['application/json']) 10487 10488 # Authentication setting 10489 auth_settings = [] 10490 10491 return self.api_client.call_api(resource_path, 'GET', 10492 path_params, 10493 query_params, 10494 header_params, 10495 body=body_params, 10496 post_params=form_params, 10497 files=local_var_files, 10498 response_type='Recipients', 10499 auth_settings=auth_settings, 10500 callback=params.get('callback'), 10501 _return_http_data_only=params.get('_return_http_data_only'), 10502 _preload_content=params.get('_preload_content', True), 10503 _request_timeout=params.get('_request_timeout'), 10504 collection_formats=collection_formats) 10505 10506 def list_status(self, account_id, **kwargs): 10507 """ 10508 Gets the envelope status for the specified envelopes. 10509 Retrieves the envelope status for the specified envelopes. 10510 This method makes a synchronous HTTP request by default. To make an 10511 asynchronous HTTP request, please define a `callback` function 10512 to be invoked when receiving the response. 10513 >>> def callback_function(response): 10514 >>> pprint(response) 10515 >>> 10516 >>> thread = api.list_status(account_id, callback=callback_function) 10517 10518 :param callback function: The callback function 10519 for asynchronous request. (optional) 10520 :param str account_id: The external account number (int) or account ID Guid. (required) 10521 :param str ac_status: 10522 :param str block: 10523 :param str count: 10524 :param str email: 10525 :param str envelope_ids: 10526 :param str from_date: 10527 :param str from_to_status: 10528 :param str start_position: 10529 :param str status: 10530 :param str to_date: 10531 :param str transaction_ids: 10532 :param str user_name: 10533 :param EnvelopeIdsRequest envelope_ids_request: 10534 :return: EnvelopesInformation 10535 If the method is called asynchronously, 10536 returns the request thread. 10537 """ 10538 kwargs['_return_http_data_only'] = True 10539 if kwargs.get('callback'): 10540 return self.list_status_with_http_info(account_id, **kwargs) 10541 else: 10542 (data) = self.list_status_with_http_info(account_id, **kwargs) 10543 return data 10544 10545 def list_status_with_http_info(self, account_id, **kwargs): 10546 """ 10547 Gets the envelope status for the specified envelopes. 10548 Retrieves the envelope status for the specified envelopes. 10549 This method makes a synchronous HTTP request by default. To make an 10550 asynchronous HTTP request, please define a `callback` function 10551 to be invoked when receiving the response. 10552 >>> def callback_function(response): 10553 >>> pprint(response) 10554 >>> 10555 >>> thread = api.list_status_with_http_info(account_id, callback=callback_function) 10556 10557 :param callback function: The callback function 10558 for asynchronous request. (optional) 10559 :param str account_id: The external account number (int) or account ID Guid. (required) 10560 :param str ac_status: 10561 :param str block: 10562 :param str count: 10563 :param str email: 10564 :param str envelope_ids: 10565 :param str from_date: 10566 :param str from_to_status: 10567 :param str start_position: 10568 :param str status: 10569 :param str to_date: 10570 :param str transaction_ids: 10571 :param str user_name: 10572 :param EnvelopeIdsRequest envelope_ids_request: 10573 :return: EnvelopesInformation 10574 If the method is called asynchronously, 10575 returns the request thread. 10576 """ 10577 10578 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'] 10579 all_params.append('callback') 10580 all_params.append('_return_http_data_only') 10581 all_params.append('_preload_content') 10582 all_params.append('_request_timeout') 10583 10584 params = locals() 10585 for key, val in iteritems(params['kwargs']): 10586 if key not in all_params: 10587 raise TypeError( 10588 "Got an unexpected keyword argument '%s'" 10589 " to method list_status" % key 10590 ) 10591 params[key] = val 10592 del params['kwargs'] 10593 # verify the required parameter 'account_id' is set 10594 if ('account_id' not in params) or (params['account_id'] is None): 10595 raise ValueError("Missing the required parameter `account_id` when calling `list_status`") 10596 10597 10598 collection_formats = {} 10599 10600 resource_path = '/v2.1/accounts/{accountId}/envelopes/status'.replace('{format}', 'json') 10601 path_params = {} 10602 if 'account_id' in params: 10603 path_params['accountId'] = params['account_id'] 10604 10605 query_params = {} 10606 if 'ac_status' in params: 10607 query_params['ac_status'] = params['ac_status'] 10608 if 'block' in params: 10609 query_params['block'] = params['block'] 10610 if 'count' in params: 10611 query_params['count'] = params['count'] 10612 if 'email' in params: 10613 query_params['email'] = params['email'] 10614 if 'envelope_ids' in params: 10615 query_params['envelope_ids'] = params['envelope_ids'] 10616 if 'from_date' in params: 10617 query_params['from_date'] = params['from_date'] 10618 if 'from_to_status' in params: 10619 query_params['from_to_status'] = params['from_to_status'] 10620 if 'start_position' in params: 10621 query_params['start_position'] = params['start_position'] 10622 if 'status' in params: 10623 query_params['status'] = params['status'] 10624 if 'to_date' in params: 10625 query_params['to_date'] = params['to_date'] 10626 if 'transaction_ids' in params: 10627 query_params['transaction_ids'] = params['transaction_ids'] 10628 if 'user_name' in params: 10629 query_params['user_name'] = params['user_name'] 10630 10631 header_params = {} 10632 10633 form_params = [] 10634 local_var_files = {} 10635 10636 body_params = None 10637 if 'envelope_ids_request' in params: 10638 body_params = params['envelope_ids_request'] 10639 # HTTP header `Accept` 10640 header_params['Accept'] = self.api_client.\ 10641 select_header_accept(['application/json']) 10642 10643 # Authentication setting 10644 auth_settings = [] 10645 10646 return self.api_client.call_api(resource_path, 'PUT', 10647 path_params, 10648 query_params, 10649 header_params, 10650 body=body_params, 10651 post_params=form_params, 10652 files=local_var_files, 10653 response_type='EnvelopesInformation', 10654 auth_settings=auth_settings, 10655 callback=params.get('callback'), 10656 _return_http_data_only=params.get('_return_http_data_only'), 10657 _preload_content=params.get('_preload_content', True), 10658 _request_timeout=params.get('_request_timeout'), 10659 collection_formats=collection_formats) 10660 10661 def list_status_changes(self, account_id, **kwargs): 10662 """ 10663 Gets status changes for one or more envelopes. 10664 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. 10665 This method makes a synchronous HTTP request by default. To make an 10666 asynchronous HTTP request, please define a `callback` function 10667 to be invoked when receiving the response. 10668 >>> def callback_function(response): 10669 >>> pprint(response) 10670 >>> 10671 >>> thread = api.list_status_changes(account_id, callback=callback_function) 10672 10673 :param callback function: The callback function 10674 for asynchronous request. (optional) 10675 :param str account_id: The external account number (int) or account ID Guid. (required) 10676 :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. 10677 :param str block: 10678 :param str cdse_mode: 10679 :param str continuation_token: 10680 :param str count: 10681 :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.\" 10682 :param str email: 10683 :param str envelope_ids: 10684 :param str exclude: 10685 :param str folder_ids: 10686 :param str folder_types: 10687 :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. 10688 :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. 10689 :param str include: 10690 :param str include_purge_information: 10691 :param str intersecting_folder_ids: 10692 :param str last_queried_date: 10693 :param str order: 10694 :param str order_by: 10695 :param str powerformids: 10696 :param str query_budget: 10697 :param str requester_date_format: 10698 :param str search_text: 10699 :param str start_position: 10700 :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. 10701 :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`. 10702 :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. 10703 :param str user_filter: 10704 :param str user_id: 10705 :param str user_name: 10706 :return: EnvelopesInformation 10707 If the method is called asynchronously, 10708 returns the request thread. 10709 """ 10710 kwargs['_return_http_data_only'] = True 10711 if kwargs.get('callback'): 10712 return self.list_status_changes_with_http_info(account_id, **kwargs) 10713 else: 10714 (data) = self.list_status_changes_with_http_info(account_id, **kwargs) 10715 return data 10716 10717 def list_status_changes_with_http_info(self, account_id, **kwargs): 10718 """ 10719 Gets status changes for one or more envelopes. 10720 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. 10721 This method makes a synchronous HTTP request by default. To make an 10722 asynchronous HTTP request, please define a `callback` function 10723 to be invoked when receiving the response. 10724 >>> def callback_function(response): 10725 >>> pprint(response) 10726 >>> 10727 >>> thread = api.list_status_changes_with_http_info(account_id, callback=callback_function) 10728 10729 :param callback function: The callback function 10730 for asynchronous request. (optional) 10731 :param str account_id: The external account number (int) or account ID Guid. (required) 10732 :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. 10733 :param str block: 10734 :param str cdse_mode: 10735 :param str continuation_token: 10736 :param str count: 10737 :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.\" 10738 :param str email: 10739 :param str envelope_ids: 10740 :param str exclude: 10741 :param str folder_ids: 10742 :param str folder_types: 10743 :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. 10744 :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. 10745 :param str include: 10746 :param str include_purge_information: 10747 :param str intersecting_folder_ids: 10748 :param str last_queried_date: 10749 :param str order: 10750 :param str order_by: 10751 :param str powerformids: 10752 :param str query_budget: 10753 :param str requester_date_format: 10754 :param str search_text: 10755 :param str start_position: 10756 :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. 10757 :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`. 10758 :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. 10759 :param str user_filter: 10760 :param str user_id: 10761 :param str user_name: 10762 :return: EnvelopesInformation 10763 If the method is called asynchronously, 10764 returns the request thread. 10765 """ 10766 10767 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_text', 'start_position', 'status', 'to_date', 'transaction_ids', 'user_filter', 'user_id', 'user_name'] 10768 all_params.append('callback') 10769 all_params.append('_return_http_data_only') 10770 all_params.append('_preload_content') 10771 all_params.append('_request_timeout') 10772 10773 params = locals() 10774 for key, val in iteritems(params['kwargs']): 10775 if key not in all_params: 10776 raise TypeError( 10777 "Got an unexpected keyword argument '%s'" 10778 " to method list_status_changes" % key 10779 ) 10780 params[key] = val 10781 del params['kwargs'] 10782 # verify the required parameter 'account_id' is set 10783 if ('account_id' not in params) or (params['account_id'] is None): 10784 raise ValueError("Missing the required parameter `account_id` when calling `list_status_changes`") 10785 10786 10787 collection_formats = {} 10788 10789 resource_path = '/v2.1/accounts/{accountId}/envelopes'.replace('{format}', 'json') 10790 path_params = {} 10791 if 'account_id' in params: 10792 path_params['accountId'] = params['account_id'] 10793 10794 query_params = {} 10795 if 'ac_status' in params: 10796 query_params['ac_status'] = params['ac_status'] 10797 if 'block' in params: 10798 query_params['block'] = params['block'] 10799 if 'cdse_mode' in params: 10800 query_params['cdse_mode'] = params['cdse_mode'] 10801 if 'continuation_token' in params: 10802 query_params['continuation_token'] = params['continuation_token'] 10803 if 'count' in params: 10804 query_params['count'] = params['count'] 10805 if 'custom_field' in params: 10806 query_params['custom_field'] = params['custom_field'] 10807 if 'email' in params: 10808 query_params['email'] = params['email'] 10809 if 'envelope_ids' in params: 10810 query_params['envelope_ids'] = params['envelope_ids'] 10811 if 'exclude' in params: 10812 query_params['exclude'] = params['exclude'] 10813 if 'folder_ids' in params: 10814 query_params['folder_ids'] = params['folder_ids'] 10815 if 'folder_types' in params: 10816 query_params['folder_types'] = params['folder_types'] 10817 if 'from_date' in params: 10818 query_params['from_date'] = params['from_date'] 10819 if 'from_to_status' in params: 10820 query_params['from_to_status'] = params['from_to_status'] 10821 if 'include' in params: 10822 query_params['include'] = params['include'] 10823 if 'include_purge_information' in params: 10824 query_params['include_purge_information'] = params['include_purge_information'] 10825 if 'intersecting_folder_ids' in params: 10826 query_params['intersecting_folder_ids'] = params['intersecting_folder_ids'] 10827 if 'last_queried_date' in params: 10828 query_params['last_queried_date'] = params['last_queried_date'] 10829 if 'order' in params: 10830 query_params['order'] = params['order'] 10831 if 'order_by' in params: 10832 query_params['order_by'] = params['order_by'] 10833 if 'powerformids' in params: 10834 query_params['powerformids'] = params['powerformids'] 10835 if 'query_budget' in params: 10836 query_params['query_budget'] = params['query_budget'] 10837 if 'requester_date_format' in params: 10838 query_params['requester_date_format'] = params['requester_date_format'] 10839 if 'search_text' in params: 10840 query_params['search_text'] = params['search_text'] 10841 if 'start_position' in params: 10842 query_params['start_position'] = params['start_position'] 10843 if 'status' in params: 10844 query_params['status'] = params['status'] 10845 if 'to_date' in params: 10846 query_params['to_date'] = params['to_date'] 10847 if 'transaction_ids' in params: 10848 query_params['transaction_ids'] = params['transaction_ids'] 10849 if 'user_filter' in params: 10850 query_params['user_filter'] = params['user_filter'] 10851 if 'user_id' in params: 10852 query_params['user_id'] = params['user_id'] 10853 if 'user_name' in params: 10854 query_params['user_name'] = params['user_name'] 10855 10856 header_params = {} 10857 10858 form_params = [] 10859 local_var_files = {} 10860 10861 body_params = None 10862 # HTTP header `Accept` 10863 header_params['Accept'] = self.api_client.\ 10864 select_header_accept(['application/json']) 10865 10866 # Authentication setting 10867 auth_settings = [] 10868 10869 return self.api_client.call_api(resource_path, 'GET', 10870 path_params, 10871 query_params, 10872 header_params, 10873 body=body_params, 10874 post_params=form_params, 10875 files=local_var_files, 10876 response_type='EnvelopesInformation', 10877 auth_settings=auth_settings, 10878 callback=params.get('callback'), 10879 _return_http_data_only=params.get('_return_http_data_only'), 10880 _preload_content=params.get('_preload_content', True), 10881 _request_timeout=params.get('_request_timeout'), 10882 collection_formats=collection_formats) 10883 10884 def list_tabs(self, account_id, envelope_id, recipient_id, **kwargs): 10885 """ 10886 Gets the tabs information for a signer or sign-in-person recipient in an envelope. 10887 Retrieves information about the tabs associated with a recipient in a draft envelope. 10888 This method makes a synchronous HTTP request by default. To make an 10889 asynchronous HTTP request, please define a `callback` function 10890 to be invoked when receiving the response. 10891 >>> def callback_function(response): 10892 >>> pprint(response) 10893 >>> 10894 >>> thread = api.list_tabs(account_id, envelope_id, recipient_id, callback=callback_function) 10895 10896 :param callback function: The callback function 10897 for asynchronous request. (optional) 10898 :param str account_id: The external account number (int) or account ID Guid. (required) 10899 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10900 :param str recipient_id: The ID of the recipient being accessed. (required) 10901 :param str include_anchor_tab_locations: When set to **true**, all tabs with anchor tab properties are included in the response. 10902 :param str include_metadata: 10903 :return: Tabs 10904 If the method is called asynchronously, 10905 returns the request thread. 10906 """ 10907 kwargs['_return_http_data_only'] = True 10908 if kwargs.get('callback'): 10909 return self.list_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 10910 else: 10911 (data) = self.list_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 10912 return data 10913 10914 def list_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 10915 """ 10916 Gets the tabs information for a signer or sign-in-person recipient in an envelope. 10917 Retrieves information about the tabs associated with a recipient in a draft envelope. 10918 This method makes a synchronous HTTP request by default. To make an 10919 asynchronous HTTP request, please define a `callback` function 10920 to be invoked when receiving the response. 10921 >>> def callback_function(response): 10922 >>> pprint(response) 10923 >>> 10924 >>> thread = api.list_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 10925 10926 :param callback function: The callback function 10927 for asynchronous request. (optional) 10928 :param str account_id: The external account number (int) or account ID Guid. (required) 10929 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10930 :param str recipient_id: The ID of the recipient being accessed. (required) 10931 :param str include_anchor_tab_locations: When set to **true**, all tabs with anchor tab properties are included in the response. 10932 :param str include_metadata: 10933 :return: Tabs 10934 If the method is called asynchronously, 10935 returns the request thread. 10936 """ 10937 10938 all_params = ['account_id', 'envelope_id', 'recipient_id', 'include_anchor_tab_locations', 'include_metadata'] 10939 all_params.append('callback') 10940 all_params.append('_return_http_data_only') 10941 all_params.append('_preload_content') 10942 all_params.append('_request_timeout') 10943 10944 params = locals() 10945 for key, val in iteritems(params['kwargs']): 10946 if key not in all_params: 10947 raise TypeError( 10948 "Got an unexpected keyword argument '%s'" 10949 " to method list_tabs" % key 10950 ) 10951 params[key] = val 10952 del params['kwargs'] 10953 # verify the required parameter 'account_id' is set 10954 if ('account_id' not in params) or (params['account_id'] is None): 10955 raise ValueError("Missing the required parameter `account_id` when calling `list_tabs`") 10956 # verify the required parameter 'envelope_id' is set 10957 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10958 raise ValueError("Missing the required parameter `envelope_id` when calling `list_tabs`") 10959 # verify the required parameter 'recipient_id' is set 10960 if ('recipient_id' not in params) or (params['recipient_id'] is None): 10961 raise ValueError("Missing the required parameter `recipient_id` when calling `list_tabs`") 10962 10963 10964 collection_formats = {} 10965 10966 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/tabs'.replace('{format}', 'json') 10967 path_params = {} 10968 if 'account_id' in params: 10969 path_params['accountId'] = params['account_id'] 10970 if 'envelope_id' in params: 10971 path_params['envelopeId'] = params['envelope_id'] 10972 if 'recipient_id' in params: 10973 path_params['recipientId'] = params['recipient_id'] 10974 10975 query_params = {} 10976 if 'include_anchor_tab_locations' in params: 10977 query_params['include_anchor_tab_locations'] = params['include_anchor_tab_locations'] 10978 if 'include_metadata' in params: 10979 query_params['include_metadata'] = params['include_metadata'] 10980 10981 header_params = {} 10982 10983 form_params = [] 10984 local_var_files = {} 10985 10986 body_params = None 10987 # HTTP header `Accept` 10988 header_params['Accept'] = self.api_client.\ 10989 select_header_accept(['application/json']) 10990 10991 # Authentication setting 10992 auth_settings = [] 10993 10994 return self.api_client.call_api(resource_path, 'GET', 10995 path_params, 10996 query_params, 10997 header_params, 10998 body=body_params, 10999 post_params=form_params, 11000 files=local_var_files, 11001 response_type='Tabs', 11002 auth_settings=auth_settings, 11003 callback=params.get('callback'), 11004 _return_http_data_only=params.get('_return_http_data_only'), 11005 _preload_content=params.get('_preload_content', True), 11006 _request_timeout=params.get('_request_timeout'), 11007 collection_formats=collection_formats) 11008 11009 def list_templates(self, account_id, envelope_id, **kwargs): 11010 """ 11011 Get List of Templates used in an Envelope 11012 This returns a list of the server-side templates, their name and ID, used in an envelope. 11013 This method makes a synchronous HTTP request by default. To make an 11014 asynchronous HTTP request, please define a `callback` function 11015 to be invoked when receiving the response. 11016 >>> def callback_function(response): 11017 >>> pprint(response) 11018 >>> 11019 >>> thread = api.list_templates(account_id, envelope_id, callback=callback_function) 11020 11021 :param callback function: The callback function 11022 for asynchronous request. (optional) 11023 :param str account_id: The external account number (int) or account ID Guid. (required) 11024 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11025 :param str include: The possible values are: matching_applied - This returns template matching information for the template. 11026 :return: TemplateInformation 11027 If the method is called asynchronously, 11028 returns the request thread. 11029 """ 11030 kwargs['_return_http_data_only'] = True 11031 if kwargs.get('callback'): 11032 return self.list_templates_with_http_info(account_id, envelope_id, **kwargs) 11033 else: 11034 (data) = self.list_templates_with_http_info(account_id, envelope_id, **kwargs) 11035 return data 11036 11037 def list_templates_with_http_info(self, account_id, envelope_id, **kwargs): 11038 """ 11039 Get List of Templates used in an Envelope 11040 This returns a list of the server-side templates, their name and ID, used in an envelope. 11041 This method makes a synchronous HTTP request by default. To make an 11042 asynchronous HTTP request, please define a `callback` function 11043 to be invoked when receiving the response. 11044 >>> def callback_function(response): 11045 >>> pprint(response) 11046 >>> 11047 >>> thread = api.list_templates_with_http_info(account_id, envelope_id, callback=callback_function) 11048 11049 :param callback function: The callback function 11050 for asynchronous request. (optional) 11051 :param str account_id: The external account number (int) or account ID Guid. (required) 11052 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11053 :param str include: The possible values are: matching_applied - This returns template matching information for the template. 11054 :return: TemplateInformation 11055 If the method is called asynchronously, 11056 returns the request thread. 11057 """ 11058 11059 all_params = ['account_id', 'envelope_id', 'include'] 11060 all_params.append('callback') 11061 all_params.append('_return_http_data_only') 11062 all_params.append('_preload_content') 11063 all_params.append('_request_timeout') 11064 11065 params = locals() 11066 for key, val in iteritems(params['kwargs']): 11067 if key not in all_params: 11068 raise TypeError( 11069 "Got an unexpected keyword argument '%s'" 11070 " to method list_templates" % key 11071 ) 11072 params[key] = val 11073 del params['kwargs'] 11074 # verify the required parameter 'account_id' is set 11075 if ('account_id' not in params) or (params['account_id'] is None): 11076 raise ValueError("Missing the required parameter `account_id` when calling `list_templates`") 11077 # verify the required parameter 'envelope_id' is set 11078 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11079 raise ValueError("Missing the required parameter `envelope_id` when calling `list_templates`") 11080 11081 11082 collection_formats = {} 11083 11084 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/templates'.replace('{format}', 'json') 11085 path_params = {} 11086 if 'account_id' in params: 11087 path_params['accountId'] = params['account_id'] 11088 if 'envelope_id' in params: 11089 path_params['envelopeId'] = params['envelope_id'] 11090 11091 query_params = {} 11092 if 'include' in params: 11093 query_params['include'] = params['include'] 11094 11095 header_params = {} 11096 11097 form_params = [] 11098 local_var_files = {} 11099 11100 body_params = None 11101 # HTTP header `Accept` 11102 header_params['Accept'] = self.api_client.\ 11103 select_header_accept(['application/json']) 11104 11105 # Authentication setting 11106 auth_settings = [] 11107 11108 return self.api_client.call_api(resource_path, 'GET', 11109 path_params, 11110 query_params, 11111 header_params, 11112 body=body_params, 11113 post_params=form_params, 11114 files=local_var_files, 11115 response_type='TemplateInformation', 11116 auth_settings=auth_settings, 11117 callback=params.get('callback'), 11118 _return_http_data_only=params.get('_return_http_data_only'), 11119 _preload_content=params.get('_preload_content', True), 11120 _request_timeout=params.get('_request_timeout'), 11121 collection_formats=collection_formats) 11122 11123 def list_templates_for_document(self, account_id, document_id, envelope_id, **kwargs): 11124 """ 11125 Gets the templates associated with a document in an existing envelope. 11126 Retrieves the templates associated with a document in the specified envelope. 11127 This method makes a synchronous HTTP request by default. To make an 11128 asynchronous HTTP request, please define a `callback` function 11129 to be invoked when receiving the response. 11130 >>> def callback_function(response): 11131 >>> pprint(response) 11132 >>> 11133 >>> thread = api.list_templates_for_document(account_id, document_id, envelope_id, callback=callback_function) 11134 11135 :param callback function: The callback function 11136 for asynchronous request. (optional) 11137 :param str account_id: The external account number (int) or account ID Guid. (required) 11138 :param str document_id: The ID of the document being accessed. (required) 11139 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11140 :param str include: 11141 :return: TemplateInformation 11142 If the method is called asynchronously, 11143 returns the request thread. 11144 """ 11145 kwargs['_return_http_data_only'] = True 11146 if kwargs.get('callback'): 11147 return self.list_templates_for_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 11148 else: 11149 (data) = self.list_templates_for_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 11150 return data 11151 11152 def list_templates_for_document_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 11153 """ 11154 Gets the templates associated with a document in an existing envelope. 11155 Retrieves the templates associated with a document in the specified envelope. 11156 This method makes a synchronous HTTP request by default. To make an 11157 asynchronous HTTP request, please define a `callback` function 11158 to be invoked when receiving the response. 11159 >>> def callback_function(response): 11160 >>> pprint(response) 11161 >>> 11162 >>> thread = api.list_templates_for_document_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 11163 11164 :param callback function: The callback function 11165 for asynchronous request. (optional) 11166 :param str account_id: The external account number (int) or account ID Guid. (required) 11167 :param str document_id: The ID of the document being accessed. (required) 11168 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11169 :param str include: 11170 :return: TemplateInformation 11171 If the method is called asynchronously, 11172 returns the request thread. 11173 """ 11174 11175 all_params = ['account_id', 'document_id', 'envelope_id', 'include'] 11176 all_params.append('callback') 11177 all_params.append('_return_http_data_only') 11178 all_params.append('_preload_content') 11179 all_params.append('_request_timeout') 11180 11181 params = locals() 11182 for key, val in iteritems(params['kwargs']): 11183 if key not in all_params: 11184 raise TypeError( 11185 "Got an unexpected keyword argument '%s'" 11186 " to method list_templates_for_document" % key 11187 ) 11188 params[key] = val 11189 del params['kwargs'] 11190 # verify the required parameter 'account_id' is set 11191 if ('account_id' not in params) or (params['account_id'] is None): 11192 raise ValueError("Missing the required parameter `account_id` when calling `list_templates_for_document`") 11193 # verify the required parameter 'document_id' is set 11194 if ('document_id' not in params) or (params['document_id'] is None): 11195 raise ValueError("Missing the required parameter `document_id` when calling `list_templates_for_document`") 11196 # verify the required parameter 'envelope_id' is set 11197 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11198 raise ValueError("Missing the required parameter `envelope_id` when calling `list_templates_for_document`") 11199 11200 11201 collection_formats = {} 11202 11203 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/templates'.replace('{format}', 'json') 11204 path_params = {} 11205 if 'account_id' in params: 11206 path_params['accountId'] = params['account_id'] 11207 if 'document_id' in params: 11208 path_params['documentId'] = params['document_id'] 11209 if 'envelope_id' in params: 11210 path_params['envelopeId'] = params['envelope_id'] 11211 11212 query_params = {} 11213 if 'include' in params: 11214 query_params['include'] = params['include'] 11215 11216 header_params = {} 11217 11218 form_params = [] 11219 local_var_files = {} 11220 11221 body_params = None 11222 # HTTP header `Accept` 11223 header_params['Accept'] = self.api_client.\ 11224 select_header_accept(['application/json']) 11225 11226 # Authentication setting 11227 auth_settings = [] 11228 11229 return self.api_client.call_api(resource_path, 'GET', 11230 path_params, 11231 query_params, 11232 header_params, 11233 body=body_params, 11234 post_params=form_params, 11235 files=local_var_files, 11236 response_type='TemplateInformation', 11237 auth_settings=auth_settings, 11238 callback=params.get('callback'), 11239 _return_http_data_only=params.get('_return_http_data_only'), 11240 _preload_content=params.get('_preload_content', True), 11241 _request_timeout=params.get('_request_timeout'), 11242 collection_formats=collection_formats) 11243 11244 def put_attachment(self, account_id, attachment_id, envelope_id, **kwargs): 11245 """ 11246 Add an attachment to a DRAFT or IN-PROCESS envelope. 11247 Adds an attachment to a draft or in-process envelope. 11248 This method makes a synchronous HTTP request by default. To make an 11249 asynchronous HTTP request, please define a `callback` function 11250 to be invoked when receiving the response. 11251 >>> def callback_function(response): 11252 >>> pprint(response) 11253 >>> 11254 >>> thread = api.put_attachment(account_id, attachment_id, envelope_id, callback=callback_function) 11255 11256 :param callback function: The callback function 11257 for asynchronous request. (optional) 11258 :param str account_id: The external account number (int) or account ID Guid. (required) 11259 :param str attachment_id: (required) 11260 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11261 :param Attachment attachment: 11262 :return: EnvelopeAttachmentsResult 11263 If the method is called asynchronously, 11264 returns the request thread. 11265 """ 11266 kwargs['_return_http_data_only'] = True 11267 if kwargs.get('callback'): 11268 return self.put_attachment_with_http_info(account_id, attachment_id, envelope_id, **kwargs) 11269 else: 11270 (data) = self.put_attachment_with_http_info(account_id, attachment_id, envelope_id, **kwargs) 11271 return data 11272 11273 def put_attachment_with_http_info(self, account_id, attachment_id, envelope_id, **kwargs): 11274 """ 11275 Add an attachment to a DRAFT or IN-PROCESS envelope. 11276 Adds an attachment to a draft or in-process envelope. 11277 This method makes a synchronous HTTP request by default. To make an 11278 asynchronous HTTP request, please define a `callback` function 11279 to be invoked when receiving the response. 11280 >>> def callback_function(response): 11281 >>> pprint(response) 11282 >>> 11283 >>> thread = api.put_attachment_with_http_info(account_id, attachment_id, envelope_id, callback=callback_function) 11284 11285 :param callback function: The callback function 11286 for asynchronous request. (optional) 11287 :param str account_id: The external account number (int) or account ID Guid. (required) 11288 :param str attachment_id: (required) 11289 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11290 :param Attachment attachment: 11291 :return: EnvelopeAttachmentsResult 11292 If the method is called asynchronously, 11293 returns the request thread. 11294 """ 11295 11296 all_params = ['account_id', 'attachment_id', 'envelope_id', 'attachment'] 11297 all_params.append('callback') 11298 all_params.append('_return_http_data_only') 11299 all_params.append('_preload_content') 11300 all_params.append('_request_timeout') 11301 11302 params = locals() 11303 for key, val in iteritems(params['kwargs']): 11304 if key not in all_params: 11305 raise TypeError( 11306 "Got an unexpected keyword argument '%s'" 11307 " to method put_attachment" % key 11308 ) 11309 params[key] = val 11310 del params['kwargs'] 11311 # verify the required parameter 'account_id' is set 11312 if ('account_id' not in params) or (params['account_id'] is None): 11313 raise ValueError("Missing the required parameter `account_id` when calling `put_attachment`") 11314 # verify the required parameter 'attachment_id' is set 11315 if ('attachment_id' not in params) or (params['attachment_id'] is None): 11316 raise ValueError("Missing the required parameter `attachment_id` when calling `put_attachment`") 11317 # verify the required parameter 'envelope_id' is set 11318 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11319 raise ValueError("Missing the required parameter `envelope_id` when calling `put_attachment`") 11320 11321 11322 collection_formats = {} 11323 11324 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments/{attachmentId}'.replace('{format}', 'json') 11325 path_params = {} 11326 if 'account_id' in params: 11327 path_params['accountId'] = params['account_id'] 11328 if 'attachment_id' in params: 11329 path_params['attachmentId'] = params['attachment_id'] 11330 if 'envelope_id' in params: 11331 path_params['envelopeId'] = params['envelope_id'] 11332 11333 query_params = {} 11334 11335 header_params = {} 11336 11337 form_params = [] 11338 local_var_files = {} 11339 11340 body_params = None 11341 if 'attachment' in params: 11342 body_params = params['attachment'] 11343 # HTTP header `Accept` 11344 header_params['Accept'] = self.api_client.\ 11345 select_header_accept(['application/json']) 11346 11347 # Authentication setting 11348 auth_settings = [] 11349 11350 return self.api_client.call_api(resource_path, 'PUT', 11351 path_params, 11352 query_params, 11353 header_params, 11354 body=body_params, 11355 post_params=form_params, 11356 files=local_var_files, 11357 response_type='EnvelopeAttachmentsResult', 11358 auth_settings=auth_settings, 11359 callback=params.get('callback'), 11360 _return_http_data_only=params.get('_return_http_data_only'), 11361 _preload_content=params.get('_preload_content', True), 11362 _request_timeout=params.get('_request_timeout'), 11363 collection_formats=collection_formats) 11364 11365 def put_attachments(self, account_id, envelope_id, **kwargs): 11366 """ 11367 Add one or more attachments to a DRAFT or IN-PROCESS envelope. 11368 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). 11369 This method makes a synchronous HTTP request by default. To make an 11370 asynchronous HTTP request, please define a `callback` function 11371 to be invoked when receiving the response. 11372 >>> def callback_function(response): 11373 >>> pprint(response) 11374 >>> 11375 >>> thread = api.put_attachments(account_id, envelope_id, callback=callback_function) 11376 11377 :param callback function: The callback function 11378 for asynchronous request. (optional) 11379 :param str account_id: The external account number (int) or account ID Guid. (required) 11380 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11381 :param EnvelopeAttachmentsRequest envelope_attachments_request: 11382 :return: EnvelopeAttachmentsResult 11383 If the method is called asynchronously, 11384 returns the request thread. 11385 """ 11386 kwargs['_return_http_data_only'] = True 11387 if kwargs.get('callback'): 11388 return self.put_attachments_with_http_info(account_id, envelope_id, **kwargs) 11389 else: 11390 (data) = self.put_attachments_with_http_info(account_id, envelope_id, **kwargs) 11391 return data 11392 11393 def put_attachments_with_http_info(self, account_id, envelope_id, **kwargs): 11394 """ 11395 Add one or more attachments to a DRAFT or IN-PROCESS envelope. 11396 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). 11397 This method makes a synchronous HTTP request by default. To make an 11398 asynchronous HTTP request, please define a `callback` function 11399 to be invoked when receiving the response. 11400 >>> def callback_function(response): 11401 >>> pprint(response) 11402 >>> 11403 >>> thread = api.put_attachments_with_http_info(account_id, envelope_id, callback=callback_function) 11404 11405 :param callback function: The callback function 11406 for asynchronous request. (optional) 11407 :param str account_id: The external account number (int) or account ID Guid. (required) 11408 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11409 :param EnvelopeAttachmentsRequest envelope_attachments_request: 11410 :return: EnvelopeAttachmentsResult 11411 If the method is called asynchronously, 11412 returns the request thread. 11413 """ 11414 11415 all_params = ['account_id', 'envelope_id', 'envelope_attachments_request'] 11416 all_params.append('callback') 11417 all_params.append('_return_http_data_only') 11418 all_params.append('_preload_content') 11419 all_params.append('_request_timeout') 11420 11421 params = locals() 11422 for key, val in iteritems(params['kwargs']): 11423 if key not in all_params: 11424 raise TypeError( 11425 "Got an unexpected keyword argument '%s'" 11426 " to method put_attachments" % key 11427 ) 11428 params[key] = val 11429 del params['kwargs'] 11430 # verify the required parameter 'account_id' is set 11431 if ('account_id' not in params) or (params['account_id'] is None): 11432 raise ValueError("Missing the required parameter `account_id` when calling `put_attachments`") 11433 # verify the required parameter 'envelope_id' is set 11434 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11435 raise ValueError("Missing the required parameter `envelope_id` when calling `put_attachments`") 11436 11437 11438 collection_formats = {} 11439 11440 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments'.replace('{format}', 'json') 11441 path_params = {} 11442 if 'account_id' in params: 11443 path_params['accountId'] = params['account_id'] 11444 if 'envelope_id' in params: 11445 path_params['envelopeId'] = params['envelope_id'] 11446 11447 query_params = {} 11448 11449 header_params = {} 11450 11451 form_params = [] 11452 local_var_files = {} 11453 11454 body_params = None 11455 if 'envelope_attachments_request' in params: 11456 body_params = params['envelope_attachments_request'] 11457 # HTTP header `Accept` 11458 header_params['Accept'] = self.api_client.\ 11459 select_header_accept(['application/json']) 11460 11461 # Authentication setting 11462 auth_settings = [] 11463 11464 return self.api_client.call_api(resource_path, 'PUT', 11465 path_params, 11466 query_params, 11467 header_params, 11468 body=body_params, 11469 post_params=form_params, 11470 files=local_var_files, 11471 response_type='EnvelopeAttachmentsResult', 11472 auth_settings=auth_settings, 11473 callback=params.get('callback'), 11474 _return_http_data_only=params.get('_return_http_data_only'), 11475 _preload_content=params.get('_preload_content', True), 11476 _request_timeout=params.get('_request_timeout'), 11477 collection_formats=collection_formats) 11478 11479 def rotate_document_page(self, account_id, document_id, envelope_id, page_number, **kwargs): 11480 """ 11481 Rotates page image from an envelope for display. 11482 Rotates page image from an envelope for display. The page image can be rotated to the left or right. 11483 This method makes a synchronous HTTP request by default. To make an 11484 asynchronous HTTP request, please define a `callback` function 11485 to be invoked when receiving the response. 11486 >>> def callback_function(response): 11487 >>> pprint(response) 11488 >>> 11489 >>> thread = api.rotate_document_page(account_id, document_id, envelope_id, page_number, callback=callback_function) 11490 11491 :param callback function: The callback function 11492 for asynchronous request. (optional) 11493 :param str account_id: The external account number (int) or account ID Guid. (required) 11494 :param str document_id: The ID of the document being accessed. (required) 11495 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11496 :param str page_number: The page number being accessed. (required) 11497 :param PageRequest page_request: 11498 :return: None 11499 If the method is called asynchronously, 11500 returns the request thread. 11501 """ 11502 kwargs['_return_http_data_only'] = True 11503 if kwargs.get('callback'): 11504 return self.rotate_document_page_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 11505 else: 11506 (data) = self.rotate_document_page_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 11507 return data 11508 11509 def rotate_document_page_with_http_info(self, account_id, document_id, envelope_id, page_number, **kwargs): 11510 """ 11511 Rotates page image from an envelope for display. 11512 Rotates page image from an envelope for display. The page image can be rotated to the left or right. 11513 This method makes a synchronous HTTP request by default. To make an 11514 asynchronous HTTP request, please define a `callback` function 11515 to be invoked when receiving the response. 11516 >>> def callback_function(response): 11517 >>> pprint(response) 11518 >>> 11519 >>> thread = api.rotate_document_page_with_http_info(account_id, document_id, envelope_id, page_number, callback=callback_function) 11520 11521 :param callback function: The callback function 11522 for asynchronous request. (optional) 11523 :param str account_id: The external account number (int) or account ID Guid. (required) 11524 :param str document_id: The ID of the document being accessed. (required) 11525 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11526 :param str page_number: The page number being accessed. (required) 11527 :param PageRequest page_request: 11528 :return: None 11529 If the method is called asynchronously, 11530 returns the request thread. 11531 """ 11532 11533 all_params = ['account_id', 'document_id', 'envelope_id', 'page_number', 'page_request'] 11534 all_params.append('callback') 11535 all_params.append('_return_http_data_only') 11536 all_params.append('_preload_content') 11537 all_params.append('_request_timeout') 11538 11539 params = locals() 11540 for key, val in iteritems(params['kwargs']): 11541 if key not in all_params: 11542 raise TypeError( 11543 "Got an unexpected keyword argument '%s'" 11544 " to method rotate_document_page" % key 11545 ) 11546 params[key] = val 11547 del params['kwargs'] 11548 # verify the required parameter 'account_id' is set 11549 if ('account_id' not in params) or (params['account_id'] is None): 11550 raise ValueError("Missing the required parameter `account_id` when calling `rotate_document_page`") 11551 # verify the required parameter 'document_id' is set 11552 if ('document_id' not in params) or (params['document_id'] is None): 11553 raise ValueError("Missing the required parameter `document_id` when calling `rotate_document_page`") 11554 # verify the required parameter 'envelope_id' is set 11555 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11556 raise ValueError("Missing the required parameter `envelope_id` when calling `rotate_document_page`") 11557 # verify the required parameter 'page_number' is set 11558 if ('page_number' not in params) or (params['page_number'] is None): 11559 raise ValueError("Missing the required parameter `page_number` when calling `rotate_document_page`") 11560 11561 11562 collection_formats = {} 11563 11564 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/pages/{pageNumber}/page_image'.replace('{format}', 'json') 11565 path_params = {} 11566 if 'account_id' in params: 11567 path_params['accountId'] = params['account_id'] 11568 if 'document_id' in params: 11569 path_params['documentId'] = params['document_id'] 11570 if 'envelope_id' in params: 11571 path_params['envelopeId'] = params['envelope_id'] 11572 if 'page_number' in params: 11573 path_params['pageNumber'] = params['page_number'] 11574 11575 query_params = {} 11576 11577 header_params = {} 11578 11579 form_params = [] 11580 local_var_files = {} 11581 11582 body_params = None 11583 if 'page_request' in params: 11584 body_params = params['page_request'] 11585 # HTTP header `Accept` 11586 header_params['Accept'] = self.api_client.\ 11587 select_header_accept(['application/json']) 11588 11589 # Authentication setting 11590 auth_settings = [] 11591 11592 return self.api_client.call_api(resource_path, 'PUT', 11593 path_params, 11594 query_params, 11595 header_params, 11596 body=body_params, 11597 post_params=form_params, 11598 files=local_var_files, 11599 response_type=None, 11600 auth_settings=auth_settings, 11601 callback=params.get('callback'), 11602 _return_http_data_only=params.get('_return_http_data_only'), 11603 _preload_content=params.get('_preload_content', True), 11604 _request_timeout=params.get('_request_timeout'), 11605 collection_formats=collection_formats) 11606 11607 def update(self, account_id, envelope_id, **kwargs): 11608 """ 11609 Send Draft Envelope/Void Envelope/Move/Purge Envelope/Modify draft 11610 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. 11611 This method makes a synchronous HTTP request by default. To make an 11612 asynchronous HTTP request, please define a `callback` function 11613 to be invoked when receiving the response. 11614 >>> def callback_function(response): 11615 >>> pprint(response) 11616 >>> 11617 >>> thread = api.update(account_id, envelope_id, callback=callback_function) 11618 11619 :param callback function: The callback function 11620 for asynchronous request. (optional) 11621 :param str account_id: The external account number (int) or account ID Guid. (required) 11622 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11623 :param str advanced_update: When set to **true**, allows the caller to update recipients, tabs, custom fields, notification, email settings and other envelope attributes. 11624 :param str resend_envelope: When set to **true**, sends the specified envelope again. 11625 :param Envelope envelope: 11626 :return: EnvelopeUpdateSummary 11627 If the method is called asynchronously, 11628 returns the request thread. 11629 """ 11630 kwargs['_return_http_data_only'] = True 11631 if kwargs.get('callback'): 11632 return self.update_with_http_info(account_id, envelope_id, **kwargs) 11633 else: 11634 (data) = self.update_with_http_info(account_id, envelope_id, **kwargs) 11635 return data 11636 11637 def update_with_http_info(self, account_id, envelope_id, **kwargs): 11638 """ 11639 Send Draft Envelope/Void Envelope/Move/Purge Envelope/Modify draft 11640 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. 11641 This method makes a synchronous HTTP request by default. To make an 11642 asynchronous HTTP request, please define a `callback` function 11643 to be invoked when receiving the response. 11644 >>> def callback_function(response): 11645 >>> pprint(response) 11646 >>> 11647 >>> thread = api.update_with_http_info(account_id, envelope_id, callback=callback_function) 11648 11649 :param callback function: The callback function 11650 for asynchronous request. (optional) 11651 :param str account_id: The external account number (int) or account ID Guid. (required) 11652 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11653 :param str advanced_update: When set to **true**, allows the caller to update recipients, tabs, custom fields, notification, email settings and other envelope attributes. 11654 :param str resend_envelope: When set to **true**, sends the specified envelope again. 11655 :param Envelope envelope: 11656 :return: EnvelopeUpdateSummary 11657 If the method is called asynchronously, 11658 returns the request thread. 11659 """ 11660 11661 all_params = ['account_id', 'envelope_id', 'advanced_update', 'resend_envelope', 'envelope'] 11662 all_params.append('callback') 11663 all_params.append('_return_http_data_only') 11664 all_params.append('_preload_content') 11665 all_params.append('_request_timeout') 11666 11667 params = locals() 11668 for key, val in iteritems(params['kwargs']): 11669 if key not in all_params: 11670 raise TypeError( 11671 "Got an unexpected keyword argument '%s'" 11672 " to method update" % key 11673 ) 11674 params[key] = val 11675 del params['kwargs'] 11676 # verify the required parameter 'account_id' is set 11677 if ('account_id' not in params) or (params['account_id'] is None): 11678 raise ValueError("Missing the required parameter `account_id` when calling `update`") 11679 # verify the required parameter 'envelope_id' is set 11680 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11681 raise ValueError("Missing the required parameter `envelope_id` when calling `update`") 11682 11683 11684 collection_formats = {} 11685 11686 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}'.replace('{format}', 'json') 11687 path_params = {} 11688 if 'account_id' in params: 11689 path_params['accountId'] = params['account_id'] 11690 if 'envelope_id' in params: 11691 path_params['envelopeId'] = params['envelope_id'] 11692 11693 query_params = {} 11694 if 'advanced_update' in params: 11695 query_params['advanced_update'] = params['advanced_update'] 11696 if 'resend_envelope' in params: 11697 query_params['resend_envelope'] = params['resend_envelope'] 11698 11699 header_params = {} 11700 11701 form_params = [] 11702 local_var_files = {} 11703 11704 body_params = None 11705 if 'envelope' in params: 11706 body_params = params['envelope'] 11707 # HTTP header `Accept` 11708 header_params['Accept'] = self.api_client.\ 11709 select_header_accept(['application/json']) 11710 11711 # Authentication setting 11712 auth_settings = [] 11713 11714 return self.api_client.call_api(resource_path, 'PUT', 11715 path_params, 11716 query_params, 11717 header_params, 11718 body=body_params, 11719 post_params=form_params, 11720 files=local_var_files, 11721 response_type='EnvelopeUpdateSummary', 11722 auth_settings=auth_settings, 11723 callback=params.get('callback'), 11724 _return_http_data_only=params.get('_return_http_data_only'), 11725 _preload_content=params.get('_preload_content', True), 11726 _request_timeout=params.get('_request_timeout'), 11727 collection_formats=collection_formats) 11728 11729 def update_chunked_upload(self, account_id, chunked_upload_id, **kwargs): 11730 """ 11731 Integrity-Check and Commit a ChunkedUpload, readying it for use elsewhere. 11732 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. 11733 This method makes a synchronous HTTP request by default. To make an 11734 asynchronous HTTP request, please define a `callback` function 11735 to be invoked when receiving the response. 11736 >>> def callback_function(response): 11737 >>> pprint(response) 11738 >>> 11739 >>> thread = api.update_chunked_upload(account_id, chunked_upload_id, callback=callback_function) 11740 11741 :param callback function: The callback function 11742 for asynchronous request. (optional) 11743 :param str account_id: The external account number (int) or account ID Guid. (required) 11744 :param str chunked_upload_id: (required) 11745 :param str action: 11746 :return: ChunkedUploadResponse 11747 If the method is called asynchronously, 11748 returns the request thread. 11749 """ 11750 kwargs['_return_http_data_only'] = True 11751 if kwargs.get('callback'): 11752 return self.update_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 11753 else: 11754 (data) = self.update_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 11755 return data 11756 11757 def update_chunked_upload_with_http_info(self, account_id, chunked_upload_id, **kwargs): 11758 """ 11759 Integrity-Check and Commit a ChunkedUpload, readying it for use elsewhere. 11760 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. 11761 This method makes a synchronous HTTP request by default. To make an 11762 asynchronous HTTP request, please define a `callback` function 11763 to be invoked when receiving the response. 11764 >>> def callback_function(response): 11765 >>> pprint(response) 11766 >>> 11767 >>> thread = api.update_chunked_upload_with_http_info(account_id, chunked_upload_id, callback=callback_function) 11768 11769 :param callback function: The callback function 11770 for asynchronous request. (optional) 11771 :param str account_id: The external account number (int) or account ID Guid. (required) 11772 :param str chunked_upload_id: (required) 11773 :param str action: 11774 :return: ChunkedUploadResponse 11775 If the method is called asynchronously, 11776 returns the request thread. 11777 """ 11778 11779 all_params = ['account_id', 'chunked_upload_id', 'action'] 11780 all_params.append('callback') 11781 all_params.append('_return_http_data_only') 11782 all_params.append('_preload_content') 11783 all_params.append('_request_timeout') 11784 11785 params = locals() 11786 for key, val in iteritems(params['kwargs']): 11787 if key not in all_params: 11788 raise TypeError( 11789 "Got an unexpected keyword argument '%s'" 11790 " to method update_chunked_upload" % key 11791 ) 11792 params[key] = val 11793 del params['kwargs'] 11794 # verify the required parameter 'account_id' is set 11795 if ('account_id' not in params) or (params['account_id'] is None): 11796 raise ValueError("Missing the required parameter `account_id` when calling `update_chunked_upload`") 11797 # verify the required parameter 'chunked_upload_id' is set 11798 if ('chunked_upload_id' not in params) or (params['chunked_upload_id'] is None): 11799 raise ValueError("Missing the required parameter `chunked_upload_id` when calling `update_chunked_upload`") 11800 11801 11802 collection_formats = {} 11803 11804 resource_path = '/v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}'.replace('{format}', 'json') 11805 path_params = {} 11806 if 'account_id' in params: 11807 path_params['accountId'] = params['account_id'] 11808 if 'chunked_upload_id' in params: 11809 path_params['chunkedUploadId'] = params['chunked_upload_id'] 11810 11811 query_params = {} 11812 if 'action' in params: 11813 query_params['action'] = params['action'] 11814 11815 header_params = {} 11816 11817 form_params = [] 11818 local_var_files = {} 11819 11820 body_params = None 11821 # HTTP header `Accept` 11822 header_params['Accept'] = self.api_client.\ 11823 select_header_accept(['application/json']) 11824 11825 # Authentication setting 11826 auth_settings = [] 11827 11828 return self.api_client.call_api(resource_path, 'PUT', 11829 path_params, 11830 query_params, 11831 header_params, 11832 body=body_params, 11833 post_params=form_params, 11834 files=local_var_files, 11835 response_type='ChunkedUploadResponse', 11836 auth_settings=auth_settings, 11837 callback=params.get('callback'), 11838 _return_http_data_only=params.get('_return_http_data_only'), 11839 _preload_content=params.get('_preload_content', True), 11840 _request_timeout=params.get('_request_timeout'), 11841 collection_formats=collection_formats) 11842 11843 def update_chunked_upload_part(self, account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs): 11844 """ 11845 Add a chunk, a chunk 'part', to an existing ChunkedUpload. 11846 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. 11847 This method makes a synchronous HTTP request by default. To make an 11848 asynchronous HTTP request, please define a `callback` function 11849 to be invoked when receiving the response. 11850 >>> def callback_function(response): 11851 >>> pprint(response) 11852 >>> 11853 >>> thread = api.update_chunked_upload_part(account_id, chunked_upload_id, chunked_upload_part_seq, callback=callback_function) 11854 11855 :param callback function: The callback function 11856 for asynchronous request. (optional) 11857 :param str account_id: The external account number (int) or account ID Guid. (required) 11858 :param str chunked_upload_id: (required) 11859 :param str chunked_upload_part_seq: (required) 11860 :param ChunkedUploadRequest chunked_upload_request: 11861 :return: ChunkedUploadResponse 11862 If the method is called asynchronously, 11863 returns the request thread. 11864 """ 11865 kwargs['_return_http_data_only'] = True 11866 if kwargs.get('callback'): 11867 return self.update_chunked_upload_part_with_http_info(account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs) 11868 else: 11869 (data) = self.update_chunked_upload_part_with_http_info(account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs) 11870 return data 11871 11872 def update_chunked_upload_part_with_http_info(self, account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs): 11873 """ 11874 Add a chunk, a chunk 'part', to an existing ChunkedUpload. 11875 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. 11876 This method makes a synchronous HTTP request by default. To make an 11877 asynchronous HTTP request, please define a `callback` function 11878 to be invoked when receiving the response. 11879 >>> def callback_function(response): 11880 >>> pprint(response) 11881 >>> 11882 >>> thread = api.update_chunked_upload_part_with_http_info(account_id, chunked_upload_id, chunked_upload_part_seq, callback=callback_function) 11883 11884 :param callback function: The callback function 11885 for asynchronous request. (optional) 11886 :param str account_id: The external account number (int) or account ID Guid. (required) 11887 :param str chunked_upload_id: (required) 11888 :param str chunked_upload_part_seq: (required) 11889 :param ChunkedUploadRequest chunked_upload_request: 11890 :return: ChunkedUploadResponse 11891 If the method is called asynchronously, 11892 returns the request thread. 11893 """ 11894 11895 all_params = ['account_id', 'chunked_upload_id', 'chunked_upload_part_seq', 'chunked_upload_request'] 11896 all_params.append('callback') 11897 all_params.append('_return_http_data_only') 11898 all_params.append('_preload_content') 11899 all_params.append('_request_timeout') 11900 11901 params = locals() 11902 for key, val in iteritems(params['kwargs']): 11903 if key not in all_params: 11904 raise TypeError( 11905 "Got an unexpected keyword argument '%s'" 11906 " to method update_chunked_upload_part" % key 11907 ) 11908 params[key] = val 11909 del params['kwargs'] 11910 # verify the required parameter 'account_id' is set 11911 if ('account_id' not in params) or (params['account_id'] is None): 11912 raise ValueError("Missing the required parameter `account_id` when calling `update_chunked_upload_part`") 11913 # verify the required parameter 'chunked_upload_id' is set 11914 if ('chunked_upload_id' not in params) or (params['chunked_upload_id'] is None): 11915 raise ValueError("Missing the required parameter `chunked_upload_id` when calling `update_chunked_upload_part`") 11916 # verify the required parameter 'chunked_upload_part_seq' is set 11917 if ('chunked_upload_part_seq' not in params) or (params['chunked_upload_part_seq'] is None): 11918 raise ValueError("Missing the required parameter `chunked_upload_part_seq` when calling `update_chunked_upload_part`") 11919 11920 11921 collection_formats = {} 11922 11923 resource_path = '/v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}/{chunkedUploadPartSeq}'.replace('{format}', 'json') 11924 path_params = {} 11925 if 'account_id' in params: 11926 path_params['accountId'] = params['account_id'] 11927 if 'chunked_upload_id' in params: 11928 path_params['chunkedUploadId'] = params['chunked_upload_id'] 11929 if 'chunked_upload_part_seq' in params: 11930 path_params['chunkedUploadPartSeq'] = params['chunked_upload_part_seq'] 11931 11932 query_params = {} 11933 11934 header_params = {} 11935 11936 form_params = [] 11937 local_var_files = {} 11938 11939 body_params = None 11940 if 'chunked_upload_request' in params: 11941 body_params = params['chunked_upload_request'] 11942 # HTTP header `Accept` 11943 header_params['Accept'] = self.api_client.\ 11944 select_header_accept(['application/json']) 11945 11946 # Authentication setting 11947 auth_settings = [] 11948 11949 return self.api_client.call_api(resource_path, 'PUT', 11950 path_params, 11951 query_params, 11952 header_params, 11953 body=body_params, 11954 post_params=form_params, 11955 files=local_var_files, 11956 response_type='ChunkedUploadResponse', 11957 auth_settings=auth_settings, 11958 callback=params.get('callback'), 11959 _return_http_data_only=params.get('_return_http_data_only'), 11960 _preload_content=params.get('_preload_content', True), 11961 _request_timeout=params.get('_request_timeout'), 11962 collection_formats=collection_formats) 11963 11964 def update_custom_fields(self, account_id, envelope_id, **kwargs): 11965 """ 11966 Updates envelope custom fields in an envelope. 11967 Updates the envelope custom fields in draft and in-process envelopes. Each custom field used in an envelope must have a unique name. 11968 This method makes a synchronous HTTP request by default. To make an 11969 asynchronous HTTP request, please define a `callback` function 11970 to be invoked when receiving the response. 11971 >>> def callback_function(response): 11972 >>> pprint(response) 11973 >>> 11974 >>> thread = api.update_custom_fields(account_id, envelope_id, callback=callback_function) 11975 11976 :param callback function: The callback function 11977 for asynchronous request. (optional) 11978 :param str account_id: The external account number (int) or account ID Guid. (required) 11979 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11980 :param CustomFields custom_fields: 11981 :return: CustomFields 11982 If the method is called asynchronously, 11983 returns the request thread. 11984 """ 11985 kwargs['_return_http_data_only'] = True 11986 if kwargs.get('callback'): 11987 return self.update_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 11988 else: 11989 (data) = self.update_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 11990 return data 11991 11992 def update_custom_fields_with_http_info(self, account_id, envelope_id, **kwargs): 11993 """ 11994 Updates envelope custom fields in an envelope. 11995 Updates the envelope custom fields in draft and in-process envelopes. Each custom field used in an envelope must have a unique name. 11996 This method makes a synchronous HTTP request by default. To make an 11997 asynchronous HTTP request, please define a `callback` function 11998 to be invoked when receiving the response. 11999 >>> def callback_function(response): 12000 >>> pprint(response) 12001 >>> 12002 >>> thread = api.update_custom_fields_with_http_info(account_id, envelope_id, callback=callback_function) 12003 12004 :param callback function: The callback function 12005 for asynchronous request. (optional) 12006 :param str account_id: The external account number (int) or account ID Guid. (required) 12007 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12008 :param CustomFields custom_fields: 12009 :return: CustomFields 12010 If the method is called asynchronously, 12011 returns the request thread. 12012 """ 12013 12014 all_params = ['account_id', 'envelope_id', 'custom_fields'] 12015 all_params.append('callback') 12016 all_params.append('_return_http_data_only') 12017 all_params.append('_preload_content') 12018 all_params.append('_request_timeout') 12019 12020 params = locals() 12021 for key, val in iteritems(params['kwargs']): 12022 if key not in all_params: 12023 raise TypeError( 12024 "Got an unexpected keyword argument '%s'" 12025 " to method update_custom_fields" % key 12026 ) 12027 params[key] = val 12028 del params['kwargs'] 12029 # verify the required parameter 'account_id' is set 12030 if ('account_id' not in params) or (params['account_id'] is None): 12031 raise ValueError("Missing the required parameter `account_id` when calling `update_custom_fields`") 12032 # verify the required parameter 'envelope_id' is set 12033 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12034 raise ValueError("Missing the required parameter `envelope_id` when calling `update_custom_fields`") 12035 12036 12037 collection_formats = {} 12038 12039 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/custom_fields'.replace('{format}', 'json') 12040 path_params = {} 12041 if 'account_id' in params: 12042 path_params['accountId'] = params['account_id'] 12043 if 'envelope_id' in params: 12044 path_params['envelopeId'] = params['envelope_id'] 12045 12046 query_params = {} 12047 12048 header_params = {} 12049 12050 form_params = [] 12051 local_var_files = {} 12052 12053 body_params = None 12054 if 'custom_fields' in params: 12055 body_params = params['custom_fields'] 12056 # HTTP header `Accept` 12057 header_params['Accept'] = self.api_client.\ 12058 select_header_accept(['application/json']) 12059 12060 # Authentication setting 12061 auth_settings = [] 12062 12063 return self.api_client.call_api(resource_path, 'PUT', 12064 path_params, 12065 query_params, 12066 header_params, 12067 body=body_params, 12068 post_params=form_params, 12069 files=local_var_files, 12070 response_type='CustomFields', 12071 auth_settings=auth_settings, 12072 callback=params.get('callback'), 12073 _return_http_data_only=params.get('_return_http_data_only'), 12074 _preload_content=params.get('_preload_content', True), 12075 _request_timeout=params.get('_request_timeout'), 12076 collection_formats=collection_formats) 12077 12078 def update_document(self, account_id, document_id, envelope_id, document_file_bytes, **kwargs): 12079 """ 12080 Adds a document to an existing draft envelope. 12081 Adds a document to an existing draft envelope. 12082 This method makes a synchronous HTTP request by default. To make an 12083 asynchronous HTTP request, please define a `callback` function 12084 to be invoked when receiving the response. 12085 >>> def callback_function(response): 12086 >>> pprint(response) 12087 >>> 12088 >>> thread = api.update_document(account_id, document_id, envelope_id, document_file_bytes, callback=callback_function) 12089 12090 :param callback function: The callback function 12091 for asynchronous request. (optional) 12092 :param str account_id: The external account number (int) or account ID Guid. (required) 12093 :param str document_id: The ID of the document being accessed. (required) 12094 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12095 :param str document_file_bytes: Updated document content. (required) 12096 :return: EnvelopeDocument 12097 If the method is called asynchronously, 12098 returns the request thread. 12099 """ 12100 kwargs['_return_http_data_only'] = True 12101 if kwargs.get('callback'): 12102 return self.update_document_with_http_info(account_id, document_id, envelope_id, document_file_bytes, **kwargs) 12103 else: 12104 (data) = self.update_document_with_http_info(account_id, document_id, envelope_id, document_file_bytes, **kwargs) 12105 return data 12106 12107 def update_document_with_http_info(self, account_id, document_id, envelope_id, document_file_bytes, **kwargs): 12108 """ 12109 Adds a document to an existing draft envelope. 12110 Adds a document to an existing draft envelope. 12111 This method makes a synchronous HTTP request by default. To make an 12112 asynchronous HTTP request, please define a `callback` function 12113 to be invoked when receiving the response. 12114 >>> def callback_function(response): 12115 >>> pprint(response) 12116 >>> 12117 >>> thread = api.update_document_with_http_info(account_id, document_id, envelope_id, document_file_bytes, callback=callback_function) 12118 12119 :param callback function: The callback function 12120 for asynchronous request. (optional) 12121 :param str account_id: The external account number (int) or account ID Guid. (required) 12122 :param str document_id: The ID of the document being accessed. (required) 12123 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12124 :param str document_file_bytes: Updated document content. (required) 12125 :return: EnvelopeDocument 12126 If the method is called asynchronously, 12127 returns the request thread. 12128 """ 12129 12130 all_params = ['account_id', 'document_id', 'envelope_id', 'document_file_bytes'] 12131 all_params.append('callback') 12132 all_params.append('_return_http_data_only') 12133 all_params.append('_preload_content') 12134 all_params.append('_request_timeout') 12135 12136 params = locals() 12137 for key, val in iteritems(params['kwargs']): 12138 if key not in all_params: 12139 raise TypeError( 12140 "Got an unexpected keyword argument '%s'" 12141 " to method update_document" % key 12142 ) 12143 params[key] = val 12144 del params['kwargs'] 12145 # verify the required parameter 'account_id' is set 12146 if ('account_id' not in params) or (params['account_id'] is None): 12147 raise ValueError("Missing the required parameter `account_id` when calling `update_document`") 12148 # verify the required parameter 'document_id' is set 12149 if ('document_id' not in params) or (params['document_id'] is None): 12150 raise ValueError("Missing the required parameter `document_id` when calling `update_document`") 12151 # verify the required parameter 'envelope_id' is set 12152 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12153 raise ValueError("Missing the required parameter `envelope_id` when calling `update_document`") 12154 # verify the required parameter 'document_file_bytes' is set 12155 if ('document_file_bytes' not in params) or (params['document_file_bytes'] is None): 12156 raise ValueError("Missing the required parameter `document_file_bytes` when calling `update_document`") 12157 12158 12159 collection_formats = {} 12160 12161 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}'.replace('{format}', 'json') 12162 path_params = {} 12163 if 'account_id' in params: 12164 path_params['accountId'] = params['account_id'] 12165 if 'document_id' in params: 12166 path_params['documentId'] = params['document_id'] 12167 if 'envelope_id' in params: 12168 path_params['envelopeId'] = params['envelope_id'] 12169 12170 query_params = {} 12171 12172 header_params = {} 12173 12174 form_params = [] 12175 local_var_files = {} 12176 12177 body_params = None 12178 if 'document_file_bytes' in params: 12179 body_params = params['document_file_bytes'] 12180 # HTTP header `Accept` 12181 header_params['Accept'] = self.api_client.\ 12182 select_header_accept(['application/json']) 12183 12184 # HTTP header `Content-Type` 12185 header_params['Content-Type'] = self.api_client.\ 12186 select_header_content_type(['application/pdf']) 12187 12188 # Authentication setting 12189 auth_settings = [] 12190 12191 return self.api_client.call_api(resource_path, 'PUT', 12192 path_params, 12193 query_params, 12194 header_params, 12195 body=body_params, 12196 post_params=form_params, 12197 files=local_var_files, 12198 response_type='EnvelopeDocument', 12199 auth_settings=auth_settings, 12200 callback=params.get('callback'), 12201 _return_http_data_only=params.get('_return_http_data_only'), 12202 _preload_content=params.get('_preload_content', True), 12203 _request_timeout=params.get('_request_timeout'), 12204 collection_formats=collection_formats) 12205 12206 def update_document_fields(self, account_id, document_id, envelope_id, **kwargs): 12207 """ 12208 Updates existing custom document fields in an existing envelope document. 12209 Updates existing custom document fields in an existing envelope document. 12210 This method makes a synchronous HTTP request by default. To make an 12211 asynchronous HTTP request, please define a `callback` function 12212 to be invoked when receiving the response. 12213 >>> def callback_function(response): 12214 >>> pprint(response) 12215 >>> 12216 >>> thread = api.update_document_fields(account_id, document_id, envelope_id, callback=callback_function) 12217 12218 :param callback function: The callback function 12219 for asynchronous request. (optional) 12220 :param str account_id: The external account number (int) or account ID Guid. (required) 12221 :param str document_id: The ID of the document being accessed. (required) 12222 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12223 :param DocumentFieldsInformation document_fields_information: 12224 :return: DocumentFieldsInformation 12225 If the method is called asynchronously, 12226 returns the request thread. 12227 """ 12228 kwargs['_return_http_data_only'] = True 12229 if kwargs.get('callback'): 12230 return self.update_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 12231 else: 12232 (data) = self.update_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 12233 return data 12234 12235 def update_document_fields_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 12236 """ 12237 Updates existing custom document fields in an existing envelope document. 12238 Updates existing custom document fields in an existing envelope document. 12239 This method makes a synchronous HTTP request by default. To make an 12240 asynchronous HTTP request, please define a `callback` function 12241 to be invoked when receiving the response. 12242 >>> def callback_function(response): 12243 >>> pprint(response) 12244 >>> 12245 >>> thread = api.update_document_fields_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 12246 12247 :param callback function: The callback function 12248 for asynchronous request. (optional) 12249 :param str account_id: The external account number (int) or account ID Guid. (required) 12250 :param str document_id: The ID of the document being accessed. (required) 12251 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12252 :param DocumentFieldsInformation document_fields_information: 12253 :return: DocumentFieldsInformation 12254 If the method is called asynchronously, 12255 returns the request thread. 12256 """ 12257 12258 all_params = ['account_id', 'document_id', 'envelope_id', 'document_fields_information'] 12259 all_params.append('callback') 12260 all_params.append('_return_http_data_only') 12261 all_params.append('_preload_content') 12262 all_params.append('_request_timeout') 12263 12264 params = locals() 12265 for key, val in iteritems(params['kwargs']): 12266 if key not in all_params: 12267 raise TypeError( 12268 "Got an unexpected keyword argument '%s'" 12269 " to method update_document_fields" % key 12270 ) 12271 params[key] = val 12272 del params['kwargs'] 12273 # verify the required parameter 'account_id' is set 12274 if ('account_id' not in params) or (params['account_id'] is None): 12275 raise ValueError("Missing the required parameter `account_id` when calling `update_document_fields`") 12276 # verify the required parameter 'document_id' is set 12277 if ('document_id' not in params) or (params['document_id'] is None): 12278 raise ValueError("Missing the required parameter `document_id` when calling `update_document_fields`") 12279 # verify the required parameter 'envelope_id' is set 12280 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12281 raise ValueError("Missing the required parameter `envelope_id` when calling `update_document_fields`") 12282 12283 12284 collection_formats = {} 12285 12286 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/fields'.replace('{format}', 'json') 12287 path_params = {} 12288 if 'account_id' in params: 12289 path_params['accountId'] = params['account_id'] 12290 if 'document_id' in params: 12291 path_params['documentId'] = params['document_id'] 12292 if 'envelope_id' in params: 12293 path_params['envelopeId'] = params['envelope_id'] 12294 12295 query_params = {} 12296 12297 header_params = {} 12298 12299 form_params = [] 12300 local_var_files = {} 12301 12302 body_params = None 12303 if 'document_fields_information' in params: 12304 body_params = params['document_fields_information'] 12305 # HTTP header `Accept` 12306 header_params['Accept'] = self.api_client.\ 12307 select_header_accept(['application/json']) 12308 12309 # Authentication setting 12310 auth_settings = [] 12311 12312 return self.api_client.call_api(resource_path, 'PUT', 12313 path_params, 12314 query_params, 12315 header_params, 12316 body=body_params, 12317 post_params=form_params, 12318 files=local_var_files, 12319 response_type='DocumentFieldsInformation', 12320 auth_settings=auth_settings, 12321 callback=params.get('callback'), 12322 _return_http_data_only=params.get('_return_http_data_only'), 12323 _preload_content=params.get('_preload_content', True), 12324 _request_timeout=params.get('_request_timeout'), 12325 collection_formats=collection_formats) 12326 12327 def update_document_tabs(self, account_id, document_id, envelope_id, **kwargs): 12328 """ 12329 Updates the tabs for an envelope document 12330 Updates tabs in the document specified by `documentId` in the envelope specified by `envelopeId`. 12331 This method makes a synchronous HTTP request by default. To make an 12332 asynchronous HTTP request, please define a `callback` function 12333 to be invoked when receiving the response. 12334 >>> def callback_function(response): 12335 >>> pprint(response) 12336 >>> 12337 >>> thread = api.update_document_tabs(account_id, document_id, envelope_id, callback=callback_function) 12338 12339 :param callback function: The callback function 12340 for asynchronous request. (optional) 12341 :param str account_id: The external account number (int) or account ID Guid. (required) 12342 :param str document_id: The ID of the document being accessed. (required) 12343 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12344 :param Tabs tabs: 12345 :return: Tabs 12346 If the method is called asynchronously, 12347 returns the request thread. 12348 """ 12349 kwargs['_return_http_data_only'] = True 12350 if kwargs.get('callback'): 12351 return self.update_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 12352 else: 12353 (data) = self.update_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 12354 return data 12355 12356 def update_document_tabs_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 12357 """ 12358 Updates the tabs for an envelope document 12359 Updates tabs in the document specified by `documentId` in the envelope specified by `envelopeId`. 12360 This method makes a synchronous HTTP request by default. To make an 12361 asynchronous HTTP request, please define a `callback` function 12362 to be invoked when receiving the response. 12363 >>> def callback_function(response): 12364 >>> pprint(response) 12365 >>> 12366 >>> thread = api.update_document_tabs_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 12367 12368 :param callback function: The callback function 12369 for asynchronous request. (optional) 12370 :param str account_id: The external account number (int) or account ID Guid. (required) 12371 :param str document_id: The ID of the document being accessed. (required) 12372 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12373 :param Tabs tabs: 12374 :return: Tabs 12375 If the method is called asynchronously, 12376 returns the request thread. 12377 """ 12378 12379 all_params = ['account_id', 'document_id', 'envelope_id', 'tabs'] 12380 all_params.append('callback') 12381 all_params.append('_return_http_data_only') 12382 all_params.append('_preload_content') 12383 all_params.append('_request_timeout') 12384 12385 params = locals() 12386 for key, val in iteritems(params['kwargs']): 12387 if key not in all_params: 12388 raise TypeError( 12389 "Got an unexpected keyword argument '%s'" 12390 " to method update_document_tabs" % key 12391 ) 12392 params[key] = val 12393 del params['kwargs'] 12394 # verify the required parameter 'account_id' is set 12395 if ('account_id' not in params) or (params['account_id'] is None): 12396 raise ValueError("Missing the required parameter `account_id` when calling `update_document_tabs`") 12397 # verify the required parameter 'document_id' is set 12398 if ('document_id' not in params) or (params['document_id'] is None): 12399 raise ValueError("Missing the required parameter `document_id` when calling `update_document_tabs`") 12400 # verify the required parameter 'envelope_id' is set 12401 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12402 raise ValueError("Missing the required parameter `envelope_id` when calling `update_document_tabs`") 12403 12404 12405 collection_formats = {} 12406 12407 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/tabs'.replace('{format}', 'json') 12408 path_params = {} 12409 if 'account_id' in params: 12410 path_params['accountId'] = params['account_id'] 12411 if 'document_id' in params: 12412 path_params['documentId'] = params['document_id'] 12413 if 'envelope_id' in params: 12414 path_params['envelopeId'] = params['envelope_id'] 12415 12416 query_params = {} 12417 12418 header_params = {} 12419 12420 form_params = [] 12421 local_var_files = {} 12422 12423 body_params = None 12424 if 'tabs' in params: 12425 body_params = params['tabs'] 12426 # HTTP header `Accept` 12427 header_params['Accept'] = self.api_client.\ 12428 select_header_accept(['application/json']) 12429 12430 # Authentication setting 12431 auth_settings = [] 12432 12433 return self.api_client.call_api(resource_path, 'PUT', 12434 path_params, 12435 query_params, 12436 header_params, 12437 body=body_params, 12438 post_params=form_params, 12439 files=local_var_files, 12440 response_type='Tabs', 12441 auth_settings=auth_settings, 12442 callback=params.get('callback'), 12443 _return_http_data_only=params.get('_return_http_data_only'), 12444 _preload_content=params.get('_preload_content', True), 12445 _request_timeout=params.get('_request_timeout'), 12446 collection_formats=collection_formats) 12447 12448 def update_documents(self, account_id, envelope_id, **kwargs): 12449 """ 12450 Adds one or more documents to an existing envelope document. 12451 Adds one or more documents to an existing envelope document. 12452 This method makes a synchronous HTTP request by default. To make an 12453 asynchronous HTTP request, please define a `callback` function 12454 to be invoked when receiving the response. 12455 >>> def callback_function(response): 12456 >>> pprint(response) 12457 >>> 12458 >>> thread = api.update_documents(account_id, envelope_id, callback=callback_function) 12459 12460 :param callback function: The callback function 12461 for asynchronous request. (optional) 12462 :param str account_id: The external account number (int) or account ID Guid. (required) 12463 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12464 :param EnvelopeDefinition envelope_definition: 12465 :return: EnvelopeDocumentsResult 12466 If the method is called asynchronously, 12467 returns the request thread. 12468 """ 12469 kwargs['_return_http_data_only'] = True 12470 if kwargs.get('callback'): 12471 return self.update_documents_with_http_info(account_id, envelope_id, **kwargs) 12472 else: 12473 (data) = self.update_documents_with_http_info(account_id, envelope_id, **kwargs) 12474 return data 12475 12476 def update_documents_with_http_info(self, account_id, envelope_id, **kwargs): 12477 """ 12478 Adds one or more documents to an existing envelope document. 12479 Adds one or more documents to an existing envelope document. 12480 This method makes a synchronous HTTP request by default. To make an 12481 asynchronous HTTP request, please define a `callback` function 12482 to be invoked when receiving the response. 12483 >>> def callback_function(response): 12484 >>> pprint(response) 12485 >>> 12486 >>> thread = api.update_documents_with_http_info(account_id, envelope_id, callback=callback_function) 12487 12488 :param callback function: The callback function 12489 for asynchronous request. (optional) 12490 :param str account_id: The external account number (int) or account ID Guid. (required) 12491 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12492 :param EnvelopeDefinition envelope_definition: 12493 :return: EnvelopeDocumentsResult 12494 If the method is called asynchronously, 12495 returns the request thread. 12496 """ 12497 12498 all_params = ['account_id', 'envelope_id', 'envelope_definition'] 12499 all_params.append('callback') 12500 all_params.append('_return_http_data_only') 12501 all_params.append('_preload_content') 12502 all_params.append('_request_timeout') 12503 12504 params = locals() 12505 for key, val in iteritems(params['kwargs']): 12506 if key not in all_params: 12507 raise TypeError( 12508 "Got an unexpected keyword argument '%s'" 12509 " to method update_documents" % key 12510 ) 12511 params[key] = val 12512 del params['kwargs'] 12513 # verify the required parameter 'account_id' is set 12514 if ('account_id' not in params) or (params['account_id'] is None): 12515 raise ValueError("Missing the required parameter `account_id` when calling `update_documents`") 12516 # verify the required parameter 'envelope_id' is set 12517 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12518 raise ValueError("Missing the required parameter `envelope_id` when calling `update_documents`") 12519 12520 12521 collection_formats = {} 12522 12523 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents'.replace('{format}', 'json') 12524 path_params = {} 12525 if 'account_id' in params: 12526 path_params['accountId'] = params['account_id'] 12527 if 'envelope_id' in params: 12528 path_params['envelopeId'] = params['envelope_id'] 12529 12530 query_params = {} 12531 12532 header_params = {} 12533 12534 form_params = [] 12535 local_var_files = {} 12536 12537 body_params = None 12538 if 'envelope_definition' in params: 12539 body_params = params['envelope_definition'] 12540 # HTTP header `Accept` 12541 header_params['Accept'] = self.api_client.\ 12542 select_header_accept(['application/json']) 12543 12544 # Authentication setting 12545 auth_settings = [] 12546 12547 return self.api_client.call_api(resource_path, 'PUT', 12548 path_params, 12549 query_params, 12550 header_params, 12551 body=body_params, 12552 post_params=form_params, 12553 files=local_var_files, 12554 response_type='EnvelopeDocumentsResult', 12555 auth_settings=auth_settings, 12556 callback=params.get('callback'), 12557 _return_http_data_only=params.get('_return_http_data_only'), 12558 _preload_content=params.get('_preload_content', True), 12559 _request_timeout=params.get('_request_timeout'), 12560 collection_formats=collection_formats) 12561 12562 def update_email_settings(self, account_id, envelope_id, **kwargs): 12563 """ 12564 Updates the email setting overrides for an envelope. 12565 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. 12566 This method makes a synchronous HTTP request by default. To make an 12567 asynchronous HTTP request, please define a `callback` function 12568 to be invoked when receiving the response. 12569 >>> def callback_function(response): 12570 >>> pprint(response) 12571 >>> 12572 >>> thread = api.update_email_settings(account_id, envelope_id, callback=callback_function) 12573 12574 :param callback function: The callback function 12575 for asynchronous request. (optional) 12576 :param str account_id: The external account number (int) or account ID Guid. (required) 12577 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12578 :param EmailSettings email_settings: 12579 :return: EmailSettings 12580 If the method is called asynchronously, 12581 returns the request thread. 12582 """ 12583 kwargs['_return_http_data_only'] = True 12584 if kwargs.get('callback'): 12585 return self.update_email_settings_with_http_info(account_id, envelope_id, **kwargs) 12586 else: 12587 (data) = self.update_email_settings_with_http_info(account_id, envelope_id, **kwargs) 12588 return data 12589 12590 def update_email_settings_with_http_info(self, account_id, envelope_id, **kwargs): 12591 """ 12592 Updates the email setting overrides for an envelope. 12593 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. 12594 This method makes a synchronous HTTP request by default. To make an 12595 asynchronous HTTP request, please define a `callback` function 12596 to be invoked when receiving the response. 12597 >>> def callback_function(response): 12598 >>> pprint(response) 12599 >>> 12600 >>> thread = api.update_email_settings_with_http_info(account_id, envelope_id, callback=callback_function) 12601 12602 :param callback function: The callback function 12603 for asynchronous request. (optional) 12604 :param str account_id: The external account number (int) or account ID Guid. (required) 12605 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12606 :param EmailSettings email_settings: 12607 :return: EmailSettings 12608 If the method is called asynchronously, 12609 returns the request thread. 12610 """ 12611 12612 all_params = ['account_id', 'envelope_id', 'email_settings'] 12613 all_params.append('callback') 12614 all_params.append('_return_http_data_only') 12615 all_params.append('_preload_content') 12616 all_params.append('_request_timeout') 12617 12618 params = locals() 12619 for key, val in iteritems(params['kwargs']): 12620 if key not in all_params: 12621 raise TypeError( 12622 "Got an unexpected keyword argument '%s'" 12623 " to method update_email_settings" % key 12624 ) 12625 params[key] = val 12626 del params['kwargs'] 12627 # verify the required parameter 'account_id' is set 12628 if ('account_id' not in params) or (params['account_id'] is None): 12629 raise ValueError("Missing the required parameter `account_id` when calling `update_email_settings`") 12630 # verify the required parameter 'envelope_id' is set 12631 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12632 raise ValueError("Missing the required parameter `envelope_id` when calling `update_email_settings`") 12633 12634 12635 collection_formats = {} 12636 12637 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/email_settings'.replace('{format}', 'json') 12638 path_params = {} 12639 if 'account_id' in params: 12640 path_params['accountId'] = params['account_id'] 12641 if 'envelope_id' in params: 12642 path_params['envelopeId'] = params['envelope_id'] 12643 12644 query_params = {} 12645 12646 header_params = {} 12647 12648 form_params = [] 12649 local_var_files = {} 12650 12651 body_params = None 12652 if 'email_settings' in params: 12653 body_params = params['email_settings'] 12654 # HTTP header `Accept` 12655 header_params['Accept'] = self.api_client.\ 12656 select_header_accept(['application/json']) 12657 12658 # Authentication setting 12659 auth_settings = [] 12660 12661 return self.api_client.call_api(resource_path, 'PUT', 12662 path_params, 12663 query_params, 12664 header_params, 12665 body=body_params, 12666 post_params=form_params, 12667 files=local_var_files, 12668 response_type='EmailSettings', 12669 auth_settings=auth_settings, 12670 callback=params.get('callback'), 12671 _return_http_data_only=params.get('_return_http_data_only'), 12672 _preload_content=params.get('_preload_content', True), 12673 _request_timeout=params.get('_request_timeout'), 12674 collection_formats=collection_formats) 12675 12676 def update_envelope_delayed_routing_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 12677 """ 12678 Updates the delayed routing rules for an envelope's workflow step definition. 12679 This method makes a synchronous HTTP request by default. To make an 12680 asynchronous HTTP request, please define a `callback` function 12681 to be invoked when receiving the response. 12682 >>> def callback_function(response): 12683 >>> pprint(response) 12684 >>> 12685 >>> thread = api.update_envelope_delayed_routing_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 12686 12687 :param callback function: The callback function 12688 for asynchronous request. (optional) 12689 :param str account_id: The external account number (int) or account ID Guid. (required) 12690 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12691 :param str workflow_step_id: (required) 12692 :param DelayedRouting delayed_routing: 12693 :return: DelayedRouting 12694 If the method is called asynchronously, 12695 returns the request thread. 12696 """ 12697 kwargs['_return_http_data_only'] = True 12698 if kwargs.get('callback'): 12699 return self.update_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 12700 else: 12701 (data) = self.update_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 12702 return data 12703 12704 def update_envelope_delayed_routing_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 12705 """ 12706 Updates the delayed routing rules for an envelope's workflow step definition. 12707 This method makes a synchronous HTTP request by default. To make an 12708 asynchronous HTTP request, please define a `callback` function 12709 to be invoked when receiving the response. 12710 >>> def callback_function(response): 12711 >>> pprint(response) 12712 >>> 12713 >>> thread = api.update_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 12714 12715 :param callback function: The callback function 12716 for asynchronous request. (optional) 12717 :param str account_id: The external account number (int) or account ID Guid. (required) 12718 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12719 :param str workflow_step_id: (required) 12720 :param DelayedRouting delayed_routing: 12721 :return: DelayedRouting 12722 If the method is called asynchronously, 12723 returns the request thread. 12724 """ 12725 12726 all_params = ['account_id', 'envelope_id', 'workflow_step_id', 'delayed_routing'] 12727 all_params.append('callback') 12728 all_params.append('_return_http_data_only') 12729 all_params.append('_preload_content') 12730 all_params.append('_request_timeout') 12731 12732 params = locals() 12733 for key, val in iteritems(params['kwargs']): 12734 if key not in all_params: 12735 raise TypeError( 12736 "Got an unexpected keyword argument '%s'" 12737 " to method update_envelope_delayed_routing_definition" % key 12738 ) 12739 params[key] = val 12740 del params['kwargs'] 12741 # verify the required parameter 'account_id' is set 12742 if ('account_id' not in params) or (params['account_id'] is None): 12743 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_delayed_routing_definition`") 12744 # verify the required parameter 'envelope_id' is set 12745 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12746 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_delayed_routing_definition`") 12747 # verify the required parameter 'workflow_step_id' is set 12748 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 12749 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_envelope_delayed_routing_definition`") 12750 12751 12752 collection_formats = {} 12753 12754 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 12755 path_params = {} 12756 if 'account_id' in params: 12757 path_params['accountId'] = params['account_id'] 12758 if 'envelope_id' in params: 12759 path_params['envelopeId'] = params['envelope_id'] 12760 if 'workflow_step_id' in params: 12761 path_params['workflowStepId'] = params['workflow_step_id'] 12762 12763 query_params = {} 12764 12765 header_params = {} 12766 12767 form_params = [] 12768 local_var_files = {} 12769 12770 body_params = None 12771 if 'delayed_routing' in params: 12772 body_params = params['delayed_routing'] 12773 # HTTP header `Accept` 12774 header_params['Accept'] = self.api_client.\ 12775 select_header_accept(['application/json']) 12776 12777 # Authentication setting 12778 auth_settings = [] 12779 12780 return self.api_client.call_api(resource_path, 'PUT', 12781 path_params, 12782 query_params, 12783 header_params, 12784 body=body_params, 12785 post_params=form_params, 12786 files=local_var_files, 12787 response_type='DelayedRouting', 12788 auth_settings=auth_settings, 12789 callback=params.get('callback'), 12790 _return_http_data_only=params.get('_return_http_data_only'), 12791 _preload_content=params.get('_preload_content', True), 12792 _request_timeout=params.get('_request_timeout'), 12793 collection_formats=collection_formats) 12794 12795 def update_envelope_doc_gen_form_fields(self, account_id, envelope_id, **kwargs): 12796 """ 12797 Updates formfields for an envelope 12798 This method makes a synchronous HTTP request by default. To make an 12799 asynchronous HTTP request, please define a `callback` function 12800 to be invoked when receiving the response. 12801 >>> def callback_function(response): 12802 >>> pprint(response) 12803 >>> 12804 >>> thread = api.update_envelope_doc_gen_form_fields(account_id, envelope_id, callback=callback_function) 12805 12806 :param callback function: The callback function 12807 for asynchronous request. (optional) 12808 :param str account_id: The external account number (int) or account ID Guid. (required) 12809 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12810 :param str update_docgen_formfields_only: 12811 :param DocGenFormFieldRequest doc_gen_form_field_request: 12812 :return: DocGenFormFieldResponse 12813 If the method is called asynchronously, 12814 returns the request thread. 12815 """ 12816 kwargs['_return_http_data_only'] = True 12817 if kwargs.get('callback'): 12818 return self.update_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, **kwargs) 12819 else: 12820 (data) = self.update_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, **kwargs) 12821 return data 12822 12823 def update_envelope_doc_gen_form_fields_with_http_info(self, account_id, envelope_id, **kwargs): 12824 """ 12825 Updates formfields for an envelope 12826 This method makes a synchronous HTTP request by default. To make an 12827 asynchronous HTTP request, please define a `callback` function 12828 to be invoked when receiving the response. 12829 >>> def callback_function(response): 12830 >>> pprint(response) 12831 >>> 12832 >>> thread = api.update_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, callback=callback_function) 12833 12834 :param callback function: The callback function 12835 for asynchronous request. (optional) 12836 :param str account_id: The external account number (int) or account ID Guid. (required) 12837 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12838 :param str update_docgen_formfields_only: 12839 :param DocGenFormFieldRequest doc_gen_form_field_request: 12840 :return: DocGenFormFieldResponse 12841 If the method is called asynchronously, 12842 returns the request thread. 12843 """ 12844 12845 all_params = ['account_id', 'envelope_id', 'update_docgen_formfields_only', 'doc_gen_form_field_request'] 12846 all_params.append('callback') 12847 all_params.append('_return_http_data_only') 12848 all_params.append('_preload_content') 12849 all_params.append('_request_timeout') 12850 12851 params = locals() 12852 for key, val in iteritems(params['kwargs']): 12853 if key not in all_params: 12854 raise TypeError( 12855 "Got an unexpected keyword argument '%s'" 12856 " to method update_envelope_doc_gen_form_fields" % key 12857 ) 12858 params[key] = val 12859 del params['kwargs'] 12860 # verify the required parameter 'account_id' is set 12861 if ('account_id' not in params) or (params['account_id'] is None): 12862 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_doc_gen_form_fields`") 12863 # verify the required parameter 'envelope_id' is set 12864 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12865 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_doc_gen_form_fields`") 12866 12867 12868 collection_formats = {} 12869 12870 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/docGenFormFields'.replace('{format}', 'json') 12871 path_params = {} 12872 if 'account_id' in params: 12873 path_params['accountId'] = params['account_id'] 12874 if 'envelope_id' in params: 12875 path_params['envelopeId'] = params['envelope_id'] 12876 12877 query_params = {} 12878 if 'update_docgen_formfields_only' in params: 12879 query_params['update_docgen_formfields_only'] = params['update_docgen_formfields_only'] 12880 12881 header_params = {} 12882 12883 form_params = [] 12884 local_var_files = {} 12885 12886 body_params = None 12887 if 'doc_gen_form_field_request' in params: 12888 body_params = params['doc_gen_form_field_request'] 12889 # HTTP header `Accept` 12890 header_params['Accept'] = self.api_client.\ 12891 select_header_accept(['application/json']) 12892 12893 # Authentication setting 12894 auth_settings = [] 12895 12896 return self.api_client.call_api(resource_path, 'PUT', 12897 path_params, 12898 query_params, 12899 header_params, 12900 body=body_params, 12901 post_params=form_params, 12902 files=local_var_files, 12903 response_type='DocGenFormFieldResponse', 12904 auth_settings=auth_settings, 12905 callback=params.get('callback'), 12906 _return_http_data_only=params.get('_return_http_data_only'), 12907 _preload_content=params.get('_preload_content', True), 12908 _request_timeout=params.get('_request_timeout'), 12909 collection_formats=collection_formats) 12910 12911 def update_envelope_scheduled_sending_definition(self, account_id, envelope_id, **kwargs): 12912 """ 12913 Updates the scheduled sending rules for an envelope's workflow definition. 12914 This method makes a synchronous HTTP request by default. To make an 12915 asynchronous HTTP request, please define a `callback` function 12916 to be invoked when receiving the response. 12917 >>> def callback_function(response): 12918 >>> pprint(response) 12919 >>> 12920 >>> thread = api.update_envelope_scheduled_sending_definition(account_id, envelope_id, callback=callback_function) 12921 12922 :param callback function: The callback function 12923 for asynchronous request. (optional) 12924 :param str account_id: The external account number (int) or account ID Guid. (required) 12925 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12926 :param ScheduledSending scheduled_sending: 12927 :return: ScheduledSending 12928 If the method is called asynchronously, 12929 returns the request thread. 12930 """ 12931 kwargs['_return_http_data_only'] = True 12932 if kwargs.get('callback'): 12933 return self.update_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 12934 else: 12935 (data) = self.update_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 12936 return data 12937 12938 def update_envelope_scheduled_sending_definition_with_http_info(self, account_id, envelope_id, **kwargs): 12939 """ 12940 Updates the scheduled sending rules for an envelope's workflow definition. 12941 This method makes a synchronous HTTP request by default. To make an 12942 asynchronous HTTP request, please define a `callback` function 12943 to be invoked when receiving the response. 12944 >>> def callback_function(response): 12945 >>> pprint(response) 12946 >>> 12947 >>> thread = api.update_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, callback=callback_function) 12948 12949 :param callback function: The callback function 12950 for asynchronous request. (optional) 12951 :param str account_id: The external account number (int) or account ID Guid. (required) 12952 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12953 :param ScheduledSending scheduled_sending: 12954 :return: ScheduledSending 12955 If the method is called asynchronously, 12956 returns the request thread. 12957 """ 12958 12959 all_params = ['account_id', 'envelope_id', 'scheduled_sending'] 12960 all_params.append('callback') 12961 all_params.append('_return_http_data_only') 12962 all_params.append('_preload_content') 12963 all_params.append('_request_timeout') 12964 12965 params = locals() 12966 for key, val in iteritems(params['kwargs']): 12967 if key not in all_params: 12968 raise TypeError( 12969 "Got an unexpected keyword argument '%s'" 12970 " to method update_envelope_scheduled_sending_definition" % key 12971 ) 12972 params[key] = val 12973 del params['kwargs'] 12974 # verify the required parameter 'account_id' is set 12975 if ('account_id' not in params) or (params['account_id'] is None): 12976 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_scheduled_sending_definition`") 12977 # verify the required parameter 'envelope_id' is set 12978 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12979 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_scheduled_sending_definition`") 12980 12981 12982 collection_formats = {} 12983 12984 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/scheduledSending'.replace('{format}', 'json') 12985 path_params = {} 12986 if 'account_id' in params: 12987 path_params['accountId'] = params['account_id'] 12988 if 'envelope_id' in params: 12989 path_params['envelopeId'] = params['envelope_id'] 12990 12991 query_params = {} 12992 12993 header_params = {} 12994 12995 form_params = [] 12996 local_var_files = {} 12997 12998 body_params = None 12999 if 'scheduled_sending' in params: 13000 body_params = params['scheduled_sending'] 13001 # HTTP header `Accept` 13002 header_params['Accept'] = self.api_client.\ 13003 select_header_accept(['application/json']) 13004 13005 # Authentication setting 13006 auth_settings = [] 13007 13008 return self.api_client.call_api(resource_path, 'PUT', 13009 path_params, 13010 query_params, 13011 header_params, 13012 body=body_params, 13013 post_params=form_params, 13014 files=local_var_files, 13015 response_type='ScheduledSending', 13016 auth_settings=auth_settings, 13017 callback=params.get('callback'), 13018 _return_http_data_only=params.get('_return_http_data_only'), 13019 _preload_content=params.get('_preload_content', True), 13020 _request_timeout=params.get('_request_timeout'), 13021 collection_formats=collection_formats) 13022 13023 def update_envelope_transfer_rule(self, account_id, envelope_transfer_rule_id, **kwargs): 13024 """ 13025 Update an envelope transfer rule for an account. 13026 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. 13027 This method makes a synchronous HTTP request by default. To make an 13028 asynchronous HTTP request, please define a `callback` function 13029 to be invoked when receiving the response. 13030 >>> def callback_function(response): 13031 >>> pprint(response) 13032 >>> 13033 >>> thread = api.update_envelope_transfer_rule(account_id, envelope_transfer_rule_id, callback=callback_function) 13034 13035 :param callback function: The callback function 13036 for asynchronous request. (optional) 13037 :param str account_id: The external account number (int) or account ID Guid. (required) 13038 :param str envelope_transfer_rule_id: (required) 13039 :param EnvelopeTransferRule envelope_transfer_rule: 13040 :return: EnvelopeTransferRule 13041 If the method is called asynchronously, 13042 returns the request thread. 13043 """ 13044 kwargs['_return_http_data_only'] = True 13045 if kwargs.get('callback'): 13046 return self.update_envelope_transfer_rule_with_http_info(account_id, envelope_transfer_rule_id, **kwargs) 13047 else: 13048 (data) = self.update_envelope_transfer_rule_with_http_info(account_id, envelope_transfer_rule_id, **kwargs) 13049 return data 13050 13051 def update_envelope_transfer_rule_with_http_info(self, account_id, envelope_transfer_rule_id, **kwargs): 13052 """ 13053 Update an envelope transfer rule for an account. 13054 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. 13055 This method makes a synchronous HTTP request by default. To make an 13056 asynchronous HTTP request, please define a `callback` function 13057 to be invoked when receiving the response. 13058 >>> def callback_function(response): 13059 >>> pprint(response) 13060 >>> 13061 >>> thread = api.update_envelope_transfer_rule_with_http_info(account_id, envelope_transfer_rule_id, callback=callback_function) 13062 13063 :param callback function: The callback function 13064 for asynchronous request. (optional) 13065 :param str account_id: The external account number (int) or account ID Guid. (required) 13066 :param str envelope_transfer_rule_id: (required) 13067 :param EnvelopeTransferRule envelope_transfer_rule: 13068 :return: EnvelopeTransferRule 13069 If the method is called asynchronously, 13070 returns the request thread. 13071 """ 13072 13073 all_params = ['account_id', 'envelope_transfer_rule_id', 'envelope_transfer_rule'] 13074 all_params.append('callback') 13075 all_params.append('_return_http_data_only') 13076 all_params.append('_preload_content') 13077 all_params.append('_request_timeout') 13078 13079 params = locals() 13080 for key, val in iteritems(params['kwargs']): 13081 if key not in all_params: 13082 raise TypeError( 13083 "Got an unexpected keyword argument '%s'" 13084 " to method update_envelope_transfer_rule" % key 13085 ) 13086 params[key] = val 13087 del params['kwargs'] 13088 # verify the required parameter 'account_id' is set 13089 if ('account_id' not in params) or (params['account_id'] is None): 13090 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_transfer_rule`") 13091 # verify the required parameter 'envelope_transfer_rule_id' is set 13092 if ('envelope_transfer_rule_id' not in params) or (params['envelope_transfer_rule_id'] is None): 13093 raise ValueError("Missing the required parameter `envelope_transfer_rule_id` when calling `update_envelope_transfer_rule`") 13094 13095 13096 collection_formats = {} 13097 13098 resource_path = '/v2.1/accounts/{accountId}/envelopes/transfer_rules/{envelopeTransferRuleId}'.replace('{format}', 'json') 13099 path_params = {} 13100 if 'account_id' in params: 13101 path_params['accountId'] = params['account_id'] 13102 if 'envelope_transfer_rule_id' in params: 13103 path_params['envelopeTransferRuleId'] = params['envelope_transfer_rule_id'] 13104 13105 query_params = {} 13106 13107 header_params = {} 13108 13109 form_params = [] 13110 local_var_files = {} 13111 13112 body_params = None 13113 if 'envelope_transfer_rule' in params: 13114 body_params = params['envelope_transfer_rule'] 13115 # HTTP header `Accept` 13116 header_params['Accept'] = self.api_client.\ 13117 select_header_accept(['application/json']) 13118 13119 # Authentication setting 13120 auth_settings = [] 13121 13122 return self.api_client.call_api(resource_path, 'PUT', 13123 path_params, 13124 query_params, 13125 header_params, 13126 body=body_params, 13127 post_params=form_params, 13128 files=local_var_files, 13129 response_type='EnvelopeTransferRule', 13130 auth_settings=auth_settings, 13131 callback=params.get('callback'), 13132 _return_http_data_only=params.get('_return_http_data_only'), 13133 _preload_content=params.get('_preload_content', True), 13134 _request_timeout=params.get('_request_timeout'), 13135 collection_formats=collection_formats) 13136 13137 def update_envelope_transfer_rules(self, account_id, **kwargs): 13138 """ 13139 Update envelope transfer rules for an account. 13140 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. 13141 This method makes a synchronous HTTP request by default. To make an 13142 asynchronous HTTP request, please define a `callback` function 13143 to be invoked when receiving the response. 13144 >>> def callback_function(response): 13145 >>> pprint(response) 13146 >>> 13147 >>> thread = api.update_envelope_transfer_rules(account_id, callback=callback_function) 13148 13149 :param callback function: The callback function 13150 for asynchronous request. (optional) 13151 :param str account_id: The external account number (int) or account ID Guid. (required) 13152 :param EnvelopeTransferRuleInformation envelope_transfer_rule_information: 13153 :return: EnvelopeTransferRuleInformation 13154 If the method is called asynchronously, 13155 returns the request thread. 13156 """ 13157 kwargs['_return_http_data_only'] = True 13158 if kwargs.get('callback'): 13159 return self.update_envelope_transfer_rules_with_http_info(account_id, **kwargs) 13160 else: 13161 (data) = self.update_envelope_transfer_rules_with_http_info(account_id, **kwargs) 13162 return data 13163 13164 def update_envelope_transfer_rules_with_http_info(self, account_id, **kwargs): 13165 """ 13166 Update envelope transfer rules for an account. 13167 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. 13168 This method makes a synchronous HTTP request by default. To make an 13169 asynchronous HTTP request, please define a `callback` function 13170 to be invoked when receiving the response. 13171 >>> def callback_function(response): 13172 >>> pprint(response) 13173 >>> 13174 >>> thread = api.update_envelope_transfer_rules_with_http_info(account_id, callback=callback_function) 13175 13176 :param callback function: The callback function 13177 for asynchronous request. (optional) 13178 :param str account_id: The external account number (int) or account ID Guid. (required) 13179 :param EnvelopeTransferRuleInformation envelope_transfer_rule_information: 13180 :return: EnvelopeTransferRuleInformation 13181 If the method is called asynchronously, 13182 returns the request thread. 13183 """ 13184 13185 all_params = ['account_id', 'envelope_transfer_rule_information'] 13186 all_params.append('callback') 13187 all_params.append('_return_http_data_only') 13188 all_params.append('_preload_content') 13189 all_params.append('_request_timeout') 13190 13191 params = locals() 13192 for key, val in iteritems(params['kwargs']): 13193 if key not in all_params: 13194 raise TypeError( 13195 "Got an unexpected keyword argument '%s'" 13196 " to method update_envelope_transfer_rules" % key 13197 ) 13198 params[key] = val 13199 del params['kwargs'] 13200 # verify the required parameter 'account_id' is set 13201 if ('account_id' not in params) or (params['account_id'] is None): 13202 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_transfer_rules`") 13203 13204 13205 collection_formats = {} 13206 13207 resource_path = '/v2.1/accounts/{accountId}/envelopes/transfer_rules'.replace('{format}', 'json') 13208 path_params = {} 13209 if 'account_id' in params: 13210 path_params['accountId'] = params['account_id'] 13211 13212 query_params = {} 13213 13214 header_params = {} 13215 13216 form_params = [] 13217 local_var_files = {} 13218 13219 body_params = None 13220 if 'envelope_transfer_rule_information' in params: 13221 body_params = params['envelope_transfer_rule_information'] 13222 # HTTP header `Accept` 13223 header_params['Accept'] = self.api_client.\ 13224 select_header_accept(['application/json']) 13225 13226 # Authentication setting 13227 auth_settings = [] 13228 13229 return self.api_client.call_api(resource_path, 'PUT', 13230 path_params, 13231 query_params, 13232 header_params, 13233 body=body_params, 13234 post_params=form_params, 13235 files=local_var_files, 13236 response_type='EnvelopeTransferRuleInformation', 13237 auth_settings=auth_settings, 13238 callback=params.get('callback'), 13239 _return_http_data_only=params.get('_return_http_data_only'), 13240 _preload_content=params.get('_preload_content', True), 13241 _request_timeout=params.get('_request_timeout'), 13242 collection_formats=collection_formats) 13243 13244 def update_envelope_workflow_definition(self, account_id, envelope_id, **kwargs): 13245 """ 13246 Updates the envelope workflow definition for an envelope. 13247 Updates the specified envelope's workflow definition if it has one. 13248 This method makes a synchronous HTTP request by default. To make an 13249 asynchronous HTTP request, please define a `callback` function 13250 to be invoked when receiving the response. 13251 >>> def callback_function(response): 13252 >>> pprint(response) 13253 >>> 13254 >>> thread = api.update_envelope_workflow_definition(account_id, envelope_id, callback=callback_function) 13255 13256 :param callback function: The callback function 13257 for asynchronous request. (optional) 13258 :param str account_id: The external account number (int) or account ID Guid. (required) 13259 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13260 :param Workflow workflow: 13261 :return: Workflow 13262 If the method is called asynchronously, 13263 returns the request thread. 13264 """ 13265 kwargs['_return_http_data_only'] = True 13266 if kwargs.get('callback'): 13267 return self.update_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 13268 else: 13269 (data) = self.update_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 13270 return data 13271 13272 def update_envelope_workflow_definition_with_http_info(self, account_id, envelope_id, **kwargs): 13273 """ 13274 Updates the envelope workflow definition for an envelope. 13275 Updates the specified envelope's workflow definition if it has one. 13276 This method makes a synchronous HTTP request by default. To make an 13277 asynchronous HTTP request, please define a `callback` function 13278 to be invoked when receiving the response. 13279 >>> def callback_function(response): 13280 >>> pprint(response) 13281 >>> 13282 >>> thread = api.update_envelope_workflow_definition_with_http_info(account_id, envelope_id, callback=callback_function) 13283 13284 :param callback function: The callback function 13285 for asynchronous request. (optional) 13286 :param str account_id: The external account number (int) or account ID Guid. (required) 13287 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13288 :param Workflow workflow: 13289 :return: Workflow 13290 If the method is called asynchronously, 13291 returns the request thread. 13292 """ 13293 13294 all_params = ['account_id', 'envelope_id', 'workflow'] 13295 all_params.append('callback') 13296 all_params.append('_return_http_data_only') 13297 all_params.append('_preload_content') 13298 all_params.append('_request_timeout') 13299 13300 params = locals() 13301 for key, val in iteritems(params['kwargs']): 13302 if key not in all_params: 13303 raise TypeError( 13304 "Got an unexpected keyword argument '%s'" 13305 " to method update_envelope_workflow_definition" % key 13306 ) 13307 params[key] = val 13308 del params['kwargs'] 13309 # verify the required parameter 'account_id' is set 13310 if ('account_id' not in params) or (params['account_id'] is None): 13311 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_workflow_definition`") 13312 # verify the required parameter 'envelope_id' is set 13313 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13314 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_workflow_definition`") 13315 13316 13317 collection_formats = {} 13318 13319 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow'.replace('{format}', 'json') 13320 path_params = {} 13321 if 'account_id' in params: 13322 path_params['accountId'] = params['account_id'] 13323 if 'envelope_id' in params: 13324 path_params['envelopeId'] = params['envelope_id'] 13325 13326 query_params = {} 13327 13328 header_params = {} 13329 13330 form_params = [] 13331 local_var_files = {} 13332 13333 body_params = None 13334 if 'workflow' in params: 13335 body_params = params['workflow'] 13336 # HTTP header `Accept` 13337 header_params['Accept'] = self.api_client.\ 13338 select_header_accept(['application/json']) 13339 13340 # Authentication setting 13341 auth_settings = [] 13342 13343 return self.api_client.call_api(resource_path, 'PUT', 13344 path_params, 13345 query_params, 13346 header_params, 13347 body=body_params, 13348 post_params=form_params, 13349 files=local_var_files, 13350 response_type='Workflow', 13351 auth_settings=auth_settings, 13352 callback=params.get('callback'), 13353 _return_http_data_only=params.get('_return_http_data_only'), 13354 _preload_content=params.get('_preload_content', True), 13355 _request_timeout=params.get('_request_timeout'), 13356 collection_formats=collection_formats) 13357 13358 def update_envelope_workflow_step_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 13359 """ 13360 Updates the envelope workflow step definition for an envelope. 13361 This method makes a synchronous HTTP request by default. To make an 13362 asynchronous HTTP request, please define a `callback` function 13363 to be invoked when receiving the response. 13364 >>> def callback_function(response): 13365 >>> pprint(response) 13366 >>> 13367 >>> thread = api.update_envelope_workflow_step_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 13368 13369 :param callback function: The callback function 13370 for asynchronous request. (optional) 13371 :param str account_id: The external account number (int) or account ID Guid. (required) 13372 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13373 :param str workflow_step_id: (required) 13374 :param WorkflowStep workflow_step: 13375 :return: WorkflowStep 13376 If the method is called asynchronously, 13377 returns the request thread. 13378 """ 13379 kwargs['_return_http_data_only'] = True 13380 if kwargs.get('callback'): 13381 return self.update_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 13382 else: 13383 (data) = self.update_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 13384 return data 13385 13386 def update_envelope_workflow_step_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 13387 """ 13388 Updates the envelope workflow step definition for an envelope. 13389 This method makes a synchronous HTTP request by default. To make an 13390 asynchronous HTTP request, please define a `callback` function 13391 to be invoked when receiving the response. 13392 >>> def callback_function(response): 13393 >>> pprint(response) 13394 >>> 13395 >>> thread = api.update_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 13396 13397 :param callback function: The callback function 13398 for asynchronous request. (optional) 13399 :param str account_id: The external account number (int) or account ID Guid. (required) 13400 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13401 :param str workflow_step_id: (required) 13402 :param WorkflowStep workflow_step: 13403 :return: WorkflowStep 13404 If the method is called asynchronously, 13405 returns the request thread. 13406 """ 13407 13408 all_params = ['account_id', 'envelope_id', 'workflow_step_id', 'workflow_step'] 13409 all_params.append('callback') 13410 all_params.append('_return_http_data_only') 13411 all_params.append('_preload_content') 13412 all_params.append('_request_timeout') 13413 13414 params = locals() 13415 for key, val in iteritems(params['kwargs']): 13416 if key not in all_params: 13417 raise TypeError( 13418 "Got an unexpected keyword argument '%s'" 13419 " to method update_envelope_workflow_step_definition" % key 13420 ) 13421 params[key] = val 13422 del params['kwargs'] 13423 # verify the required parameter 'account_id' is set 13424 if ('account_id' not in params) or (params['account_id'] is None): 13425 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_workflow_step_definition`") 13426 # verify the required parameter 'envelope_id' is set 13427 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13428 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_workflow_step_definition`") 13429 # verify the required parameter 'workflow_step_id' is set 13430 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 13431 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_envelope_workflow_step_definition`") 13432 13433 13434 collection_formats = {} 13435 13436 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 13437 path_params = {} 13438 if 'account_id' in params: 13439 path_params['accountId'] = params['account_id'] 13440 if 'envelope_id' in params: 13441 path_params['envelopeId'] = params['envelope_id'] 13442 if 'workflow_step_id' in params: 13443 path_params['workflowStepId'] = params['workflow_step_id'] 13444 13445 query_params = {} 13446 13447 header_params = {} 13448 13449 form_params = [] 13450 local_var_files = {} 13451 13452 body_params = None 13453 if 'workflow_step' in params: 13454 body_params = params['workflow_step'] 13455 # HTTP header `Accept` 13456 header_params['Accept'] = self.api_client.\ 13457 select_header_accept(['application/json']) 13458 13459 # Authentication setting 13460 auth_settings = [] 13461 13462 return self.api_client.call_api(resource_path, 'PUT', 13463 path_params, 13464 query_params, 13465 header_params, 13466 body=body_params, 13467 post_params=form_params, 13468 files=local_var_files, 13469 response_type='WorkflowStep', 13470 auth_settings=auth_settings, 13471 callback=params.get('callback'), 13472 _return_http_data_only=params.get('_return_http_data_only'), 13473 _preload_content=params.get('_preload_content', True), 13474 _request_timeout=params.get('_request_timeout'), 13475 collection_formats=collection_formats) 13476 13477 def update_lock(self, account_id, envelope_id, **kwargs): 13478 """ 13479 Updates an envelope lock. 13480 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. 13481 This method makes a synchronous HTTP request by default. To make an 13482 asynchronous HTTP request, please define a `callback` function 13483 to be invoked when receiving the response. 13484 >>> def callback_function(response): 13485 >>> pprint(response) 13486 >>> 13487 >>> thread = api.update_lock(account_id, envelope_id, callback=callback_function) 13488 13489 :param callback function: The callback function 13490 for asynchronous request. (optional) 13491 :param str account_id: The external account number (int) or account ID Guid. (required) 13492 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13493 :param LockRequest lock_request: 13494 :return: LockInformation 13495 If the method is called asynchronously, 13496 returns the request thread. 13497 """ 13498 kwargs['_return_http_data_only'] = True 13499 if kwargs.get('callback'): 13500 return self.update_lock_with_http_info(account_id, envelope_id, **kwargs) 13501 else: 13502 (data) = self.update_lock_with_http_info(account_id, envelope_id, **kwargs) 13503 return data 13504 13505 def update_lock_with_http_info(self, account_id, envelope_id, **kwargs): 13506 """ 13507 Updates an envelope lock. 13508 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. 13509 This method makes a synchronous HTTP request by default. To make an 13510 asynchronous HTTP request, please define a `callback` function 13511 to be invoked when receiving the response. 13512 >>> def callback_function(response): 13513 >>> pprint(response) 13514 >>> 13515 >>> thread = api.update_lock_with_http_info(account_id, envelope_id, callback=callback_function) 13516 13517 :param callback function: The callback function 13518 for asynchronous request. (optional) 13519 :param str account_id: The external account number (int) or account ID Guid. (required) 13520 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13521 :param LockRequest lock_request: 13522 :return: LockInformation 13523 If the method is called asynchronously, 13524 returns the request thread. 13525 """ 13526 13527 all_params = ['account_id', 'envelope_id', 'lock_request'] 13528 all_params.append('callback') 13529 all_params.append('_return_http_data_only') 13530 all_params.append('_preload_content') 13531 all_params.append('_request_timeout') 13532 13533 params = locals() 13534 for key, val in iteritems(params['kwargs']): 13535 if key not in all_params: 13536 raise TypeError( 13537 "Got an unexpected keyword argument '%s'" 13538 " to method update_lock" % key 13539 ) 13540 params[key] = val 13541 del params['kwargs'] 13542 # verify the required parameter 'account_id' is set 13543 if ('account_id' not in params) or (params['account_id'] is None): 13544 raise ValueError("Missing the required parameter `account_id` when calling `update_lock`") 13545 # verify the required parameter 'envelope_id' is set 13546 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13547 raise ValueError("Missing the required parameter `envelope_id` when calling `update_lock`") 13548 13549 13550 collection_formats = {} 13551 13552 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/lock'.replace('{format}', 'json') 13553 path_params = {} 13554 if 'account_id' in params: 13555 path_params['accountId'] = params['account_id'] 13556 if 'envelope_id' in params: 13557 path_params['envelopeId'] = params['envelope_id'] 13558 13559 query_params = {} 13560 13561 header_params = {} 13562 13563 form_params = [] 13564 local_var_files = {} 13565 13566 body_params = None 13567 if 'lock_request' in params: 13568 body_params = params['lock_request'] 13569 # HTTP header `Accept` 13570 header_params['Accept'] = self.api_client.\ 13571 select_header_accept(['application/json']) 13572 13573 # Authentication setting 13574 auth_settings = [] 13575 13576 return self.api_client.call_api(resource_path, 'PUT', 13577 path_params, 13578 query_params, 13579 header_params, 13580 body=body_params, 13581 post_params=form_params, 13582 files=local_var_files, 13583 response_type='LockInformation', 13584 auth_settings=auth_settings, 13585 callback=params.get('callback'), 13586 _return_http_data_only=params.get('_return_http_data_only'), 13587 _preload_content=params.get('_preload_content', True), 13588 _request_timeout=params.get('_request_timeout'), 13589 collection_formats=collection_formats) 13590 13591 def update_notification_settings(self, account_id, envelope_id, **kwargs): 13592 """ 13593 Sets envelope notification (Reminders/Expirations) structure for an existing envelope. 13594 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. 13595 This method makes a synchronous HTTP request by default. To make an 13596 asynchronous HTTP request, please define a `callback` function 13597 to be invoked when receiving the response. 13598 >>> def callback_function(response): 13599 >>> pprint(response) 13600 >>> 13601 >>> thread = api.update_notification_settings(account_id, envelope_id, callback=callback_function) 13602 13603 :param callback function: The callback function 13604 for asynchronous request. (optional) 13605 :param str account_id: The external account number (int) or account ID Guid. (required) 13606 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13607 :param EnvelopeNotificationRequest envelope_notification_request: 13608 :return: Notification 13609 If the method is called asynchronously, 13610 returns the request thread. 13611 """ 13612 kwargs['_return_http_data_only'] = True 13613 if kwargs.get('callback'): 13614 return self.update_notification_settings_with_http_info(account_id, envelope_id, **kwargs) 13615 else: 13616 (data) = self.update_notification_settings_with_http_info(account_id, envelope_id, **kwargs) 13617 return data 13618 13619 def update_notification_settings_with_http_info(self, account_id, envelope_id, **kwargs): 13620 """ 13621 Sets envelope notification (Reminders/Expirations) structure for an existing envelope. 13622 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. 13623 This method makes a synchronous HTTP request by default. To make an 13624 asynchronous HTTP request, please define a `callback` function 13625 to be invoked when receiving the response. 13626 >>> def callback_function(response): 13627 >>> pprint(response) 13628 >>> 13629 >>> thread = api.update_notification_settings_with_http_info(account_id, envelope_id, callback=callback_function) 13630 13631 :param callback function: The callback function 13632 for asynchronous request. (optional) 13633 :param str account_id: The external account number (int) or account ID Guid. (required) 13634 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13635 :param EnvelopeNotificationRequest envelope_notification_request: 13636 :return: Notification 13637 If the method is called asynchronously, 13638 returns the request thread. 13639 """ 13640 13641 all_params = ['account_id', 'envelope_id', 'envelope_notification_request'] 13642 all_params.append('callback') 13643 all_params.append('_return_http_data_only') 13644 all_params.append('_preload_content') 13645 all_params.append('_request_timeout') 13646 13647 params = locals() 13648 for key, val in iteritems(params['kwargs']): 13649 if key not in all_params: 13650 raise TypeError( 13651 "Got an unexpected keyword argument '%s'" 13652 " to method update_notification_settings" % key 13653 ) 13654 params[key] = val 13655 del params['kwargs'] 13656 # verify the required parameter 'account_id' is set 13657 if ('account_id' not in params) or (params['account_id'] is None): 13658 raise ValueError("Missing the required parameter `account_id` when calling `update_notification_settings`") 13659 # verify the required parameter 'envelope_id' is set 13660 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13661 raise ValueError("Missing the required parameter `envelope_id` when calling `update_notification_settings`") 13662 13663 13664 collection_formats = {} 13665 13666 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/notification'.replace('{format}', 'json') 13667 path_params = {} 13668 if 'account_id' in params: 13669 path_params['accountId'] = params['account_id'] 13670 if 'envelope_id' in params: 13671 path_params['envelopeId'] = params['envelope_id'] 13672 13673 query_params = {} 13674 13675 header_params = {} 13676 13677 form_params = [] 13678 local_var_files = {} 13679 13680 body_params = None 13681 if 'envelope_notification_request' in params: 13682 body_params = params['envelope_notification_request'] 13683 # HTTP header `Accept` 13684 header_params['Accept'] = self.api_client.\ 13685 select_header_accept(['application/json']) 13686 13687 # Authentication setting 13688 auth_settings = [] 13689 13690 return self.api_client.call_api(resource_path, 'PUT', 13691 path_params, 13692 query_params, 13693 header_params, 13694 body=body_params, 13695 post_params=form_params, 13696 files=local_var_files, 13697 response_type='Notification', 13698 auth_settings=auth_settings, 13699 callback=params.get('callback'), 13700 _return_http_data_only=params.get('_return_http_data_only'), 13701 _preload_content=params.get('_preload_content', True), 13702 _request_timeout=params.get('_request_timeout'), 13703 collection_formats=collection_formats) 13704 13705 def update_recipient_document_visibility(self, account_id, envelope_id, recipient_id, **kwargs): 13706 """ 13707 Updates document visibility for the recipients 13708 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. 13709 This method makes a synchronous HTTP request by default. To make an 13710 asynchronous HTTP request, please define a `callback` function 13711 to be invoked when receiving the response. 13712 >>> def callback_function(response): 13713 >>> pprint(response) 13714 >>> 13715 >>> thread = api.update_recipient_document_visibility(account_id, envelope_id, recipient_id, callback=callback_function) 13716 13717 :param callback function: The callback function 13718 for asynchronous request. (optional) 13719 :param str account_id: The external account number (int) or account ID Guid. (required) 13720 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13721 :param str recipient_id: The ID of the recipient being accessed. (required) 13722 :param DocumentVisibilityList document_visibility_list: 13723 :return: DocumentVisibilityList 13724 If the method is called asynchronously, 13725 returns the request thread. 13726 """ 13727 kwargs['_return_http_data_only'] = True 13728 if kwargs.get('callback'): 13729 return self.update_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13730 else: 13731 (data) = self.update_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13732 return data 13733 13734 def update_recipient_document_visibility_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 13735 """ 13736 Updates document visibility for the recipients 13737 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. 13738 This method makes a synchronous HTTP request by default. To make an 13739 asynchronous HTTP request, please define a `callback` function 13740 to be invoked when receiving the response. 13741 >>> def callback_function(response): 13742 >>> pprint(response) 13743 >>> 13744 >>> thread = api.update_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 13745 13746 :param callback function: The callback function 13747 for asynchronous request. (optional) 13748 :param str account_id: The external account number (int) or account ID Guid. (required) 13749 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13750 :param str recipient_id: The ID of the recipient being accessed. (required) 13751 :param DocumentVisibilityList document_visibility_list: 13752 :return: DocumentVisibilityList 13753 If the method is called asynchronously, 13754 returns the request thread. 13755 """ 13756 13757 all_params = ['account_id', 'envelope_id', 'recipient_id', 'document_visibility_list'] 13758 all_params.append('callback') 13759 all_params.append('_return_http_data_only') 13760 all_params.append('_preload_content') 13761 all_params.append('_request_timeout') 13762 13763 params = locals() 13764 for key, val in iteritems(params['kwargs']): 13765 if key not in all_params: 13766 raise TypeError( 13767 "Got an unexpected keyword argument '%s'" 13768 " to method update_recipient_document_visibility" % key 13769 ) 13770 params[key] = val 13771 del params['kwargs'] 13772 # verify the required parameter 'account_id' is set 13773 if ('account_id' not in params) or (params['account_id'] is None): 13774 raise ValueError("Missing the required parameter `account_id` when calling `update_recipient_document_visibility`") 13775 # verify the required parameter 'envelope_id' is set 13776 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13777 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipient_document_visibility`") 13778 # verify the required parameter 'recipient_id' is set 13779 if ('recipient_id' not in params) or (params['recipient_id'] is None): 13780 raise ValueError("Missing the required parameter `recipient_id` when calling `update_recipient_document_visibility`") 13781 13782 13783 collection_formats = {} 13784 13785 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/document_visibility'.replace('{format}', 'json') 13786 path_params = {} 13787 if 'account_id' in params: 13788 path_params['accountId'] = params['account_id'] 13789 if 'envelope_id' in params: 13790 path_params['envelopeId'] = params['envelope_id'] 13791 if 'recipient_id' in params: 13792 path_params['recipientId'] = params['recipient_id'] 13793 13794 query_params = {} 13795 13796 header_params = {} 13797 13798 form_params = [] 13799 local_var_files = {} 13800 13801 body_params = None 13802 if 'document_visibility_list' in params: 13803 body_params = params['document_visibility_list'] 13804 # HTTP header `Accept` 13805 header_params['Accept'] = self.api_client.\ 13806 select_header_accept(['application/json']) 13807 13808 # Authentication setting 13809 auth_settings = [] 13810 13811 return self.api_client.call_api(resource_path, 'PUT', 13812 path_params, 13813 query_params, 13814 header_params, 13815 body=body_params, 13816 post_params=form_params, 13817 files=local_var_files, 13818 response_type='DocumentVisibilityList', 13819 auth_settings=auth_settings, 13820 callback=params.get('callback'), 13821 _return_http_data_only=params.get('_return_http_data_only'), 13822 _preload_content=params.get('_preload_content', True), 13823 _request_timeout=params.get('_request_timeout'), 13824 collection_formats=collection_formats) 13825 13826 def update_recipient_initials_image(self, account_id, envelope_id, recipient_id, **kwargs): 13827 """ 13828 Sets the initials image for an accountless signer. 13829 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**. 13830 This method makes a synchronous HTTP request by default. To make an 13831 asynchronous HTTP request, please define a `callback` function 13832 to be invoked when receiving the response. 13833 >>> def callback_function(response): 13834 >>> pprint(response) 13835 >>> 13836 >>> thread = api.update_recipient_initials_image(account_id, envelope_id, recipient_id, callback=callback_function) 13837 13838 :param callback function: The callback function 13839 for asynchronous request. (optional) 13840 :param str account_id: The external account number (int) or account ID Guid. (required) 13841 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13842 :param str recipient_id: The ID of the recipient being accessed. (required) 13843 :return: None 13844 If the method is called asynchronously, 13845 returns the request thread. 13846 """ 13847 kwargs['_return_http_data_only'] = True 13848 if kwargs.get('callback'): 13849 return self.update_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13850 else: 13851 (data) = self.update_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13852 return data 13853 13854 def update_recipient_initials_image_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 13855 """ 13856 Sets the initials image for an accountless signer. 13857 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**. 13858 This method makes a synchronous HTTP request by default. To make an 13859 asynchronous HTTP request, please define a `callback` function 13860 to be invoked when receiving the response. 13861 >>> def callback_function(response): 13862 >>> pprint(response) 13863 >>> 13864 >>> thread = api.update_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 13865 13866 :param callback function: The callback function 13867 for asynchronous request. (optional) 13868 :param str account_id: The external account number (int) or account ID Guid. (required) 13869 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13870 :param str recipient_id: The ID of the recipient being accessed. (required) 13871 :return: None 13872 If the method is called asynchronously, 13873 returns the request thread. 13874 """ 13875 13876 all_params = ['account_id', 'envelope_id', 'recipient_id'] 13877 all_params.append('callback') 13878 all_params.append('_return_http_data_only') 13879 all_params.append('_preload_content') 13880 all_params.append('_request_timeout') 13881 13882 params = locals() 13883 for key, val in iteritems(params['kwargs']): 13884 if key not in all_params: 13885 raise TypeError( 13886 "Got an unexpected keyword argument '%s'" 13887 " to method update_recipient_initials_image" % key 13888 ) 13889 params[key] = val 13890 del params['kwargs'] 13891 # verify the required parameter 'account_id' is set 13892 if ('account_id' not in params) or (params['account_id'] is None): 13893 raise ValueError("Missing the required parameter `account_id` when calling `update_recipient_initials_image`") 13894 # verify the required parameter 'envelope_id' is set 13895 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13896 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipient_initials_image`") 13897 # verify the required parameter 'recipient_id' is set 13898 if ('recipient_id' not in params) or (params['recipient_id'] is None): 13899 raise ValueError("Missing the required parameter `recipient_id` when calling `update_recipient_initials_image`") 13900 13901 13902 collection_formats = {} 13903 13904 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/initials_image'.replace('{format}', 'json') 13905 path_params = {} 13906 if 'account_id' in params: 13907 path_params['accountId'] = params['account_id'] 13908 if 'envelope_id' in params: 13909 path_params['envelopeId'] = params['envelope_id'] 13910 if 'recipient_id' in params: 13911 path_params['recipientId'] = params['recipient_id'] 13912 13913 query_params = {} 13914 13915 header_params = {} 13916 13917 form_params = [] 13918 local_var_files = {} 13919 13920 body_params = None 13921 # HTTP header `Accept` 13922 header_params['Accept'] = self.api_client.\ 13923 select_header_accept(['application/json']) 13924 13925 # HTTP header `Content-Type` 13926 header_params['Content-Type'] = self.api_client.\ 13927 select_header_content_type(['image/gif']) 13928 13929 # Authentication setting 13930 auth_settings = [] 13931 13932 return self.api_client.call_api(resource_path, 'PUT', 13933 path_params, 13934 query_params, 13935 header_params, 13936 body=body_params, 13937 post_params=form_params, 13938 files=local_var_files, 13939 response_type=None, 13940 auth_settings=auth_settings, 13941 callback=params.get('callback'), 13942 _return_http_data_only=params.get('_return_http_data_only'), 13943 _preload_content=params.get('_preload_content', True), 13944 _request_timeout=params.get('_request_timeout'), 13945 collection_formats=collection_formats) 13946 13947 def update_recipient_signature_image(self, account_id, envelope_id, recipient_id, **kwargs): 13948 """ 13949 Sets the signature image for an accountless signer. 13950 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**. 13951 This method makes a synchronous HTTP request by default. To make an 13952 asynchronous HTTP request, please define a `callback` function 13953 to be invoked when receiving the response. 13954 >>> def callback_function(response): 13955 >>> pprint(response) 13956 >>> 13957 >>> thread = api.update_recipient_signature_image(account_id, envelope_id, recipient_id, callback=callback_function) 13958 13959 :param callback function: The callback function 13960 for asynchronous request. (optional) 13961 :param str account_id: The external account number (int) or account ID Guid. (required) 13962 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13963 :param str recipient_id: The ID of the recipient being accessed. (required) 13964 :return: None 13965 If the method is called asynchronously, 13966 returns the request thread. 13967 """ 13968 kwargs['_return_http_data_only'] = True 13969 if kwargs.get('callback'): 13970 return self.update_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13971 else: 13972 (data) = self.update_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13973 return data 13974 13975 def update_recipient_signature_image_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 13976 """ 13977 Sets the signature image for an accountless signer. 13978 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**. 13979 This method makes a synchronous HTTP request by default. To make an 13980 asynchronous HTTP request, please define a `callback` function 13981 to be invoked when receiving the response. 13982 >>> def callback_function(response): 13983 >>> pprint(response) 13984 >>> 13985 >>> thread = api.update_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 13986 13987 :param callback function: The callback function 13988 for asynchronous request. (optional) 13989 :param str account_id: The external account number (int) or account ID Guid. (required) 13990 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13991 :param str recipient_id: The ID of the recipient being accessed. (required) 13992 :return: None 13993 If the method is called asynchronously, 13994 returns the request thread. 13995 """ 13996 13997 all_params = ['account_id', 'envelope_id', 'recipient_id'] 13998 all_params.append('callback') 13999 all_params.append('_return_http_data_only') 14000 all_params.append('_preload_content') 14001 all_params.append('_request_timeout') 14002 14003 params = locals() 14004 for key, val in iteritems(params['kwargs']): 14005 if key not in all_params: 14006 raise TypeError( 14007 "Got an unexpected keyword argument '%s'" 14008 " to method update_recipient_signature_image" % key 14009 ) 14010 params[key] = val 14011 del params['kwargs'] 14012 # verify the required parameter 'account_id' is set 14013 if ('account_id' not in params) or (params['account_id'] is None): 14014 raise ValueError("Missing the required parameter `account_id` when calling `update_recipient_signature_image`") 14015 # verify the required parameter 'envelope_id' is set 14016 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14017 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipient_signature_image`") 14018 # verify the required parameter 'recipient_id' is set 14019 if ('recipient_id' not in params) or (params['recipient_id'] is None): 14020 raise ValueError("Missing the required parameter `recipient_id` when calling `update_recipient_signature_image`") 14021 14022 14023 collection_formats = {} 14024 14025 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/signature_image'.replace('{format}', 'json') 14026 path_params = {} 14027 if 'account_id' in params: 14028 path_params['accountId'] = params['account_id'] 14029 if 'envelope_id' in params: 14030 path_params['envelopeId'] = params['envelope_id'] 14031 if 'recipient_id' in params: 14032 path_params['recipientId'] = params['recipient_id'] 14033 14034 query_params = {} 14035 14036 header_params = {} 14037 14038 form_params = [] 14039 local_var_files = {} 14040 14041 body_params = None 14042 # HTTP header `Accept` 14043 header_params['Accept'] = self.api_client.\ 14044 select_header_accept(['application/json']) 14045 14046 # HTTP header `Content-Type` 14047 header_params['Content-Type'] = self.api_client.\ 14048 select_header_content_type(['image/gif']) 14049 14050 # Authentication setting 14051 auth_settings = [] 14052 14053 return self.api_client.call_api(resource_path, 'PUT', 14054 path_params, 14055 query_params, 14056 header_params, 14057 body=body_params, 14058 post_params=form_params, 14059 files=local_var_files, 14060 response_type=None, 14061 auth_settings=auth_settings, 14062 callback=params.get('callback'), 14063 _return_http_data_only=params.get('_return_http_data_only'), 14064 _preload_content=params.get('_preload_content', True), 14065 _request_timeout=params.get('_request_timeout'), 14066 collection_formats=collection_formats) 14067 14068 def update_recipients(self, account_id, envelope_id, **kwargs): 14069 """ 14070 Updates recipients in a draft envelope or corrects recipient information for an in process envelope. 14071 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). 14072 This method makes a synchronous HTTP request by default. To make an 14073 asynchronous HTTP request, please define a `callback` function 14074 to be invoked when receiving the response. 14075 >>> def callback_function(response): 14076 >>> pprint(response) 14077 >>> 14078 >>> thread = api.update_recipients(account_id, envelope_id, callback=callback_function) 14079 14080 :param callback function: The callback function 14081 for asynchronous request. (optional) 14082 :param str account_id: The external account number (int) or account ID Guid. (required) 14083 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14084 :param str combine_same_order_recipients: 14085 :param str offline_signing: 14086 :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. 14087 :param Recipients recipients: 14088 :return: RecipientsUpdateSummary 14089 If the method is called asynchronously, 14090 returns the request thread. 14091 """ 14092 kwargs['_return_http_data_only'] = True 14093 if kwargs.get('callback'): 14094 return self.update_recipients_with_http_info(account_id, envelope_id, **kwargs) 14095 else: 14096 (data) = self.update_recipients_with_http_info(account_id, envelope_id, **kwargs) 14097 return data 14098 14099 def update_recipients_with_http_info(self, account_id, envelope_id, **kwargs): 14100 """ 14101 Updates recipients in a draft envelope or corrects recipient information for an in process envelope. 14102 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). 14103 This method makes a synchronous HTTP request by default. To make an 14104 asynchronous HTTP request, please define a `callback` function 14105 to be invoked when receiving the response. 14106 >>> def callback_function(response): 14107 >>> pprint(response) 14108 >>> 14109 >>> thread = api.update_recipients_with_http_info(account_id, envelope_id, callback=callback_function) 14110 14111 :param callback function: The callback function 14112 for asynchronous request. (optional) 14113 :param str account_id: The external account number (int) or account ID Guid. (required) 14114 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14115 :param str combine_same_order_recipients: 14116 :param str offline_signing: 14117 :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. 14118 :param Recipients recipients: 14119 :return: RecipientsUpdateSummary 14120 If the method is called asynchronously, 14121 returns the request thread. 14122 """ 14123 14124 all_params = ['account_id', 'envelope_id', 'combine_same_order_recipients', 'offline_signing', 'resend_envelope', 'recipients'] 14125 all_params.append('callback') 14126 all_params.append('_return_http_data_only') 14127 all_params.append('_preload_content') 14128 all_params.append('_request_timeout') 14129 14130 params = locals() 14131 for key, val in iteritems(params['kwargs']): 14132 if key not in all_params: 14133 raise TypeError( 14134 "Got an unexpected keyword argument '%s'" 14135 " to method update_recipients" % key 14136 ) 14137 params[key] = val 14138 del params['kwargs'] 14139 # verify the required parameter 'account_id' is set 14140 if ('account_id' not in params) or (params['account_id'] is None): 14141 raise ValueError("Missing the required parameter `account_id` when calling `update_recipients`") 14142 # verify the required parameter 'envelope_id' is set 14143 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14144 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipients`") 14145 14146 14147 collection_formats = {} 14148 14149 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients'.replace('{format}', 'json') 14150 path_params = {} 14151 if 'account_id' in params: 14152 path_params['accountId'] = params['account_id'] 14153 if 'envelope_id' in params: 14154 path_params['envelopeId'] = params['envelope_id'] 14155 14156 query_params = {} 14157 if 'combine_same_order_recipients' in params: 14158 query_params['combine_same_order_recipients'] = params['combine_same_order_recipients'] 14159 if 'offline_signing' in params: 14160 query_params['offline_signing'] = params['offline_signing'] 14161 if 'resend_envelope' in params: 14162 query_params['resend_envelope'] = params['resend_envelope'] 14163 14164 header_params = {} 14165 14166 form_params = [] 14167 local_var_files = {} 14168 14169 body_params = None 14170 if 'recipients' in params: 14171 body_params = params['recipients'] 14172 # HTTP header `Accept` 14173 header_params['Accept'] = self.api_client.\ 14174 select_header_accept(['application/json']) 14175 14176 # Authentication setting 14177 auth_settings = [] 14178 14179 return self.api_client.call_api(resource_path, 'PUT', 14180 path_params, 14181 query_params, 14182 header_params, 14183 body=body_params, 14184 post_params=form_params, 14185 files=local_var_files, 14186 response_type='RecipientsUpdateSummary', 14187 auth_settings=auth_settings, 14188 callback=params.get('callback'), 14189 _return_http_data_only=params.get('_return_http_data_only'), 14190 _preload_content=params.get('_preload_content', True), 14191 _request_timeout=params.get('_request_timeout'), 14192 collection_formats=collection_formats) 14193 14194 def update_recipients_document_visibility(self, account_id, envelope_id, **kwargs): 14195 """ 14196 Updates document visibility for the recipients 14197 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. 14198 This method makes a synchronous HTTP request by default. To make an 14199 asynchronous HTTP request, please define a `callback` function 14200 to be invoked when receiving the response. 14201 >>> def callback_function(response): 14202 >>> pprint(response) 14203 >>> 14204 >>> thread = api.update_recipients_document_visibility(account_id, envelope_id, callback=callback_function) 14205 14206 :param callback function: The callback function 14207 for asynchronous request. (optional) 14208 :param str account_id: The external account number (int) or account ID Guid. (required) 14209 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14210 :param DocumentVisibilityList document_visibility_list: 14211 :return: DocumentVisibilityList 14212 If the method is called asynchronously, 14213 returns the request thread. 14214 """ 14215 kwargs['_return_http_data_only'] = True 14216 if kwargs.get('callback'): 14217 return self.update_recipients_document_visibility_with_http_info(account_id, envelope_id, **kwargs) 14218 else: 14219 (data) = self.update_recipients_document_visibility_with_http_info(account_id, envelope_id, **kwargs) 14220 return data 14221 14222 def update_recipients_document_visibility_with_http_info(self, account_id, envelope_id, **kwargs): 14223 """ 14224 Updates document visibility for the recipients 14225 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. 14226 This method makes a synchronous HTTP request by default. To make an 14227 asynchronous HTTP request, please define a `callback` function 14228 to be invoked when receiving the response. 14229 >>> def callback_function(response): 14230 >>> pprint(response) 14231 >>> 14232 >>> thread = api.update_recipients_document_visibility_with_http_info(account_id, envelope_id, callback=callback_function) 14233 14234 :param callback function: The callback function 14235 for asynchronous request. (optional) 14236 :param str account_id: The external account number (int) or account ID Guid. (required) 14237 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14238 :param DocumentVisibilityList document_visibility_list: 14239 :return: DocumentVisibilityList 14240 If the method is called asynchronously, 14241 returns the request thread. 14242 """ 14243 14244 all_params = ['account_id', 'envelope_id', 'document_visibility_list'] 14245 all_params.append('callback') 14246 all_params.append('_return_http_data_only') 14247 all_params.append('_preload_content') 14248 all_params.append('_request_timeout') 14249 14250 params = locals() 14251 for key, val in iteritems(params['kwargs']): 14252 if key not in all_params: 14253 raise TypeError( 14254 "Got an unexpected keyword argument '%s'" 14255 " to method update_recipients_document_visibility" % key 14256 ) 14257 params[key] = val 14258 del params['kwargs'] 14259 # verify the required parameter 'account_id' is set 14260 if ('account_id' not in params) or (params['account_id'] is None): 14261 raise ValueError("Missing the required parameter `account_id` when calling `update_recipients_document_visibility`") 14262 # verify the required parameter 'envelope_id' is set 14263 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14264 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipients_document_visibility`") 14265 14266 14267 collection_formats = {} 14268 14269 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/document_visibility'.replace('{format}', 'json') 14270 path_params = {} 14271 if 'account_id' in params: 14272 path_params['accountId'] = params['account_id'] 14273 if 'envelope_id' in params: 14274 path_params['envelopeId'] = params['envelope_id'] 14275 14276 query_params = {} 14277 14278 header_params = {} 14279 14280 form_params = [] 14281 local_var_files = {} 14282 14283 body_params = None 14284 if 'document_visibility_list' in params: 14285 body_params = params['document_visibility_list'] 14286 # HTTP header `Accept` 14287 header_params['Accept'] = self.api_client.\ 14288 select_header_accept(['application/json']) 14289 14290 # Authentication setting 14291 auth_settings = [] 14292 14293 return self.api_client.call_api(resource_path, 'PUT', 14294 path_params, 14295 query_params, 14296 header_params, 14297 body=body_params, 14298 post_params=form_params, 14299 files=local_var_files, 14300 response_type='DocumentVisibilityList', 14301 auth_settings=auth_settings, 14302 callback=params.get('callback'), 14303 _return_http_data_only=params.get('_return_http_data_only'), 14304 _preload_content=params.get('_preload_content', True), 14305 _request_timeout=params.get('_request_timeout'), 14306 collection_formats=collection_formats) 14307 14308 def update_tabs(self, account_id, envelope_id, recipient_id, **kwargs): 14309 """ 14310 Updates the tabs for a recipient. 14311 Updates one or more tabs for a recipient in a draft envelope. 14312 This method makes a synchronous HTTP request by default. To make an 14313 asynchronous HTTP request, please define a `callback` function 14314 to be invoked when receiving the response. 14315 >>> def callback_function(response): 14316 >>> pprint(response) 14317 >>> 14318 >>> thread = api.update_tabs(account_id, envelope_id, recipient_id, callback=callback_function) 14319 14320 :param callback function: The callback function 14321 for asynchronous request. (optional) 14322 :param str account_id: The external account number (int) or account ID Guid. (required) 14323 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14324 :param str recipient_id: The ID of the recipient being accessed. (required) 14325 :param Tabs tabs: 14326 :return: Tabs 14327 If the method is called asynchronously, 14328 returns the request thread. 14329 """ 14330 kwargs['_return_http_data_only'] = True 14331 if kwargs.get('callback'): 14332 return self.update_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 14333 else: 14334 (data) = self.update_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 14335 return data 14336 14337 def update_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 14338 """ 14339 Updates the tabs for a recipient. 14340 Updates one or more tabs for a recipient in a draft envelope. 14341 This method makes a synchronous HTTP request by default. To make an 14342 asynchronous HTTP request, please define a `callback` function 14343 to be invoked when receiving the response. 14344 >>> def callback_function(response): 14345 >>> pprint(response) 14346 >>> 14347 >>> thread = api.update_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 14348 14349 :param callback function: The callback function 14350 for asynchronous request. (optional) 14351 :param str account_id: The external account number (int) or account ID Guid. (required) 14352 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14353 :param str recipient_id: The ID of the recipient being accessed. (required) 14354 :param Tabs tabs: 14355 :return: Tabs 14356 If the method is called asynchronously, 14357 returns the request thread. 14358 """ 14359 14360 all_params = ['account_id', 'envelope_id', 'recipient_id', 'tabs'] 14361 all_params.append('callback') 14362 all_params.append('_return_http_data_only') 14363 all_params.append('_preload_content') 14364 all_params.append('_request_timeout') 14365 14366 params = locals() 14367 for key, val in iteritems(params['kwargs']): 14368 if key not in all_params: 14369 raise TypeError( 14370 "Got an unexpected keyword argument '%s'" 14371 " to method update_tabs" % key 14372 ) 14373 params[key] = val 14374 del params['kwargs'] 14375 # verify the required parameter 'account_id' is set 14376 if ('account_id' not in params) or (params['account_id'] is None): 14377 raise ValueError("Missing the required parameter `account_id` when calling `update_tabs`") 14378 # verify the required parameter 'envelope_id' is set 14379 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14380 raise ValueError("Missing the required parameter `envelope_id` when calling `update_tabs`") 14381 # verify the required parameter 'recipient_id' is set 14382 if ('recipient_id' not in params) or (params['recipient_id'] is None): 14383 raise ValueError("Missing the required parameter `recipient_id` when calling `update_tabs`") 14384 14385 14386 collection_formats = {} 14387 14388 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/tabs'.replace('{format}', 'json') 14389 path_params = {} 14390 if 'account_id' in params: 14391 path_params['accountId'] = params['account_id'] 14392 if 'envelope_id' in params: 14393 path_params['envelopeId'] = params['envelope_id'] 14394 if 'recipient_id' in params: 14395 path_params['recipientId'] = params['recipient_id'] 14396 14397 query_params = {} 14398 14399 header_params = {} 14400 14401 form_params = [] 14402 local_var_files = {} 14403 14404 body_params = None 14405 if 'tabs' in params: 14406 body_params = params['tabs'] 14407 # HTTP header `Accept` 14408 header_params['Accept'] = self.api_client.\ 14409 select_header_accept(['application/json']) 14410 14411 # Authentication setting 14412 auth_settings = [] 14413 14414 return self.api_client.call_api(resource_path, 'PUT', 14415 path_params, 14416 query_params, 14417 header_params, 14418 body=body_params, 14419 post_params=form_params, 14420 files=local_var_files, 14421 response_type='Tabs', 14422 auth_settings=auth_settings, 14423 callback=params.get('callback'), 14424 _return_http_data_only=params.get('_return_http_data_only'), 14425 _preload_content=params.get('_preload_content', True), 14426 _request_timeout=params.get('_request_timeout'), 14427 collection_formats=collection_formats) 14428 14429 def update_tabs_blob(self, account_id, envelope_id, **kwargs): 14430 """ 14431 Update encrypted tabs for envelope. 14432 14433 This method makes a synchronous HTTP request by default. To make an 14434 asynchronous HTTP request, please define a `callback` function 14435 to be invoked when receiving the response. 14436 >>> def callback_function(response): 14437 >>> pprint(response) 14438 >>> 14439 >>> thread = api.update_tabs_blob(account_id, envelope_id, callback=callback_function) 14440 14441 :param callback function: The callback function 14442 for asynchronous request. (optional) 14443 :param str account_id: The external account number (int) or account ID Guid. (required) 14444 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14445 :return: None 14446 If the method is called asynchronously, 14447 returns the request thread. 14448 """ 14449 kwargs['_return_http_data_only'] = True 14450 if kwargs.get('callback'): 14451 return self.update_tabs_blob_with_http_info(account_id, envelope_id, **kwargs) 14452 else: 14453 (data) = self.update_tabs_blob_with_http_info(account_id, envelope_id, **kwargs) 14454 return data 14455 14456 def update_tabs_blob_with_http_info(self, account_id, envelope_id, **kwargs): 14457 """ 14458 Update encrypted tabs for envelope. 14459 14460 This method makes a synchronous HTTP request by default. To make an 14461 asynchronous HTTP request, please define a `callback` function 14462 to be invoked when receiving the response. 14463 >>> def callback_function(response): 14464 >>> pprint(response) 14465 >>> 14466 >>> thread = api.update_tabs_blob_with_http_info(account_id, envelope_id, callback=callback_function) 14467 14468 :param callback function: The callback function 14469 for asynchronous request. (optional) 14470 :param str account_id: The external account number (int) or account ID Guid. (required) 14471 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14472 :return: None 14473 If the method is called asynchronously, 14474 returns the request thread. 14475 """ 14476 14477 all_params = ['account_id', 'envelope_id'] 14478 all_params.append('callback') 14479 all_params.append('_return_http_data_only') 14480 all_params.append('_preload_content') 14481 all_params.append('_request_timeout') 14482 14483 params = locals() 14484 for key, val in iteritems(params['kwargs']): 14485 if key not in all_params: 14486 raise TypeError( 14487 "Got an unexpected keyword argument '%s'" 14488 " to method update_tabs_blob" % key 14489 ) 14490 params[key] = val 14491 del params['kwargs'] 14492 # verify the required parameter 'account_id' is set 14493 if ('account_id' not in params) or (params['account_id'] is None): 14494 raise ValueError("Missing the required parameter `account_id` when calling `update_tabs_blob`") 14495 # verify the required parameter 'envelope_id' is set 14496 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14497 raise ValueError("Missing the required parameter `envelope_id` when calling `update_tabs_blob`") 14498 14499 14500 collection_formats = {} 14501 14502 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/tabs_blob'.replace('{format}', 'json') 14503 path_params = {} 14504 if 'account_id' in params: 14505 path_params['accountId'] = params['account_id'] 14506 if 'envelope_id' in params: 14507 path_params['envelopeId'] = params['envelope_id'] 14508 14509 query_params = {} 14510 14511 header_params = {} 14512 14513 form_params = [] 14514 local_var_files = {} 14515 14516 body_params = None 14517 # HTTP header `Accept` 14518 header_params['Accept'] = self.api_client.\ 14519 select_header_accept(['application/json']) 14520 14521 # Authentication setting 14522 auth_settings = [] 14523 14524 return self.api_client.call_api(resource_path, 'PUT', 14525 path_params, 14526 query_params, 14527 header_params, 14528 body=body_params, 14529 post_params=form_params, 14530 files=local_var_files, 14531 response_type=None, 14532 auth_settings=auth_settings, 14533 callback=params.get('callback'), 14534 _return_http_data_only=params.get('_return_http_data_only'), 14535 _preload_content=params.get('_preload_content', True), 14536 _request_timeout=params.get('_request_timeout'), 14537 collection_formats=collection_formats) 14538 14539 def update_template_delayed_routing_definition(self, account_id, template_id, workflow_step_id, **kwargs): 14540 """ 14541 Updates the delayed routing rules for a template's workflow step definition. 14542 This method makes a synchronous HTTP request by default. To make an 14543 asynchronous HTTP request, please define a `callback` function 14544 to be invoked when receiving the response. 14545 >>> def callback_function(response): 14546 >>> pprint(response) 14547 >>> 14548 >>> thread = api.update_template_delayed_routing_definition(account_id, template_id, workflow_step_id, callback=callback_function) 14549 14550 :param callback function: The callback function 14551 for asynchronous request. (optional) 14552 :param str account_id: The external account number (int) or account ID Guid. (required) 14553 :param str template_id: The ID of the template being accessed. (required) 14554 :param str workflow_step_id: (required) 14555 :param DelayedRouting delayed_routing: 14556 :return: DelayedRouting 14557 If the method is called asynchronously, 14558 returns the request thread. 14559 """ 14560 kwargs['_return_http_data_only'] = True 14561 if kwargs.get('callback'): 14562 return self.update_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 14563 else: 14564 (data) = self.update_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 14565 return data 14566 14567 def update_template_delayed_routing_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 14568 """ 14569 Updates the delayed routing rules for a template's workflow step definition. 14570 This method makes a synchronous HTTP request by default. To make an 14571 asynchronous HTTP request, please define a `callback` function 14572 to be invoked when receiving the response. 14573 >>> def callback_function(response): 14574 >>> pprint(response) 14575 >>> 14576 >>> thread = api.update_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 14577 14578 :param callback function: The callback function 14579 for asynchronous request. (optional) 14580 :param str account_id: The external account number (int) or account ID Guid. (required) 14581 :param str template_id: The ID of the template being accessed. (required) 14582 :param str workflow_step_id: (required) 14583 :param DelayedRouting delayed_routing: 14584 :return: DelayedRouting 14585 If the method is called asynchronously, 14586 returns the request thread. 14587 """ 14588 14589 all_params = ['account_id', 'template_id', 'workflow_step_id', 'delayed_routing'] 14590 all_params.append('callback') 14591 all_params.append('_return_http_data_only') 14592 all_params.append('_preload_content') 14593 all_params.append('_request_timeout') 14594 14595 params = locals() 14596 for key, val in iteritems(params['kwargs']): 14597 if key not in all_params: 14598 raise TypeError( 14599 "Got an unexpected keyword argument '%s'" 14600 " to method update_template_delayed_routing_definition" % key 14601 ) 14602 params[key] = val 14603 del params['kwargs'] 14604 # verify the required parameter 'account_id' is set 14605 if ('account_id' not in params) or (params['account_id'] is None): 14606 raise ValueError("Missing the required parameter `account_id` when calling `update_template_delayed_routing_definition`") 14607 # verify the required parameter 'template_id' is set 14608 if ('template_id' not in params) or (params['template_id'] is None): 14609 raise ValueError("Missing the required parameter `template_id` when calling `update_template_delayed_routing_definition`") 14610 # verify the required parameter 'workflow_step_id' is set 14611 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 14612 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_template_delayed_routing_definition`") 14613 14614 14615 collection_formats = {} 14616 14617 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 14618 path_params = {} 14619 if 'account_id' in params: 14620 path_params['accountId'] = params['account_id'] 14621 if 'template_id' in params: 14622 path_params['templateId'] = params['template_id'] 14623 if 'workflow_step_id' in params: 14624 path_params['workflowStepId'] = params['workflow_step_id'] 14625 14626 query_params = {} 14627 14628 header_params = {} 14629 14630 form_params = [] 14631 local_var_files = {} 14632 14633 body_params = None 14634 if 'delayed_routing' in params: 14635 body_params = params['delayed_routing'] 14636 # HTTP header `Accept` 14637 header_params['Accept'] = self.api_client.\ 14638 select_header_accept(['application/json']) 14639 14640 # Authentication setting 14641 auth_settings = [] 14642 14643 return self.api_client.call_api(resource_path, 'PUT', 14644 path_params, 14645 query_params, 14646 header_params, 14647 body=body_params, 14648 post_params=form_params, 14649 files=local_var_files, 14650 response_type='DelayedRouting', 14651 auth_settings=auth_settings, 14652 callback=params.get('callback'), 14653 _return_http_data_only=params.get('_return_http_data_only'), 14654 _preload_content=params.get('_preload_content', True), 14655 _request_timeout=params.get('_request_timeout'), 14656 collection_formats=collection_formats) 14657 14658 def update_template_recipient_document_visibility(self, account_id, recipient_id, template_id, **kwargs): 14659 """ 14660 Updates document visibility for the recipients 14661 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. 14662 This method makes a synchronous HTTP request by default. To make an 14663 asynchronous HTTP request, please define a `callback` function 14664 to be invoked when receiving the response. 14665 >>> def callback_function(response): 14666 >>> pprint(response) 14667 >>> 14668 >>> thread = api.update_template_recipient_document_visibility(account_id, recipient_id, template_id, callback=callback_function) 14669 14670 :param callback function: The callback function 14671 for asynchronous request. (optional) 14672 :param str account_id: The external account number (int) or account ID Guid. (required) 14673 :param str recipient_id: The ID of the recipient being accessed. (required) 14674 :param str template_id: The ID of the template being accessed. (required) 14675 :param TemplateDocumentVisibilityList template_document_visibility_list: 14676 :return: TemplateDocumentVisibilityList 14677 If the method is called asynchronously, 14678 returns the request thread. 14679 """ 14680 kwargs['_return_http_data_only'] = True 14681 if kwargs.get('callback'): 14682 return self.update_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, **kwargs) 14683 else: 14684 (data) = self.update_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, **kwargs) 14685 return data 14686 14687 def update_template_recipient_document_visibility_with_http_info(self, account_id, recipient_id, template_id, **kwargs): 14688 """ 14689 Updates document visibility for the recipients 14690 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. 14691 This method makes a synchronous HTTP request by default. To make an 14692 asynchronous HTTP request, please define a `callback` function 14693 to be invoked when receiving the response. 14694 >>> def callback_function(response): 14695 >>> pprint(response) 14696 >>> 14697 >>> thread = api.update_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, callback=callback_function) 14698 14699 :param callback function: The callback function 14700 for asynchronous request. (optional) 14701 :param str account_id: The external account number (int) or account ID Guid. (required) 14702 :param str recipient_id: The ID of the recipient being accessed. (required) 14703 :param str template_id: The ID of the template being accessed. (required) 14704 :param TemplateDocumentVisibilityList template_document_visibility_list: 14705 :return: TemplateDocumentVisibilityList 14706 If the method is called asynchronously, 14707 returns the request thread. 14708 """ 14709 14710 all_params = ['account_id', 'recipient_id', 'template_id', 'template_document_visibility_list'] 14711 all_params.append('callback') 14712 all_params.append('_return_http_data_only') 14713 all_params.append('_preload_content') 14714 all_params.append('_request_timeout') 14715 14716 params = locals() 14717 for key, val in iteritems(params['kwargs']): 14718 if key not in all_params: 14719 raise TypeError( 14720 "Got an unexpected keyword argument '%s'" 14721 " to method update_template_recipient_document_visibility" % key 14722 ) 14723 params[key] = val 14724 del params['kwargs'] 14725 # verify the required parameter 'account_id' is set 14726 if ('account_id' not in params) or (params['account_id'] is None): 14727 raise ValueError("Missing the required parameter `account_id` when calling `update_template_recipient_document_visibility`") 14728 # verify the required parameter 'recipient_id' is set 14729 if ('recipient_id' not in params) or (params['recipient_id'] is None): 14730 raise ValueError("Missing the required parameter `recipient_id` when calling `update_template_recipient_document_visibility`") 14731 # verify the required parameter 'template_id' is set 14732 if ('template_id' not in params) or (params['template_id'] is None): 14733 raise ValueError("Missing the required parameter `template_id` when calling `update_template_recipient_document_visibility`") 14734 14735 14736 collection_formats = {} 14737 14738 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/recipients/{recipientId}/document_visibility'.replace('{format}', 'json') 14739 path_params = {} 14740 if 'account_id' in params: 14741 path_params['accountId'] = params['account_id'] 14742 if 'recipient_id' in params: 14743 path_params['recipientId'] = params['recipient_id'] 14744 if 'template_id' in params: 14745 path_params['templateId'] = params['template_id'] 14746 14747 query_params = {} 14748 14749 header_params = {} 14750 14751 form_params = [] 14752 local_var_files = {} 14753 14754 body_params = None 14755 if 'template_document_visibility_list' in params: 14756 body_params = params['template_document_visibility_list'] 14757 # HTTP header `Accept` 14758 header_params['Accept'] = self.api_client.\ 14759 select_header_accept(['application/json']) 14760 14761 # Authentication setting 14762 auth_settings = [] 14763 14764 return self.api_client.call_api(resource_path, 'PUT', 14765 path_params, 14766 query_params, 14767 header_params, 14768 body=body_params, 14769 post_params=form_params, 14770 files=local_var_files, 14771 response_type='TemplateDocumentVisibilityList', 14772 auth_settings=auth_settings, 14773 callback=params.get('callback'), 14774 _return_http_data_only=params.get('_return_http_data_only'), 14775 _preload_content=params.get('_preload_content', True), 14776 _request_timeout=params.get('_request_timeout'), 14777 collection_formats=collection_formats) 14778 14779 def update_template_recipients_document_visibility(self, account_id, template_id, **kwargs): 14780 """ 14781 Updates document visibility for the recipients 14782 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. 14783 This method makes a synchronous HTTP request by default. To make an 14784 asynchronous HTTP request, please define a `callback` function 14785 to be invoked when receiving the response. 14786 >>> def callback_function(response): 14787 >>> pprint(response) 14788 >>> 14789 >>> thread = api.update_template_recipients_document_visibility(account_id, template_id, callback=callback_function) 14790 14791 :param callback function: The callback function 14792 for asynchronous request. (optional) 14793 :param str account_id: The external account number (int) or account ID Guid. (required) 14794 :param str template_id: The ID of the template being accessed. (required) 14795 :param TemplateDocumentVisibilityList template_document_visibility_list: 14796 :return: TemplateDocumentVisibilityList 14797 If the method is called asynchronously, 14798 returns the request thread. 14799 """ 14800 kwargs['_return_http_data_only'] = True 14801 if kwargs.get('callback'): 14802 return self.update_template_recipients_document_visibility_with_http_info(account_id, template_id, **kwargs) 14803 else: 14804 (data) = self.update_template_recipients_document_visibility_with_http_info(account_id, template_id, **kwargs) 14805 return data 14806 14807 def update_template_recipients_document_visibility_with_http_info(self, account_id, template_id, **kwargs): 14808 """ 14809 Updates document visibility for the recipients 14810 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. 14811 This method makes a synchronous HTTP request by default. To make an 14812 asynchronous HTTP request, please define a `callback` function 14813 to be invoked when receiving the response. 14814 >>> def callback_function(response): 14815 >>> pprint(response) 14816 >>> 14817 >>> thread = api.update_template_recipients_document_visibility_with_http_info(account_id, template_id, callback=callback_function) 14818 14819 :param callback function: The callback function 14820 for asynchronous request. (optional) 14821 :param str account_id: The external account number (int) or account ID Guid. (required) 14822 :param str template_id: The ID of the template being accessed. (required) 14823 :param TemplateDocumentVisibilityList template_document_visibility_list: 14824 :return: TemplateDocumentVisibilityList 14825 If the method is called asynchronously, 14826 returns the request thread. 14827 """ 14828 14829 all_params = ['account_id', 'template_id', 'template_document_visibility_list'] 14830 all_params.append('callback') 14831 all_params.append('_return_http_data_only') 14832 all_params.append('_preload_content') 14833 all_params.append('_request_timeout') 14834 14835 params = locals() 14836 for key, val in iteritems(params['kwargs']): 14837 if key not in all_params: 14838 raise TypeError( 14839 "Got an unexpected keyword argument '%s'" 14840 " to method update_template_recipients_document_visibility" % key 14841 ) 14842 params[key] = val 14843 del params['kwargs'] 14844 # verify the required parameter 'account_id' is set 14845 if ('account_id' not in params) or (params['account_id'] is None): 14846 raise ValueError("Missing the required parameter `account_id` when calling `update_template_recipients_document_visibility`") 14847 # verify the required parameter 'template_id' is set 14848 if ('template_id' not in params) or (params['template_id'] is None): 14849 raise ValueError("Missing the required parameter `template_id` when calling `update_template_recipients_document_visibility`") 14850 14851 14852 collection_formats = {} 14853 14854 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/recipients/document_visibility'.replace('{format}', 'json') 14855 path_params = {} 14856 if 'account_id' in params: 14857 path_params['accountId'] = params['account_id'] 14858 if 'template_id' in params: 14859 path_params['templateId'] = params['template_id'] 14860 14861 query_params = {} 14862 14863 header_params = {} 14864 14865 form_params = [] 14866 local_var_files = {} 14867 14868 body_params = None 14869 if 'template_document_visibility_list' in params: 14870 body_params = params['template_document_visibility_list'] 14871 # HTTP header `Accept` 14872 header_params['Accept'] = self.api_client.\ 14873 select_header_accept(['application/json']) 14874 14875 # Authentication setting 14876 auth_settings = [] 14877 14878 return self.api_client.call_api(resource_path, 'PUT', 14879 path_params, 14880 query_params, 14881 header_params, 14882 body=body_params, 14883 post_params=form_params, 14884 files=local_var_files, 14885 response_type='TemplateDocumentVisibilityList', 14886 auth_settings=auth_settings, 14887 callback=params.get('callback'), 14888 _return_http_data_only=params.get('_return_http_data_only'), 14889 _preload_content=params.get('_preload_content', True), 14890 _request_timeout=params.get('_request_timeout'), 14891 collection_formats=collection_formats) 14892 14893 def update_template_scheduled_sending_definition(self, account_id, template_id, **kwargs): 14894 """ 14895 Updates the scheduled sending rules for a template's workflow definition. 14896 This method makes a synchronous HTTP request by default. To make an 14897 asynchronous HTTP request, please define a `callback` function 14898 to be invoked when receiving the response. 14899 >>> def callback_function(response): 14900 >>> pprint(response) 14901 >>> 14902 >>> thread = api.update_template_scheduled_sending_definition(account_id, template_id, callback=callback_function) 14903 14904 :param callback function: The callback function 14905 for asynchronous request. (optional) 14906 :param str account_id: The external account number (int) or account ID Guid. (required) 14907 :param str template_id: The ID of the template being accessed. (required) 14908 :param ScheduledSending scheduled_sending: 14909 :return: ScheduledSending 14910 If the method is called asynchronously, 14911 returns the request thread. 14912 """ 14913 kwargs['_return_http_data_only'] = True 14914 if kwargs.get('callback'): 14915 return self.update_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 14916 else: 14917 (data) = self.update_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 14918 return data 14919 14920 def update_template_scheduled_sending_definition_with_http_info(self, account_id, template_id, **kwargs): 14921 """ 14922 Updates the scheduled sending rules for a template's workflow definition. 14923 This method makes a synchronous HTTP request by default. To make an 14924 asynchronous HTTP request, please define a `callback` function 14925 to be invoked when receiving the response. 14926 >>> def callback_function(response): 14927 >>> pprint(response) 14928 >>> 14929 >>> thread = api.update_template_scheduled_sending_definition_with_http_info(account_id, template_id, callback=callback_function) 14930 14931 :param callback function: The callback function 14932 for asynchronous request. (optional) 14933 :param str account_id: The external account number (int) or account ID Guid. (required) 14934 :param str template_id: The ID of the template being accessed. (required) 14935 :param ScheduledSending scheduled_sending: 14936 :return: ScheduledSending 14937 If the method is called asynchronously, 14938 returns the request thread. 14939 """ 14940 14941 all_params = ['account_id', 'template_id', 'scheduled_sending'] 14942 all_params.append('callback') 14943 all_params.append('_return_http_data_only') 14944 all_params.append('_preload_content') 14945 all_params.append('_request_timeout') 14946 14947 params = locals() 14948 for key, val in iteritems(params['kwargs']): 14949 if key not in all_params: 14950 raise TypeError( 14951 "Got an unexpected keyword argument '%s'" 14952 " to method update_template_scheduled_sending_definition" % key 14953 ) 14954 params[key] = val 14955 del params['kwargs'] 14956 # verify the required parameter 'account_id' is set 14957 if ('account_id' not in params) or (params['account_id'] is None): 14958 raise ValueError("Missing the required parameter `account_id` when calling `update_template_scheduled_sending_definition`") 14959 # verify the required parameter 'template_id' is set 14960 if ('template_id' not in params) or (params['template_id'] is None): 14961 raise ValueError("Missing the required parameter `template_id` when calling `update_template_scheduled_sending_definition`") 14962 14963 14964 collection_formats = {} 14965 14966 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/scheduledSending'.replace('{format}', 'json') 14967 path_params = {} 14968 if 'account_id' in params: 14969 path_params['accountId'] = params['account_id'] 14970 if 'template_id' in params: 14971 path_params['templateId'] = params['template_id'] 14972 14973 query_params = {} 14974 14975 header_params = {} 14976 14977 form_params = [] 14978 local_var_files = {} 14979 14980 body_params = None 14981 if 'scheduled_sending' in params: 14982 body_params = params['scheduled_sending'] 14983 # HTTP header `Accept` 14984 header_params['Accept'] = self.api_client.\ 14985 select_header_accept(['application/json']) 14986 14987 # Authentication setting 14988 auth_settings = [] 14989 14990 return self.api_client.call_api(resource_path, 'PUT', 14991 path_params, 14992 query_params, 14993 header_params, 14994 body=body_params, 14995 post_params=form_params, 14996 files=local_var_files, 14997 response_type='ScheduledSending', 14998 auth_settings=auth_settings, 14999 callback=params.get('callback'), 15000 _return_http_data_only=params.get('_return_http_data_only'), 15001 _preload_content=params.get('_preload_content', True), 15002 _request_timeout=params.get('_request_timeout'), 15003 collection_formats=collection_formats) 15004 15005 def update_template_workflow_definition(self, account_id, template_id, **kwargs): 15006 """ 15007 Updates the workflow definition for a template. 15008 Updates the specified template's workflow definition if it has one. 15009 This method makes a synchronous HTTP request by default. To make an 15010 asynchronous HTTP request, please define a `callback` function 15011 to be invoked when receiving the response. 15012 >>> def callback_function(response): 15013 >>> pprint(response) 15014 >>> 15015 >>> thread = api.update_template_workflow_definition(account_id, template_id, callback=callback_function) 15016 15017 :param callback function: The callback function 15018 for asynchronous request. (optional) 15019 :param str account_id: The external account number (int) or account ID Guid. (required) 15020 :param str template_id: The ID of the template being accessed. (required) 15021 :param Workflow workflow: 15022 :return: Workflow 15023 If the method is called asynchronously, 15024 returns the request thread. 15025 """ 15026 kwargs['_return_http_data_only'] = True 15027 if kwargs.get('callback'): 15028 return self.update_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 15029 else: 15030 (data) = self.update_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 15031 return data 15032 15033 def update_template_workflow_definition_with_http_info(self, account_id, template_id, **kwargs): 15034 """ 15035 Updates the workflow definition for a template. 15036 Updates the specified template's workflow definition if it has one. 15037 This method makes a synchronous HTTP request by default. To make an 15038 asynchronous HTTP request, please define a `callback` function 15039 to be invoked when receiving the response. 15040 >>> def callback_function(response): 15041 >>> pprint(response) 15042 >>> 15043 >>> thread = api.update_template_workflow_definition_with_http_info(account_id, template_id, callback=callback_function) 15044 15045 :param callback function: The callback function 15046 for asynchronous request. (optional) 15047 :param str account_id: The external account number (int) or account ID Guid. (required) 15048 :param str template_id: The ID of the template being accessed. (required) 15049 :param Workflow workflow: 15050 :return: Workflow 15051 If the method is called asynchronously, 15052 returns the request thread. 15053 """ 15054 15055 all_params = ['account_id', 'template_id', 'workflow'] 15056 all_params.append('callback') 15057 all_params.append('_return_http_data_only') 15058 all_params.append('_preload_content') 15059 all_params.append('_request_timeout') 15060 15061 params = locals() 15062 for key, val in iteritems(params['kwargs']): 15063 if key not in all_params: 15064 raise TypeError( 15065 "Got an unexpected keyword argument '%s'" 15066 " to method update_template_workflow_definition" % key 15067 ) 15068 params[key] = val 15069 del params['kwargs'] 15070 # verify the required parameter 'account_id' is set 15071 if ('account_id' not in params) or (params['account_id'] is None): 15072 raise ValueError("Missing the required parameter `account_id` when calling `update_template_workflow_definition`") 15073 # verify the required parameter 'template_id' is set 15074 if ('template_id' not in params) or (params['template_id'] is None): 15075 raise ValueError("Missing the required parameter `template_id` when calling `update_template_workflow_definition`") 15076 15077 15078 collection_formats = {} 15079 15080 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow'.replace('{format}', 'json') 15081 path_params = {} 15082 if 'account_id' in params: 15083 path_params['accountId'] = params['account_id'] 15084 if 'template_id' in params: 15085 path_params['templateId'] = params['template_id'] 15086 15087 query_params = {} 15088 15089 header_params = {} 15090 15091 form_params = [] 15092 local_var_files = {} 15093 15094 body_params = None 15095 if 'workflow' in params: 15096 body_params = params['workflow'] 15097 # HTTP header `Accept` 15098 header_params['Accept'] = self.api_client.\ 15099 select_header_accept(['application/json']) 15100 15101 # Authentication setting 15102 auth_settings = [] 15103 15104 return self.api_client.call_api(resource_path, 'PUT', 15105 path_params, 15106 query_params, 15107 header_params, 15108 body=body_params, 15109 post_params=form_params, 15110 files=local_var_files, 15111 response_type='Workflow', 15112 auth_settings=auth_settings, 15113 callback=params.get('callback'), 15114 _return_http_data_only=params.get('_return_http_data_only'), 15115 _preload_content=params.get('_preload_content', True), 15116 _request_timeout=params.get('_request_timeout'), 15117 collection_formats=collection_formats) 15118 15119 def update_template_workflow_step_definition(self, account_id, template_id, workflow_step_id, **kwargs): 15120 """ 15121 Updates the template workflow step definition for an envelope. 15122 This method makes a synchronous HTTP request by default. To make an 15123 asynchronous HTTP request, please define a `callback` function 15124 to be invoked when receiving the response. 15125 >>> def callback_function(response): 15126 >>> pprint(response) 15127 >>> 15128 >>> thread = api.update_template_workflow_step_definition(account_id, template_id, workflow_step_id, callback=callback_function) 15129 15130 :param callback function: The callback function 15131 for asynchronous request. (optional) 15132 :param str account_id: The external account number (int) or account ID Guid. (required) 15133 :param str template_id: The ID of the template being accessed. (required) 15134 :param str workflow_step_id: (required) 15135 :param WorkflowStep workflow_step: 15136 :return: WorkflowStep 15137 If the method is called asynchronously, 15138 returns the request thread. 15139 """ 15140 kwargs['_return_http_data_only'] = True 15141 if kwargs.get('callback'): 15142 return self.update_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 15143 else: 15144 (data) = self.update_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 15145 return data 15146 15147 def update_template_workflow_step_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 15148 """ 15149 Updates the template workflow step definition for an envelope. 15150 This method makes a synchronous HTTP request by default. To make an 15151 asynchronous HTTP request, please define a `callback` function 15152 to be invoked when receiving the response. 15153 >>> def callback_function(response): 15154 >>> pprint(response) 15155 >>> 15156 >>> thread = api.update_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 15157 15158 :param callback function: The callback function 15159 for asynchronous request. (optional) 15160 :param str account_id: The external account number (int) or account ID Guid. (required) 15161 :param str template_id: The ID of the template being accessed. (required) 15162 :param str workflow_step_id: (required) 15163 :param WorkflowStep workflow_step: 15164 :return: WorkflowStep 15165 If the method is called asynchronously, 15166 returns the request thread. 15167 """ 15168 15169 all_params = ['account_id', 'template_id', 'workflow_step_id', 'workflow_step'] 15170 all_params.append('callback') 15171 all_params.append('_return_http_data_only') 15172 all_params.append('_preload_content') 15173 all_params.append('_request_timeout') 15174 15175 params = locals() 15176 for key, val in iteritems(params['kwargs']): 15177 if key not in all_params: 15178 raise TypeError( 15179 "Got an unexpected keyword argument '%s'" 15180 " to method update_template_workflow_step_definition" % key 15181 ) 15182 params[key] = val 15183 del params['kwargs'] 15184 # verify the required parameter 'account_id' is set 15185 if ('account_id' not in params) or (params['account_id'] is None): 15186 raise ValueError("Missing the required parameter `account_id` when calling `update_template_workflow_step_definition`") 15187 # verify the required parameter 'template_id' is set 15188 if ('template_id' not in params) or (params['template_id'] is None): 15189 raise ValueError("Missing the required parameter `template_id` when calling `update_template_workflow_step_definition`") 15190 # verify the required parameter 'workflow_step_id' is set 15191 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 15192 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_template_workflow_step_definition`") 15193 15194 15195 collection_formats = {} 15196 15197 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 15198 path_params = {} 15199 if 'account_id' in params: 15200 path_params['accountId'] = params['account_id'] 15201 if 'template_id' in params: 15202 path_params['templateId'] = params['template_id'] 15203 if 'workflow_step_id' in params: 15204 path_params['workflowStepId'] = params['workflow_step_id'] 15205 15206 query_params = {} 15207 15208 header_params = {} 15209 15210 form_params = [] 15211 local_var_files = {} 15212 15213 body_params = None 15214 if 'workflow_step' in params: 15215 body_params = params['workflow_step'] 15216 # HTTP header `Accept` 15217 header_params['Accept'] = self.api_client.\ 15218 select_header_accept(['application/json']) 15219 15220 # Authentication setting 15221 auth_settings = [] 15222 15223 return self.api_client.call_api(resource_path, 'PUT', 15224 path_params, 15225 query_params, 15226 header_params, 15227 body=body_params, 15228 post_params=form_params, 15229 files=local_var_files, 15230 response_type='WorkflowStep', 15231 auth_settings=auth_settings, 15232 callback=params.get('callback'), 15233 _return_http_data_only=params.get('_return_http_data_only'), 15234 _preload_content=params.get('_preload_content', True), 15235 _request_timeout=params.get('_request_timeout'), 15236 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 CorrectViewRequest correct_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 CorrectViewRequest correct_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', 'correct_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 'correct_view_request' in params: 592 body_params = params['correct_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 ReturnUrlRequest return_url_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 ReturnUrlRequest return_url_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', 'return_url_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 'return_url_request' in params: 1183 body_params = params['return_url_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, token_scopes, **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, token_scopes, 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: (required) 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, token_scopes, **kwargs) 2604 else: 2605 (data) = self.create_recipient_proof_file_resource_token_with_http_info(account_id, envelope_id, recipient_id, token_scopes, **kwargs) 2606 return data 2607 2608 def create_recipient_proof_file_resource_token_with_http_info(self, account_id, envelope_id, recipient_id, token_scopes, **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, token_scopes, 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: (required) 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 # verify the required parameter 'token_scopes' is set 2656 if ('token_scopes' not in params) or (params['token_scopes'] is None): 2657 raise ValueError("Missing the required parameter `token_scopes` when calling `create_recipient_proof_file_resource_token`") 2658 2659 2660 collection_formats = {} 2661 2662 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/identity_proof_token'.replace('{format}', 'json') 2663 path_params = {} 2664 if 'account_id' in params: 2665 path_params['accountId'] = params['account_id'] 2666 if 'envelope_id' in params: 2667 path_params['envelopeId'] = params['envelope_id'] 2668 if 'recipient_id' in params: 2669 path_params['recipientId'] = params['recipient_id'] 2670 if 'token_scopes' in params: 2671 path_params['token_scopes'] = params['token_scopes'] 2672 2673 query_params = {} 2674 2675 header_params = {} 2676 2677 form_params = [] 2678 local_var_files = {} 2679 2680 body_params = None 2681 # HTTP header `Accept` 2682 header_params['Accept'] = self.api_client.\ 2683 select_header_accept(['application/json']) 2684 2685 # Authentication setting 2686 auth_settings = [] 2687 2688 return self.api_client.call_api(resource_path, 'POST', 2689 path_params, 2690 query_params, 2691 header_params, 2692 body=body_params, 2693 post_params=form_params, 2694 files=local_var_files, 2695 response_type='IdEvidenceResourceToken', 2696 auth_settings=auth_settings, 2697 callback=params.get('callback'), 2698 _return_http_data_only=params.get('_return_http_data_only'), 2699 _preload_content=params.get('_preload_content', True), 2700 _request_timeout=params.get('_request_timeout'), 2701 collection_formats=collection_formats) 2702 2703 def create_recipient_view(self, account_id, envelope_id, **kwargs): 2704 """ 2705 Returns a URL to the recipient view UI. 2706 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. 2707 This method makes a synchronous HTTP request by default. To make an 2708 asynchronous HTTP request, please define a `callback` function 2709 to be invoked when receiving the response. 2710 >>> def callback_function(response): 2711 >>> pprint(response) 2712 >>> 2713 >>> thread = api.create_recipient_view(account_id, envelope_id, callback=callback_function) 2714 2715 :param callback function: The callback function 2716 for asynchronous request. (optional) 2717 :param str account_id: The external account number (int) or account ID Guid. (required) 2718 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2719 :param RecipientViewRequest recipient_view_request: 2720 :return: ViewUrl 2721 If the method is called asynchronously, 2722 returns the request thread. 2723 """ 2724 kwargs['_return_http_data_only'] = True 2725 if kwargs.get('callback'): 2726 return self.create_recipient_view_with_http_info(account_id, envelope_id, **kwargs) 2727 else: 2728 (data) = self.create_recipient_view_with_http_info(account_id, envelope_id, **kwargs) 2729 return data 2730 2731 def create_recipient_view_with_http_info(self, account_id, envelope_id, **kwargs): 2732 """ 2733 Returns a URL to the recipient view UI. 2734 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. 2735 This method makes a synchronous HTTP request by default. To make an 2736 asynchronous HTTP request, please define a `callback` function 2737 to be invoked when receiving the response. 2738 >>> def callback_function(response): 2739 >>> pprint(response) 2740 >>> 2741 >>> thread = api.create_recipient_view_with_http_info(account_id, envelope_id, callback=callback_function) 2742 2743 :param callback function: The callback function 2744 for asynchronous request. (optional) 2745 :param str account_id: The external account number (int) or account ID Guid. (required) 2746 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2747 :param RecipientViewRequest recipient_view_request: 2748 :return: ViewUrl 2749 If the method is called asynchronously, 2750 returns the request thread. 2751 """ 2752 2753 all_params = ['account_id', 'envelope_id', 'recipient_view_request'] 2754 all_params.append('callback') 2755 all_params.append('_return_http_data_only') 2756 all_params.append('_preload_content') 2757 all_params.append('_request_timeout') 2758 2759 params = locals() 2760 for key, val in iteritems(params['kwargs']): 2761 if key not in all_params: 2762 raise TypeError( 2763 "Got an unexpected keyword argument '%s'" 2764 " to method create_recipient_view" % key 2765 ) 2766 params[key] = val 2767 del params['kwargs'] 2768 # verify the required parameter 'account_id' is set 2769 if ('account_id' not in params) or (params['account_id'] is None): 2770 raise ValueError("Missing the required parameter `account_id` when calling `create_recipient_view`") 2771 # verify the required parameter 'envelope_id' is set 2772 if ('envelope_id' not in params) or (params['envelope_id'] is None): 2773 raise ValueError("Missing the required parameter `envelope_id` when calling `create_recipient_view`") 2774 2775 2776 collection_formats = {} 2777 2778 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/recipient'.replace('{format}', 'json') 2779 path_params = {} 2780 if 'account_id' in params: 2781 path_params['accountId'] = params['account_id'] 2782 if 'envelope_id' in params: 2783 path_params['envelopeId'] = params['envelope_id'] 2784 2785 query_params = {} 2786 2787 header_params = {} 2788 2789 form_params = [] 2790 local_var_files = {} 2791 2792 body_params = None 2793 if 'recipient_view_request' in params: 2794 body_params = params['recipient_view_request'] 2795 # HTTP header `Accept` 2796 header_params['Accept'] = self.api_client.\ 2797 select_header_accept(['application/json']) 2798 2799 # Authentication setting 2800 auth_settings = [] 2801 2802 return self.api_client.call_api(resource_path, 'POST', 2803 path_params, 2804 query_params, 2805 header_params, 2806 body=body_params, 2807 post_params=form_params, 2808 files=local_var_files, 2809 response_type='ViewUrl', 2810 auth_settings=auth_settings, 2811 callback=params.get('callback'), 2812 _return_http_data_only=params.get('_return_http_data_only'), 2813 _preload_content=params.get('_preload_content', True), 2814 _request_timeout=params.get('_request_timeout'), 2815 collection_formats=collection_formats) 2816 2817 def create_responsive_html_preview(self, account_id, envelope_id, **kwargs): 2818 """ 2819 Get Responsive HTML Preview for all documents in an envelope. 2820 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. 2821 This method makes a synchronous HTTP request by default. To make an 2822 asynchronous HTTP request, please define a `callback` function 2823 to be invoked when receiving the response. 2824 >>> def callback_function(response): 2825 >>> pprint(response) 2826 >>> 2827 >>> thread = api.create_responsive_html_preview(account_id, envelope_id, callback=callback_function) 2828 2829 :param callback function: The callback function 2830 for asynchronous request. (optional) 2831 :param str account_id: The external account number (int) or account ID Guid. (required) 2832 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2833 :param DocumentHtmlDefinition document_html_definition: 2834 :return: DocumentHtmlDefinitions 2835 If the method is called asynchronously, 2836 returns the request thread. 2837 """ 2838 kwargs['_return_http_data_only'] = True 2839 if kwargs.get('callback'): 2840 return self.create_responsive_html_preview_with_http_info(account_id, envelope_id, **kwargs) 2841 else: 2842 (data) = self.create_responsive_html_preview_with_http_info(account_id, envelope_id, **kwargs) 2843 return data 2844 2845 def create_responsive_html_preview_with_http_info(self, account_id, envelope_id, **kwargs): 2846 """ 2847 Get Responsive HTML Preview for all documents in an envelope. 2848 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. 2849 This method makes a synchronous HTTP request by default. To make an 2850 asynchronous HTTP request, please define a `callback` function 2851 to be invoked when receiving the response. 2852 >>> def callback_function(response): 2853 >>> pprint(response) 2854 >>> 2855 >>> thread = api.create_responsive_html_preview_with_http_info(account_id, envelope_id, callback=callback_function) 2856 2857 :param callback function: The callback function 2858 for asynchronous request. (optional) 2859 :param str account_id: The external account number (int) or account ID Guid. (required) 2860 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2861 :param DocumentHtmlDefinition document_html_definition: 2862 :return: DocumentHtmlDefinitions 2863 If the method is called asynchronously, 2864 returns the request thread. 2865 """ 2866 2867 all_params = ['account_id', 'envelope_id', 'document_html_definition'] 2868 all_params.append('callback') 2869 all_params.append('_return_http_data_only') 2870 all_params.append('_preload_content') 2871 all_params.append('_request_timeout') 2872 2873 params = locals() 2874 for key, val in iteritems(params['kwargs']): 2875 if key not in all_params: 2876 raise TypeError( 2877 "Got an unexpected keyword argument '%s'" 2878 " to method create_responsive_html_preview" % key 2879 ) 2880 params[key] = val 2881 del params['kwargs'] 2882 # verify the required parameter 'account_id' is set 2883 if ('account_id' not in params) or (params['account_id'] is None): 2884 raise ValueError("Missing the required parameter `account_id` when calling `create_responsive_html_preview`") 2885 # verify the required parameter 'envelope_id' is set 2886 if ('envelope_id' not in params) or (params['envelope_id'] is None): 2887 raise ValueError("Missing the required parameter `envelope_id` when calling `create_responsive_html_preview`") 2888 2889 2890 collection_formats = {} 2891 2892 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/responsive_html_preview'.replace('{format}', 'json') 2893 path_params = {} 2894 if 'account_id' in params: 2895 path_params['accountId'] = params['account_id'] 2896 if 'envelope_id' in params: 2897 path_params['envelopeId'] = params['envelope_id'] 2898 2899 query_params = {} 2900 2901 header_params = {} 2902 2903 form_params = [] 2904 local_var_files = {} 2905 2906 body_params = None 2907 if 'document_html_definition' in params: 2908 body_params = params['document_html_definition'] 2909 # HTTP header `Accept` 2910 header_params['Accept'] = self.api_client.\ 2911 select_header_accept(['application/json']) 2912 2913 # Authentication setting 2914 auth_settings = [] 2915 2916 return self.api_client.call_api(resource_path, 'POST', 2917 path_params, 2918 query_params, 2919 header_params, 2920 body=body_params, 2921 post_params=form_params, 2922 files=local_var_files, 2923 response_type='DocumentHtmlDefinitions', 2924 auth_settings=auth_settings, 2925 callback=params.get('callback'), 2926 _return_http_data_only=params.get('_return_http_data_only'), 2927 _preload_content=params.get('_preload_content', True), 2928 _request_timeout=params.get('_request_timeout'), 2929 collection_formats=collection_formats) 2930 2931 def create_sender_view(self, account_id, envelope_id, **kwargs): 2932 """ 2933 Returns a URL to the sender view UI. 2934 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. 2935 This method makes a synchronous HTTP request by default. To make an 2936 asynchronous HTTP request, please define a `callback` function 2937 to be invoked when receiving the response. 2938 >>> def callback_function(response): 2939 >>> pprint(response) 2940 >>> 2941 >>> thread = api.create_sender_view(account_id, envelope_id, callback=callback_function) 2942 2943 :param callback function: The callback function 2944 for asynchronous request. (optional) 2945 :param str account_id: The external account number (int) or account ID Guid. (required) 2946 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2947 :param ReturnUrlRequest return_url_request: 2948 :return: ViewUrl 2949 If the method is called asynchronously, 2950 returns the request thread. 2951 """ 2952 kwargs['_return_http_data_only'] = True 2953 if kwargs.get('callback'): 2954 return self.create_sender_view_with_http_info(account_id, envelope_id, **kwargs) 2955 else: 2956 (data) = self.create_sender_view_with_http_info(account_id, envelope_id, **kwargs) 2957 return data 2958 2959 def create_sender_view_with_http_info(self, account_id, envelope_id, **kwargs): 2960 """ 2961 Returns a URL to the sender view UI. 2962 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. 2963 This method makes a synchronous HTTP request by default. To make an 2964 asynchronous HTTP request, please define a `callback` function 2965 to be invoked when receiving the response. 2966 >>> def callback_function(response): 2967 >>> pprint(response) 2968 >>> 2969 >>> thread = api.create_sender_view_with_http_info(account_id, envelope_id, callback=callback_function) 2970 2971 :param callback function: The callback function 2972 for asynchronous request. (optional) 2973 :param str account_id: The external account number (int) or account ID Guid. (required) 2974 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2975 :param ReturnUrlRequest return_url_request: 2976 :return: ViewUrl 2977 If the method is called asynchronously, 2978 returns the request thread. 2979 """ 2980 2981 all_params = ['account_id', 'envelope_id', 'return_url_request'] 2982 all_params.append('callback') 2983 all_params.append('_return_http_data_only') 2984 all_params.append('_preload_content') 2985 all_params.append('_request_timeout') 2986 2987 params = locals() 2988 for key, val in iteritems(params['kwargs']): 2989 if key not in all_params: 2990 raise TypeError( 2991 "Got an unexpected keyword argument '%s'" 2992 " to method create_sender_view" % key 2993 ) 2994 params[key] = val 2995 del params['kwargs'] 2996 # verify the required parameter 'account_id' is set 2997 if ('account_id' not in params) or (params['account_id'] is None): 2998 raise ValueError("Missing the required parameter `account_id` when calling `create_sender_view`") 2999 # verify the required parameter 'envelope_id' is set 3000 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3001 raise ValueError("Missing the required parameter `envelope_id` when calling `create_sender_view`") 3002 3003 3004 collection_formats = {} 3005 3006 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/sender'.replace('{format}', 'json') 3007 path_params = {} 3008 if 'account_id' in params: 3009 path_params['accountId'] = params['account_id'] 3010 if 'envelope_id' in params: 3011 path_params['envelopeId'] = params['envelope_id'] 3012 3013 query_params = {} 3014 3015 header_params = {} 3016 3017 form_params = [] 3018 local_var_files = {} 3019 3020 body_params = None 3021 if 'return_url_request' in params: 3022 body_params = params['return_url_request'] 3023 # HTTP header `Accept` 3024 header_params['Accept'] = self.api_client.\ 3025 select_header_accept(['application/json']) 3026 3027 # Authentication setting 3028 auth_settings = [] 3029 3030 return self.api_client.call_api(resource_path, 'POST', 3031 path_params, 3032 query_params, 3033 header_params, 3034 body=body_params, 3035 post_params=form_params, 3036 files=local_var_files, 3037 response_type='ViewUrl', 3038 auth_settings=auth_settings, 3039 callback=params.get('callback'), 3040 _return_http_data_only=params.get('_return_http_data_only'), 3041 _preload_content=params.get('_preload_content', True), 3042 _request_timeout=params.get('_request_timeout'), 3043 collection_formats=collection_formats) 3044 3045 def create_tabs(self, account_id, envelope_id, recipient_id, **kwargs): 3046 """ 3047 Adds tabs for a recipient. 3048 Adds one or more tabs for a recipient. 3049 This method makes a synchronous HTTP request by default. To make an 3050 asynchronous HTTP request, please define a `callback` function 3051 to be invoked when receiving the response. 3052 >>> def callback_function(response): 3053 >>> pprint(response) 3054 >>> 3055 >>> thread = api.create_tabs(account_id, envelope_id, recipient_id, callback=callback_function) 3056 3057 :param callback function: The callback function 3058 for asynchronous request. (optional) 3059 :param str account_id: The external account number (int) or account ID Guid. (required) 3060 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3061 :param str recipient_id: The ID of the recipient being accessed. (required) 3062 :param Tabs tabs: 3063 :return: Tabs 3064 If the method is called asynchronously, 3065 returns the request thread. 3066 """ 3067 kwargs['_return_http_data_only'] = True 3068 if kwargs.get('callback'): 3069 return self.create_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 3070 else: 3071 (data) = self.create_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 3072 return data 3073 3074 def create_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 3075 """ 3076 Adds tabs for a recipient. 3077 Adds one or more tabs for a recipient. 3078 This method makes a synchronous HTTP request by default. To make an 3079 asynchronous HTTP request, please define a `callback` function 3080 to be invoked when receiving the response. 3081 >>> def callback_function(response): 3082 >>> pprint(response) 3083 >>> 3084 >>> thread = api.create_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 3085 3086 :param callback function: The callback function 3087 for asynchronous request. (optional) 3088 :param str account_id: The external account number (int) or account ID Guid. (required) 3089 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3090 :param str recipient_id: The ID of the recipient being accessed. (required) 3091 :param Tabs tabs: 3092 :return: Tabs 3093 If the method is called asynchronously, 3094 returns the request thread. 3095 """ 3096 3097 all_params = ['account_id', 'envelope_id', 'recipient_id', 'tabs'] 3098 all_params.append('callback') 3099 all_params.append('_return_http_data_only') 3100 all_params.append('_preload_content') 3101 all_params.append('_request_timeout') 3102 3103 params = locals() 3104 for key, val in iteritems(params['kwargs']): 3105 if key not in all_params: 3106 raise TypeError( 3107 "Got an unexpected keyword argument '%s'" 3108 " to method create_tabs" % key 3109 ) 3110 params[key] = val 3111 del params['kwargs'] 3112 # verify the required parameter 'account_id' is set 3113 if ('account_id' not in params) or (params['account_id'] is None): 3114 raise ValueError("Missing the required parameter `account_id` when calling `create_tabs`") 3115 # verify the required parameter 'envelope_id' is set 3116 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3117 raise ValueError("Missing the required parameter `envelope_id` when calling `create_tabs`") 3118 # verify the required parameter 'recipient_id' is set 3119 if ('recipient_id' not in params) or (params['recipient_id'] is None): 3120 raise ValueError("Missing the required parameter `recipient_id` when calling `create_tabs`") 3121 3122 3123 collection_formats = {} 3124 3125 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/tabs'.replace('{format}', 'json') 3126 path_params = {} 3127 if 'account_id' in params: 3128 path_params['accountId'] = params['account_id'] 3129 if 'envelope_id' in params: 3130 path_params['envelopeId'] = params['envelope_id'] 3131 if 'recipient_id' in params: 3132 path_params['recipientId'] = params['recipient_id'] 3133 3134 query_params = {} 3135 3136 header_params = {} 3137 3138 form_params = [] 3139 local_var_files = {} 3140 3141 body_params = None 3142 if 'tabs' in params: 3143 body_params = params['tabs'] 3144 # HTTP header `Accept` 3145 header_params['Accept'] = self.api_client.\ 3146 select_header_accept(['application/json']) 3147 3148 # Authentication setting 3149 auth_settings = [] 3150 3151 return self.api_client.call_api(resource_path, 'POST', 3152 path_params, 3153 query_params, 3154 header_params, 3155 body=body_params, 3156 post_params=form_params, 3157 files=local_var_files, 3158 response_type='Tabs', 3159 auth_settings=auth_settings, 3160 callback=params.get('callback'), 3161 _return_http_data_only=params.get('_return_http_data_only'), 3162 _preload_content=params.get('_preload_content', True), 3163 _request_timeout=params.get('_request_timeout'), 3164 collection_formats=collection_formats) 3165 3166 def create_template_workflow_step_definition(self, account_id, template_id, **kwargs): 3167 """ 3168 Creates and adds a new workflow step definition for a template's workflow 3169 This method makes a synchronous HTTP request by default. To make an 3170 asynchronous HTTP request, please define a `callback` function 3171 to be invoked when receiving the response. 3172 >>> def callback_function(response): 3173 >>> pprint(response) 3174 >>> 3175 >>> thread = api.create_template_workflow_step_definition(account_id, template_id, callback=callback_function) 3176 3177 :param callback function: The callback function 3178 for asynchronous request. (optional) 3179 :param str account_id: The external account number (int) or account ID Guid. (required) 3180 :param str template_id: The ID of the template being accessed. (required) 3181 :param WorkflowStep workflow_step: 3182 :return: WorkflowStep 3183 If the method is called asynchronously, 3184 returns the request thread. 3185 """ 3186 kwargs['_return_http_data_only'] = True 3187 if kwargs.get('callback'): 3188 return self.create_template_workflow_step_definition_with_http_info(account_id, template_id, **kwargs) 3189 else: 3190 (data) = self.create_template_workflow_step_definition_with_http_info(account_id, template_id, **kwargs) 3191 return data 3192 3193 def create_template_workflow_step_definition_with_http_info(self, account_id, template_id, **kwargs): 3194 """ 3195 Creates and adds a new workflow step definition for a template's workflow 3196 This method makes a synchronous HTTP request by default. To make an 3197 asynchronous HTTP request, please define a `callback` function 3198 to be invoked when receiving the response. 3199 >>> def callback_function(response): 3200 >>> pprint(response) 3201 >>> 3202 >>> thread = api.create_template_workflow_step_definition_with_http_info(account_id, template_id, callback=callback_function) 3203 3204 :param callback function: The callback function 3205 for asynchronous request. (optional) 3206 :param str account_id: The external account number (int) or account ID Guid. (required) 3207 :param str template_id: The ID of the template being accessed. (required) 3208 :param WorkflowStep workflow_step: 3209 :return: WorkflowStep 3210 If the method is called asynchronously, 3211 returns the request thread. 3212 """ 3213 3214 all_params = ['account_id', 'template_id', 'workflow_step'] 3215 all_params.append('callback') 3216 all_params.append('_return_http_data_only') 3217 all_params.append('_preload_content') 3218 all_params.append('_request_timeout') 3219 3220 params = locals() 3221 for key, val in iteritems(params['kwargs']): 3222 if key not in all_params: 3223 raise TypeError( 3224 "Got an unexpected keyword argument '%s'" 3225 " to method create_template_workflow_step_definition" % key 3226 ) 3227 params[key] = val 3228 del params['kwargs'] 3229 # verify the required parameter 'account_id' is set 3230 if ('account_id' not in params) or (params['account_id'] is None): 3231 raise ValueError("Missing the required parameter `account_id` when calling `create_template_workflow_step_definition`") 3232 # verify the required parameter 'template_id' is set 3233 if ('template_id' not in params) or (params['template_id'] is None): 3234 raise ValueError("Missing the required parameter `template_id` when calling `create_template_workflow_step_definition`") 3235 3236 3237 collection_formats = {} 3238 3239 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps'.replace('{format}', 'json') 3240 path_params = {} 3241 if 'account_id' in params: 3242 path_params['accountId'] = params['account_id'] 3243 if 'template_id' in params: 3244 path_params['templateId'] = params['template_id'] 3245 3246 query_params = {} 3247 3248 header_params = {} 3249 3250 form_params = [] 3251 local_var_files = {} 3252 3253 body_params = None 3254 if 'workflow_step' in params: 3255 body_params = params['workflow_step'] 3256 # HTTP header `Accept` 3257 header_params['Accept'] = self.api_client.\ 3258 select_header_accept(['application/json']) 3259 3260 # Authentication setting 3261 auth_settings = [] 3262 3263 return self.api_client.call_api(resource_path, 'POST', 3264 path_params, 3265 query_params, 3266 header_params, 3267 body=body_params, 3268 post_params=form_params, 3269 files=local_var_files, 3270 response_type='WorkflowStep', 3271 auth_settings=auth_settings, 3272 callback=params.get('callback'), 3273 _return_http_data_only=params.get('_return_http_data_only'), 3274 _preload_content=params.get('_preload_content', True), 3275 _request_timeout=params.get('_request_timeout'), 3276 collection_formats=collection_formats) 3277 3278 def delete_attachments(self, account_id, envelope_id, **kwargs): 3279 """ 3280 Delete one or more attachments from a DRAFT envelope. 3281 Deletes one or more attachments from a draft envelope. 3282 This method makes a synchronous HTTP request by default. To make an 3283 asynchronous HTTP request, please define a `callback` function 3284 to be invoked when receiving the response. 3285 >>> def callback_function(response): 3286 >>> pprint(response) 3287 >>> 3288 >>> thread = api.delete_attachments(account_id, envelope_id, callback=callback_function) 3289 3290 :param callback function: The callback function 3291 for asynchronous request. (optional) 3292 :param str account_id: The external account number (int) or account ID Guid. (required) 3293 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3294 :param EnvelopeAttachmentsRequest envelope_attachments_request: 3295 :return: EnvelopeAttachmentsResult 3296 If the method is called asynchronously, 3297 returns the request thread. 3298 """ 3299 kwargs['_return_http_data_only'] = True 3300 if kwargs.get('callback'): 3301 return self.delete_attachments_with_http_info(account_id, envelope_id, **kwargs) 3302 else: 3303 (data) = self.delete_attachments_with_http_info(account_id, envelope_id, **kwargs) 3304 return data 3305 3306 def delete_attachments_with_http_info(self, account_id, envelope_id, **kwargs): 3307 """ 3308 Delete one or more attachments from a DRAFT envelope. 3309 Deletes one or more attachments from a draft envelope. 3310 This method makes a synchronous HTTP request by default. To make an 3311 asynchronous HTTP request, please define a `callback` function 3312 to be invoked when receiving the response. 3313 >>> def callback_function(response): 3314 >>> pprint(response) 3315 >>> 3316 >>> thread = api.delete_attachments_with_http_info(account_id, envelope_id, callback=callback_function) 3317 3318 :param callback function: The callback function 3319 for asynchronous request. (optional) 3320 :param str account_id: The external account number (int) or account ID Guid. (required) 3321 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3322 :param EnvelopeAttachmentsRequest envelope_attachments_request: 3323 :return: EnvelopeAttachmentsResult 3324 If the method is called asynchronously, 3325 returns the request thread. 3326 """ 3327 3328 all_params = ['account_id', 'envelope_id', 'envelope_attachments_request'] 3329 all_params.append('callback') 3330 all_params.append('_return_http_data_only') 3331 all_params.append('_preload_content') 3332 all_params.append('_request_timeout') 3333 3334 params = locals() 3335 for key, val in iteritems(params['kwargs']): 3336 if key not in all_params: 3337 raise TypeError( 3338 "Got an unexpected keyword argument '%s'" 3339 " to method delete_attachments" % key 3340 ) 3341 params[key] = val 3342 del params['kwargs'] 3343 # verify the required parameter 'account_id' is set 3344 if ('account_id' not in params) or (params['account_id'] is None): 3345 raise ValueError("Missing the required parameter `account_id` when calling `delete_attachments`") 3346 # verify the required parameter 'envelope_id' is set 3347 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3348 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_attachments`") 3349 3350 3351 collection_formats = {} 3352 3353 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments'.replace('{format}', 'json') 3354 path_params = {} 3355 if 'account_id' in params: 3356 path_params['accountId'] = params['account_id'] 3357 if 'envelope_id' in params: 3358 path_params['envelopeId'] = params['envelope_id'] 3359 3360 query_params = {} 3361 3362 header_params = {} 3363 3364 form_params = [] 3365 local_var_files = {} 3366 3367 body_params = None 3368 if 'envelope_attachments_request' in params: 3369 body_params = params['envelope_attachments_request'] 3370 # HTTP header `Accept` 3371 header_params['Accept'] = self.api_client.\ 3372 select_header_accept(['application/json']) 3373 3374 # Authentication setting 3375 auth_settings = [] 3376 3377 return self.api_client.call_api(resource_path, 'DELETE', 3378 path_params, 3379 query_params, 3380 header_params, 3381 body=body_params, 3382 post_params=form_params, 3383 files=local_var_files, 3384 response_type='EnvelopeAttachmentsResult', 3385 auth_settings=auth_settings, 3386 callback=params.get('callback'), 3387 _return_http_data_only=params.get('_return_http_data_only'), 3388 _preload_content=params.get('_preload_content', True), 3389 _request_timeout=params.get('_request_timeout'), 3390 collection_formats=collection_formats) 3391 3392 def delete_chunked_upload(self, account_id, chunked_upload_id, **kwargs): 3393 """ 3394 Delete an existing ChunkedUpload. 3395 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. 3396 This method makes a synchronous HTTP request by default. To make an 3397 asynchronous HTTP request, please define a `callback` function 3398 to be invoked when receiving the response. 3399 >>> def callback_function(response): 3400 >>> pprint(response) 3401 >>> 3402 >>> thread = api.delete_chunked_upload(account_id, chunked_upload_id, callback=callback_function) 3403 3404 :param callback function: The callback function 3405 for asynchronous request. (optional) 3406 :param str account_id: The external account number (int) or account ID Guid. (required) 3407 :param str chunked_upload_id: (required) 3408 :return: ChunkedUploadResponse 3409 If the method is called asynchronously, 3410 returns the request thread. 3411 """ 3412 kwargs['_return_http_data_only'] = True 3413 if kwargs.get('callback'): 3414 return self.delete_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 3415 else: 3416 (data) = self.delete_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 3417 return data 3418 3419 def delete_chunked_upload_with_http_info(self, account_id, chunked_upload_id, **kwargs): 3420 """ 3421 Delete an existing ChunkedUpload. 3422 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. 3423 This method makes a synchronous HTTP request by default. To make an 3424 asynchronous HTTP request, please define a `callback` function 3425 to be invoked when receiving the response. 3426 >>> def callback_function(response): 3427 >>> pprint(response) 3428 >>> 3429 >>> thread = api.delete_chunked_upload_with_http_info(account_id, chunked_upload_id, callback=callback_function) 3430 3431 :param callback function: The callback function 3432 for asynchronous request. (optional) 3433 :param str account_id: The external account number (int) or account ID Guid. (required) 3434 :param str chunked_upload_id: (required) 3435 :return: ChunkedUploadResponse 3436 If the method is called asynchronously, 3437 returns the request thread. 3438 """ 3439 3440 all_params = ['account_id', 'chunked_upload_id'] 3441 all_params.append('callback') 3442 all_params.append('_return_http_data_only') 3443 all_params.append('_preload_content') 3444 all_params.append('_request_timeout') 3445 3446 params = locals() 3447 for key, val in iteritems(params['kwargs']): 3448 if key not in all_params: 3449 raise TypeError( 3450 "Got an unexpected keyword argument '%s'" 3451 " to method delete_chunked_upload" % key 3452 ) 3453 params[key] = val 3454 del params['kwargs'] 3455 # verify the required parameter 'account_id' is set 3456 if ('account_id' not in params) or (params['account_id'] is None): 3457 raise ValueError("Missing the required parameter `account_id` when calling `delete_chunked_upload`") 3458 # verify the required parameter 'chunked_upload_id' is set 3459 if ('chunked_upload_id' not in params) or (params['chunked_upload_id'] is None): 3460 raise ValueError("Missing the required parameter `chunked_upload_id` when calling `delete_chunked_upload`") 3461 3462 3463 collection_formats = {} 3464 3465 resource_path = '/v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}'.replace('{format}', 'json') 3466 path_params = {} 3467 if 'account_id' in params: 3468 path_params['accountId'] = params['account_id'] 3469 if 'chunked_upload_id' in params: 3470 path_params['chunkedUploadId'] = params['chunked_upload_id'] 3471 3472 query_params = {} 3473 3474 header_params = {} 3475 3476 form_params = [] 3477 local_var_files = {} 3478 3479 body_params = None 3480 # HTTP header `Accept` 3481 header_params['Accept'] = self.api_client.\ 3482 select_header_accept(['application/json']) 3483 3484 # Authentication setting 3485 auth_settings = [] 3486 3487 return self.api_client.call_api(resource_path, 'DELETE', 3488 path_params, 3489 query_params, 3490 header_params, 3491 body=body_params, 3492 post_params=form_params, 3493 files=local_var_files, 3494 response_type='ChunkedUploadResponse', 3495 auth_settings=auth_settings, 3496 callback=params.get('callback'), 3497 _return_http_data_only=params.get('_return_http_data_only'), 3498 _preload_content=params.get('_preload_content', True), 3499 _request_timeout=params.get('_request_timeout'), 3500 collection_formats=collection_formats) 3501 3502 def delete_custom_fields(self, account_id, envelope_id, **kwargs): 3503 """ 3504 Deletes envelope custom fields for draft and in-process envelopes. 3505 Deletes envelope custom fields for draft and in-process envelopes. 3506 This method makes a synchronous HTTP request by default. To make an 3507 asynchronous HTTP request, please define a `callback` function 3508 to be invoked when receiving the response. 3509 >>> def callback_function(response): 3510 >>> pprint(response) 3511 >>> 3512 >>> thread = api.delete_custom_fields(account_id, envelope_id, callback=callback_function) 3513 3514 :param callback function: The callback function 3515 for asynchronous request. (optional) 3516 :param str account_id: The external account number (int) or account ID Guid. (required) 3517 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3518 :param CustomFields custom_fields: 3519 :return: CustomFields 3520 If the method is called asynchronously, 3521 returns the request thread. 3522 """ 3523 kwargs['_return_http_data_only'] = True 3524 if kwargs.get('callback'): 3525 return self.delete_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 3526 else: 3527 (data) = self.delete_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 3528 return data 3529 3530 def delete_custom_fields_with_http_info(self, account_id, envelope_id, **kwargs): 3531 """ 3532 Deletes envelope custom fields for draft and in-process envelopes. 3533 Deletes envelope custom fields for draft and in-process envelopes. 3534 This method makes a synchronous HTTP request by default. To make an 3535 asynchronous HTTP request, please define a `callback` function 3536 to be invoked when receiving the response. 3537 >>> def callback_function(response): 3538 >>> pprint(response) 3539 >>> 3540 >>> thread = api.delete_custom_fields_with_http_info(account_id, envelope_id, callback=callback_function) 3541 3542 :param callback function: The callback function 3543 for asynchronous request. (optional) 3544 :param str account_id: The external account number (int) or account ID Guid. (required) 3545 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3546 :param CustomFields custom_fields: 3547 :return: CustomFields 3548 If the method is called asynchronously, 3549 returns the request thread. 3550 """ 3551 3552 all_params = ['account_id', 'envelope_id', 'custom_fields'] 3553 all_params.append('callback') 3554 all_params.append('_return_http_data_only') 3555 all_params.append('_preload_content') 3556 all_params.append('_request_timeout') 3557 3558 params = locals() 3559 for key, val in iteritems(params['kwargs']): 3560 if key not in all_params: 3561 raise TypeError( 3562 "Got an unexpected keyword argument '%s'" 3563 " to method delete_custom_fields" % key 3564 ) 3565 params[key] = val 3566 del params['kwargs'] 3567 # verify the required parameter 'account_id' is set 3568 if ('account_id' not in params) or (params['account_id'] is None): 3569 raise ValueError("Missing the required parameter `account_id` when calling `delete_custom_fields`") 3570 # verify the required parameter 'envelope_id' is set 3571 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3572 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_custom_fields`") 3573 3574 3575 collection_formats = {} 3576 3577 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/custom_fields'.replace('{format}', 'json') 3578 path_params = {} 3579 if 'account_id' in params: 3580 path_params['accountId'] = params['account_id'] 3581 if 'envelope_id' in params: 3582 path_params['envelopeId'] = params['envelope_id'] 3583 3584 query_params = {} 3585 3586 header_params = {} 3587 3588 form_params = [] 3589 local_var_files = {} 3590 3591 body_params = None 3592 if 'custom_fields' in params: 3593 body_params = params['custom_fields'] 3594 # HTTP header `Accept` 3595 header_params['Accept'] = self.api_client.\ 3596 select_header_accept(['application/json']) 3597 3598 # Authentication setting 3599 auth_settings = [] 3600 3601 return self.api_client.call_api(resource_path, 'DELETE', 3602 path_params, 3603 query_params, 3604 header_params, 3605 body=body_params, 3606 post_params=form_params, 3607 files=local_var_files, 3608 response_type='CustomFields', 3609 auth_settings=auth_settings, 3610 callback=params.get('callback'), 3611 _return_http_data_only=params.get('_return_http_data_only'), 3612 _preload_content=params.get('_preload_content', True), 3613 _request_timeout=params.get('_request_timeout'), 3614 collection_formats=collection_formats) 3615 3616 def delete_document_fields(self, account_id, document_id, envelope_id, **kwargs): 3617 """ 3618 Deletes custom document fields from an existing envelope document. 3619 Deletes custom document fields from an existing envelope document. 3620 This method makes a synchronous HTTP request by default. To make an 3621 asynchronous HTTP request, please define a `callback` function 3622 to be invoked when receiving the response. 3623 >>> def callback_function(response): 3624 >>> pprint(response) 3625 >>> 3626 >>> thread = api.delete_document_fields(account_id, document_id, envelope_id, callback=callback_function) 3627 3628 :param callback function: The callback function 3629 for asynchronous request. (optional) 3630 :param str account_id: The external account number (int) or account ID Guid. (required) 3631 :param str document_id: The ID of the document being accessed. (required) 3632 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3633 :param DocumentFieldsInformation document_fields_information: 3634 :return: DocumentFieldsInformation 3635 If the method is called asynchronously, 3636 returns the request thread. 3637 """ 3638 kwargs['_return_http_data_only'] = True 3639 if kwargs.get('callback'): 3640 return self.delete_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 3641 else: 3642 (data) = self.delete_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 3643 return data 3644 3645 def delete_document_fields_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 3646 """ 3647 Deletes custom document fields from an existing envelope document. 3648 Deletes custom document fields from an existing envelope document. 3649 This method makes a synchronous HTTP request by default. To make an 3650 asynchronous HTTP request, please define a `callback` function 3651 to be invoked when receiving the response. 3652 >>> def callback_function(response): 3653 >>> pprint(response) 3654 >>> 3655 >>> thread = api.delete_document_fields_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 3656 3657 :param callback function: The callback function 3658 for asynchronous request. (optional) 3659 :param str account_id: The external account number (int) or account ID Guid. (required) 3660 :param str document_id: The ID of the document being accessed. (required) 3661 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3662 :param DocumentFieldsInformation document_fields_information: 3663 :return: DocumentFieldsInformation 3664 If the method is called asynchronously, 3665 returns the request thread. 3666 """ 3667 3668 all_params = ['account_id', 'document_id', 'envelope_id', 'document_fields_information'] 3669 all_params.append('callback') 3670 all_params.append('_return_http_data_only') 3671 all_params.append('_preload_content') 3672 all_params.append('_request_timeout') 3673 3674 params = locals() 3675 for key, val in iteritems(params['kwargs']): 3676 if key not in all_params: 3677 raise TypeError( 3678 "Got an unexpected keyword argument '%s'" 3679 " to method delete_document_fields" % key 3680 ) 3681 params[key] = val 3682 del params['kwargs'] 3683 # verify the required parameter 'account_id' is set 3684 if ('account_id' not in params) or (params['account_id'] is None): 3685 raise ValueError("Missing the required parameter `account_id` when calling `delete_document_fields`") 3686 # verify the required parameter 'document_id' is set 3687 if ('document_id' not in params) or (params['document_id'] is None): 3688 raise ValueError("Missing the required parameter `document_id` when calling `delete_document_fields`") 3689 # verify the required parameter 'envelope_id' is set 3690 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3691 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_document_fields`") 3692 3693 3694 collection_formats = {} 3695 3696 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/fields'.replace('{format}', 'json') 3697 path_params = {} 3698 if 'account_id' in params: 3699 path_params['accountId'] = params['account_id'] 3700 if 'document_id' in params: 3701 path_params['documentId'] = params['document_id'] 3702 if 'envelope_id' in params: 3703 path_params['envelopeId'] = params['envelope_id'] 3704 3705 query_params = {} 3706 3707 header_params = {} 3708 3709 form_params = [] 3710 local_var_files = {} 3711 3712 body_params = None 3713 if 'document_fields_information' in params: 3714 body_params = params['document_fields_information'] 3715 # HTTP header `Accept` 3716 header_params['Accept'] = self.api_client.\ 3717 select_header_accept(['application/json']) 3718 3719 # Authentication setting 3720 auth_settings = [] 3721 3722 return self.api_client.call_api(resource_path, 'DELETE', 3723 path_params, 3724 query_params, 3725 header_params, 3726 body=body_params, 3727 post_params=form_params, 3728 files=local_var_files, 3729 response_type='DocumentFieldsInformation', 3730 auth_settings=auth_settings, 3731 callback=params.get('callback'), 3732 _return_http_data_only=params.get('_return_http_data_only'), 3733 _preload_content=params.get('_preload_content', True), 3734 _request_timeout=params.get('_request_timeout'), 3735 collection_formats=collection_formats) 3736 3737 def delete_document_page(self, account_id, document_id, envelope_id, page_number, **kwargs): 3738 """ 3739 Deletes a page from a document in an envelope. 3740 Deletes a page from a document in an envelope based on the page number. 3741 This method makes a synchronous HTTP request by default. To make an 3742 asynchronous HTTP request, please define a `callback` function 3743 to be invoked when receiving the response. 3744 >>> def callback_function(response): 3745 >>> pprint(response) 3746 >>> 3747 >>> thread = api.delete_document_page(account_id, document_id, envelope_id, page_number, callback=callback_function) 3748 3749 :param callback function: The callback function 3750 for asynchronous request. (optional) 3751 :param str account_id: The external account number (int) or account ID Guid. (required) 3752 :param str document_id: The ID of the document being accessed. (required) 3753 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3754 :param str page_number: The page number being accessed. (required) 3755 :return: None 3756 If the method is called asynchronously, 3757 returns the request thread. 3758 """ 3759 kwargs['_return_http_data_only'] = True 3760 if kwargs.get('callback'): 3761 return self.delete_document_page_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 3762 else: 3763 (data) = self.delete_document_page_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 3764 return data 3765 3766 def delete_document_page_with_http_info(self, account_id, document_id, envelope_id, page_number, **kwargs): 3767 """ 3768 Deletes a page from a document in an envelope. 3769 Deletes a page from a document in an envelope based on the page number. 3770 This method makes a synchronous HTTP request by default. To make an 3771 asynchronous HTTP request, please define a `callback` function 3772 to be invoked when receiving the response. 3773 >>> def callback_function(response): 3774 >>> pprint(response) 3775 >>> 3776 >>> thread = api.delete_document_page_with_http_info(account_id, document_id, envelope_id, page_number, callback=callback_function) 3777 3778 :param callback function: The callback function 3779 for asynchronous request. (optional) 3780 :param str account_id: The external account number (int) or account ID Guid. (required) 3781 :param str document_id: The ID of the document being accessed. (required) 3782 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3783 :param str page_number: The page number being accessed. (required) 3784 :return: None 3785 If the method is called asynchronously, 3786 returns the request thread. 3787 """ 3788 3789 all_params = ['account_id', 'document_id', 'envelope_id', 'page_number'] 3790 all_params.append('callback') 3791 all_params.append('_return_http_data_only') 3792 all_params.append('_preload_content') 3793 all_params.append('_request_timeout') 3794 3795 params = locals() 3796 for key, val in iteritems(params['kwargs']): 3797 if key not in all_params: 3798 raise TypeError( 3799 "Got an unexpected keyword argument '%s'" 3800 " to method delete_document_page" % key 3801 ) 3802 params[key] = val 3803 del params['kwargs'] 3804 # verify the required parameter 'account_id' is set 3805 if ('account_id' not in params) or (params['account_id'] is None): 3806 raise ValueError("Missing the required parameter `account_id` when calling `delete_document_page`") 3807 # verify the required parameter 'document_id' is set 3808 if ('document_id' not in params) or (params['document_id'] is None): 3809 raise ValueError("Missing the required parameter `document_id` when calling `delete_document_page`") 3810 # verify the required parameter 'envelope_id' is set 3811 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3812 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_document_page`") 3813 # verify the required parameter 'page_number' is set 3814 if ('page_number' not in params) or (params['page_number'] is None): 3815 raise ValueError("Missing the required parameter `page_number` when calling `delete_document_page`") 3816 3817 3818 collection_formats = {} 3819 3820 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/pages/{pageNumber}'.replace('{format}', 'json') 3821 path_params = {} 3822 if 'account_id' in params: 3823 path_params['accountId'] = params['account_id'] 3824 if 'document_id' in params: 3825 path_params['documentId'] = params['document_id'] 3826 if 'envelope_id' in params: 3827 path_params['envelopeId'] = params['envelope_id'] 3828 if 'page_number' in params: 3829 path_params['pageNumber'] = params['page_number'] 3830 3831 query_params = {} 3832 3833 header_params = {} 3834 3835 form_params = [] 3836 local_var_files = {} 3837 3838 body_params = None 3839 # HTTP header `Accept` 3840 header_params['Accept'] = self.api_client.\ 3841 select_header_accept(['application/json']) 3842 3843 # Authentication setting 3844 auth_settings = [] 3845 3846 return self.api_client.call_api(resource_path, 'DELETE', 3847 path_params, 3848 query_params, 3849 header_params, 3850 body=body_params, 3851 post_params=form_params, 3852 files=local_var_files, 3853 response_type=None, 3854 auth_settings=auth_settings, 3855 callback=params.get('callback'), 3856 _return_http_data_only=params.get('_return_http_data_only'), 3857 _preload_content=params.get('_preload_content', True), 3858 _request_timeout=params.get('_request_timeout'), 3859 collection_formats=collection_formats) 3860 3861 def delete_document_tabs(self, account_id, document_id, envelope_id, **kwargs): 3862 """ 3863 Deletes tabs from an envelope document 3864 Deletes tabs from the document specified by `documentId` in the envelope specified by `envelopeId`. 3865 This method makes a synchronous HTTP request by default. To make an 3866 asynchronous HTTP request, please define a `callback` function 3867 to be invoked when receiving the response. 3868 >>> def callback_function(response): 3869 >>> pprint(response) 3870 >>> 3871 >>> thread = api.delete_document_tabs(account_id, document_id, envelope_id, callback=callback_function) 3872 3873 :param callback function: The callback function 3874 for asynchronous request. (optional) 3875 :param str account_id: The external account number (int) or account ID Guid. (required) 3876 :param str document_id: The ID of the document being accessed. (required) 3877 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3878 :param Tabs tabs: 3879 :return: Tabs 3880 If the method is called asynchronously, 3881 returns the request thread. 3882 """ 3883 kwargs['_return_http_data_only'] = True 3884 if kwargs.get('callback'): 3885 return self.delete_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 3886 else: 3887 (data) = self.delete_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 3888 return data 3889 3890 def delete_document_tabs_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 3891 """ 3892 Deletes tabs from an envelope document 3893 Deletes tabs from the document specified by `documentId` in the envelope specified by `envelopeId`. 3894 This method makes a synchronous HTTP request by default. To make an 3895 asynchronous HTTP request, please define a `callback` function 3896 to be invoked when receiving the response. 3897 >>> def callback_function(response): 3898 >>> pprint(response) 3899 >>> 3900 >>> thread = api.delete_document_tabs_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 3901 3902 :param callback function: The callback function 3903 for asynchronous request. (optional) 3904 :param str account_id: The external account number (int) or account ID Guid. (required) 3905 :param str document_id: The ID of the document being accessed. (required) 3906 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3907 :param Tabs tabs: 3908 :return: Tabs 3909 If the method is called asynchronously, 3910 returns the request thread. 3911 """ 3912 3913 all_params = ['account_id', 'document_id', 'envelope_id', 'tabs'] 3914 all_params.append('callback') 3915 all_params.append('_return_http_data_only') 3916 all_params.append('_preload_content') 3917 all_params.append('_request_timeout') 3918 3919 params = locals() 3920 for key, val in iteritems(params['kwargs']): 3921 if key not in all_params: 3922 raise TypeError( 3923 "Got an unexpected keyword argument '%s'" 3924 " to method delete_document_tabs" % key 3925 ) 3926 params[key] = val 3927 del params['kwargs'] 3928 # verify the required parameter 'account_id' is set 3929 if ('account_id' not in params) or (params['account_id'] is None): 3930 raise ValueError("Missing the required parameter `account_id` when calling `delete_document_tabs`") 3931 # verify the required parameter 'document_id' is set 3932 if ('document_id' not in params) or (params['document_id'] is None): 3933 raise ValueError("Missing the required parameter `document_id` when calling `delete_document_tabs`") 3934 # verify the required parameter 'envelope_id' is set 3935 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3936 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_document_tabs`") 3937 3938 3939 collection_formats = {} 3940 3941 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/tabs'.replace('{format}', 'json') 3942 path_params = {} 3943 if 'account_id' in params: 3944 path_params['accountId'] = params['account_id'] 3945 if 'document_id' in params: 3946 path_params['documentId'] = params['document_id'] 3947 if 'envelope_id' in params: 3948 path_params['envelopeId'] = params['envelope_id'] 3949 3950 query_params = {} 3951 3952 header_params = {} 3953 3954 form_params = [] 3955 local_var_files = {} 3956 3957 body_params = None 3958 if 'tabs' in params: 3959 body_params = params['tabs'] 3960 # HTTP header `Accept` 3961 header_params['Accept'] = self.api_client.\ 3962 select_header_accept(['application/json']) 3963 3964 # Authentication setting 3965 auth_settings = [] 3966 3967 return self.api_client.call_api(resource_path, 'DELETE', 3968 path_params, 3969 query_params, 3970 header_params, 3971 body=body_params, 3972 post_params=form_params, 3973 files=local_var_files, 3974 response_type='Tabs', 3975 auth_settings=auth_settings, 3976 callback=params.get('callback'), 3977 _return_http_data_only=params.get('_return_http_data_only'), 3978 _preload_content=params.get('_preload_content', True), 3979 _request_timeout=params.get('_request_timeout'), 3980 collection_formats=collection_formats) 3981 3982 def delete_documents(self, account_id, envelope_id, **kwargs): 3983 """ 3984 Deletes documents from a draft envelope. 3985 Deletes one or more documents from an existing draft envelope. 3986 This method makes a synchronous HTTP request by default. To make an 3987 asynchronous HTTP request, please define a `callback` function 3988 to be invoked when receiving the response. 3989 >>> def callback_function(response): 3990 >>> pprint(response) 3991 >>> 3992 >>> thread = api.delete_documents(account_id, envelope_id, callback=callback_function) 3993 3994 :param callback function: The callback function 3995 for asynchronous request. (optional) 3996 :param str account_id: The external account number (int) or account ID Guid. (required) 3997 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3998 :param EnvelopeDefinition envelope_definition: 3999 :return: EnvelopeDocumentsResult 4000 If the method is called asynchronously, 4001 returns the request thread. 4002 """ 4003 kwargs['_return_http_data_only'] = True 4004 if kwargs.get('callback'): 4005 return self.delete_documents_with_http_info(account_id, envelope_id, **kwargs) 4006 else: 4007 (data) = self.delete_documents_with_http_info(account_id, envelope_id, **kwargs) 4008 return data 4009 4010 def delete_documents_with_http_info(self, account_id, envelope_id, **kwargs): 4011 """ 4012 Deletes documents from a draft envelope. 4013 Deletes one or more documents from an existing draft envelope. 4014 This method makes a synchronous HTTP request by default. To make an 4015 asynchronous HTTP request, please define a `callback` function 4016 to be invoked when receiving the response. 4017 >>> def callback_function(response): 4018 >>> pprint(response) 4019 >>> 4020 >>> thread = api.delete_documents_with_http_info(account_id, envelope_id, callback=callback_function) 4021 4022 :param callback function: The callback function 4023 for asynchronous request. (optional) 4024 :param str account_id: The external account number (int) or account ID Guid. (required) 4025 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4026 :param EnvelopeDefinition envelope_definition: 4027 :return: EnvelopeDocumentsResult 4028 If the method is called asynchronously, 4029 returns the request thread. 4030 """ 4031 4032 all_params = ['account_id', 'envelope_id', 'envelope_definition'] 4033 all_params.append('callback') 4034 all_params.append('_return_http_data_only') 4035 all_params.append('_preload_content') 4036 all_params.append('_request_timeout') 4037 4038 params = locals() 4039 for key, val in iteritems(params['kwargs']): 4040 if key not in all_params: 4041 raise TypeError( 4042 "Got an unexpected keyword argument '%s'" 4043 " to method delete_documents" % key 4044 ) 4045 params[key] = val 4046 del params['kwargs'] 4047 # verify the required parameter 'account_id' is set 4048 if ('account_id' not in params) or (params['account_id'] is None): 4049 raise ValueError("Missing the required parameter `account_id` when calling `delete_documents`") 4050 # verify the required parameter 'envelope_id' is set 4051 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4052 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_documents`") 4053 4054 4055 collection_formats = {} 4056 4057 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents'.replace('{format}', 'json') 4058 path_params = {} 4059 if 'account_id' in params: 4060 path_params['accountId'] = params['account_id'] 4061 if 'envelope_id' in params: 4062 path_params['envelopeId'] = params['envelope_id'] 4063 4064 query_params = {} 4065 4066 header_params = {} 4067 4068 form_params = [] 4069 local_var_files = {} 4070 4071 body_params = None 4072 if 'envelope_definition' in params: 4073 body_params = params['envelope_definition'] 4074 # HTTP header `Accept` 4075 header_params['Accept'] = self.api_client.\ 4076 select_header_accept(['application/json']) 4077 4078 # Authentication setting 4079 auth_settings = [] 4080 4081 return self.api_client.call_api(resource_path, 'DELETE', 4082 path_params, 4083 query_params, 4084 header_params, 4085 body=body_params, 4086 post_params=form_params, 4087 files=local_var_files, 4088 response_type='EnvelopeDocumentsResult', 4089 auth_settings=auth_settings, 4090 callback=params.get('callback'), 4091 _return_http_data_only=params.get('_return_http_data_only'), 4092 _preload_content=params.get('_preload_content', True), 4093 _request_timeout=params.get('_request_timeout'), 4094 collection_formats=collection_formats) 4095 4096 def delete_email_settings(self, account_id, envelope_id, **kwargs): 4097 """ 4098 Deletes the email setting overrides for an envelope. 4099 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. 4100 This method makes a synchronous HTTP request by default. To make an 4101 asynchronous HTTP request, please define a `callback` function 4102 to be invoked when receiving the response. 4103 >>> def callback_function(response): 4104 >>> pprint(response) 4105 >>> 4106 >>> thread = api.delete_email_settings(account_id, envelope_id, callback=callback_function) 4107 4108 :param callback function: The callback function 4109 for asynchronous request. (optional) 4110 :param str account_id: The external account number (int) or account ID Guid. (required) 4111 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4112 :return: EmailSettings 4113 If the method is called asynchronously, 4114 returns the request thread. 4115 """ 4116 kwargs['_return_http_data_only'] = True 4117 if kwargs.get('callback'): 4118 return self.delete_email_settings_with_http_info(account_id, envelope_id, **kwargs) 4119 else: 4120 (data) = self.delete_email_settings_with_http_info(account_id, envelope_id, **kwargs) 4121 return data 4122 4123 def delete_email_settings_with_http_info(self, account_id, envelope_id, **kwargs): 4124 """ 4125 Deletes the email setting overrides for an envelope. 4126 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. 4127 This method makes a synchronous HTTP request by default. To make an 4128 asynchronous HTTP request, please define a `callback` function 4129 to be invoked when receiving the response. 4130 >>> def callback_function(response): 4131 >>> pprint(response) 4132 >>> 4133 >>> thread = api.delete_email_settings_with_http_info(account_id, envelope_id, callback=callback_function) 4134 4135 :param callback function: The callback function 4136 for asynchronous request. (optional) 4137 :param str account_id: The external account number (int) or account ID Guid. (required) 4138 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4139 :return: EmailSettings 4140 If the method is called asynchronously, 4141 returns the request thread. 4142 """ 4143 4144 all_params = ['account_id', 'envelope_id'] 4145 all_params.append('callback') 4146 all_params.append('_return_http_data_only') 4147 all_params.append('_preload_content') 4148 all_params.append('_request_timeout') 4149 4150 params = locals() 4151 for key, val in iteritems(params['kwargs']): 4152 if key not in all_params: 4153 raise TypeError( 4154 "Got an unexpected keyword argument '%s'" 4155 " to method delete_email_settings" % key 4156 ) 4157 params[key] = val 4158 del params['kwargs'] 4159 # verify the required parameter 'account_id' is set 4160 if ('account_id' not in params) or (params['account_id'] is None): 4161 raise ValueError("Missing the required parameter `account_id` when calling `delete_email_settings`") 4162 # verify the required parameter 'envelope_id' is set 4163 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4164 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_email_settings`") 4165 4166 4167 collection_formats = {} 4168 4169 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/email_settings'.replace('{format}', 'json') 4170 path_params = {} 4171 if 'account_id' in params: 4172 path_params['accountId'] = params['account_id'] 4173 if 'envelope_id' in params: 4174 path_params['envelopeId'] = params['envelope_id'] 4175 4176 query_params = {} 4177 4178 header_params = {} 4179 4180 form_params = [] 4181 local_var_files = {} 4182 4183 body_params = None 4184 # HTTP header `Accept` 4185 header_params['Accept'] = self.api_client.\ 4186 select_header_accept(['application/json']) 4187 4188 # Authentication setting 4189 auth_settings = [] 4190 4191 return self.api_client.call_api(resource_path, 'DELETE', 4192 path_params, 4193 query_params, 4194 header_params, 4195 body=body_params, 4196 post_params=form_params, 4197 files=local_var_files, 4198 response_type='EmailSettings', 4199 auth_settings=auth_settings, 4200 callback=params.get('callback'), 4201 _return_http_data_only=params.get('_return_http_data_only'), 4202 _preload_content=params.get('_preload_content', True), 4203 _request_timeout=params.get('_request_timeout'), 4204 collection_formats=collection_formats) 4205 4206 def delete_envelope_correct_view(self, account_id, envelope_id, **kwargs): 4207 """ 4208 Revokes the correction view URL to the Envelope UI 4209 Revokes the correction view URL to the Envelope UI. 4210 This method makes a synchronous HTTP request by default. To make an 4211 asynchronous HTTP request, please define a `callback` function 4212 to be invoked when receiving the response. 4213 >>> def callback_function(response): 4214 >>> pprint(response) 4215 >>> 4216 >>> thread = api.delete_envelope_correct_view(account_id, envelope_id, callback=callback_function) 4217 4218 :param callback function: The callback function 4219 for asynchronous request. (optional) 4220 :param str account_id: The external account number (int) or account ID Guid. (required) 4221 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4222 :param CorrectViewRequest correct_view_request: 4223 :return: None 4224 If the method is called asynchronously, 4225 returns the request thread. 4226 """ 4227 kwargs['_return_http_data_only'] = True 4228 if kwargs.get('callback'): 4229 return self.delete_envelope_correct_view_with_http_info(account_id, envelope_id, **kwargs) 4230 else: 4231 (data) = self.delete_envelope_correct_view_with_http_info(account_id, envelope_id, **kwargs) 4232 return data 4233 4234 def delete_envelope_correct_view_with_http_info(self, account_id, envelope_id, **kwargs): 4235 """ 4236 Revokes the correction view URL to the Envelope UI 4237 Revokes the correction view URL to the Envelope UI. 4238 This method makes a synchronous HTTP request by default. To make an 4239 asynchronous HTTP request, please define a `callback` function 4240 to be invoked when receiving the response. 4241 >>> def callback_function(response): 4242 >>> pprint(response) 4243 >>> 4244 >>> thread = api.delete_envelope_correct_view_with_http_info(account_id, envelope_id, callback=callback_function) 4245 4246 :param callback function: The callback function 4247 for asynchronous request. (optional) 4248 :param str account_id: The external account number (int) or account ID Guid. (required) 4249 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4250 :param CorrectViewRequest correct_view_request: 4251 :return: None 4252 If the method is called asynchronously, 4253 returns the request thread. 4254 """ 4255 4256 all_params = ['account_id', 'envelope_id', 'correct_view_request'] 4257 all_params.append('callback') 4258 all_params.append('_return_http_data_only') 4259 all_params.append('_preload_content') 4260 all_params.append('_request_timeout') 4261 4262 params = locals() 4263 for key, val in iteritems(params['kwargs']): 4264 if key not in all_params: 4265 raise TypeError( 4266 "Got an unexpected keyword argument '%s'" 4267 " to method delete_envelope_correct_view" % key 4268 ) 4269 params[key] = val 4270 del params['kwargs'] 4271 # verify the required parameter 'account_id' is set 4272 if ('account_id' not in params) or (params['account_id'] is None): 4273 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_correct_view`") 4274 # verify the required parameter 'envelope_id' is set 4275 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4276 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_envelope_correct_view`") 4277 4278 4279 collection_formats = {} 4280 4281 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/correct'.replace('{format}', 'json') 4282 path_params = {} 4283 if 'account_id' in params: 4284 path_params['accountId'] = params['account_id'] 4285 if 'envelope_id' in params: 4286 path_params['envelopeId'] = params['envelope_id'] 4287 4288 query_params = {} 4289 4290 header_params = {} 4291 4292 form_params = [] 4293 local_var_files = {} 4294 4295 body_params = None 4296 if 'correct_view_request' in params: 4297 body_params = params['correct_view_request'] 4298 # HTTP header `Accept` 4299 header_params['Accept'] = self.api_client.\ 4300 select_header_accept(['application/json']) 4301 4302 # Authentication setting 4303 auth_settings = [] 4304 4305 return self.api_client.call_api(resource_path, 'DELETE', 4306 path_params, 4307 query_params, 4308 header_params, 4309 body=body_params, 4310 post_params=form_params, 4311 files=local_var_files, 4312 response_type=None, 4313 auth_settings=auth_settings, 4314 callback=params.get('callback'), 4315 _return_http_data_only=params.get('_return_http_data_only'), 4316 _preload_content=params.get('_preload_content', True), 4317 _request_timeout=params.get('_request_timeout'), 4318 collection_formats=collection_formats) 4319 4320 def delete_envelope_delayed_routing_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 4321 """ 4322 Deletes the delayed routing rules for the specified envelope workflow step. 4323 This method makes a synchronous HTTP request by default. To make an 4324 asynchronous HTTP request, please define a `callback` function 4325 to be invoked when receiving the response. 4326 >>> def callback_function(response): 4327 >>> pprint(response) 4328 >>> 4329 >>> thread = api.delete_envelope_delayed_routing_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 4330 4331 :param callback function: The callback function 4332 for asynchronous request. (optional) 4333 :param str account_id: The external account number (int) or account ID Guid. (required) 4334 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4335 :param str workflow_step_id: (required) 4336 :return: None 4337 If the method is called asynchronously, 4338 returns the request thread. 4339 """ 4340 kwargs['_return_http_data_only'] = True 4341 if kwargs.get('callback'): 4342 return self.delete_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 4343 else: 4344 (data) = self.delete_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 4345 return data 4346 4347 def delete_envelope_delayed_routing_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 4348 """ 4349 Deletes the delayed routing rules for the specified envelope workflow step. 4350 This method makes a synchronous HTTP request by default. To make an 4351 asynchronous HTTP request, please define a `callback` function 4352 to be invoked when receiving the response. 4353 >>> def callback_function(response): 4354 >>> pprint(response) 4355 >>> 4356 >>> thread = api.delete_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 4357 4358 :param callback function: The callback function 4359 for asynchronous request. (optional) 4360 :param str account_id: The external account number (int) or account ID Guid. (required) 4361 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4362 :param str workflow_step_id: (required) 4363 :return: None 4364 If the method is called asynchronously, 4365 returns the request thread. 4366 """ 4367 4368 all_params = ['account_id', 'envelope_id', 'workflow_step_id'] 4369 all_params.append('callback') 4370 all_params.append('_return_http_data_only') 4371 all_params.append('_preload_content') 4372 all_params.append('_request_timeout') 4373 4374 params = locals() 4375 for key, val in iteritems(params['kwargs']): 4376 if key not in all_params: 4377 raise TypeError( 4378 "Got an unexpected keyword argument '%s'" 4379 " to method delete_envelope_delayed_routing_definition" % key 4380 ) 4381 params[key] = val 4382 del params['kwargs'] 4383 # verify the required parameter 'account_id' is set 4384 if ('account_id' not in params) or (params['account_id'] is None): 4385 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_delayed_routing_definition`") 4386 # verify the required parameter 'envelope_id' is set 4387 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4388 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_envelope_delayed_routing_definition`") 4389 # verify the required parameter 'workflow_step_id' is set 4390 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 4391 raise ValueError("Missing the required parameter `workflow_step_id` when calling `delete_envelope_delayed_routing_definition`") 4392 4393 4394 collection_formats = {} 4395 4396 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 4397 path_params = {} 4398 if 'account_id' in params: 4399 path_params['accountId'] = params['account_id'] 4400 if 'envelope_id' in params: 4401 path_params['envelopeId'] = params['envelope_id'] 4402 if 'workflow_step_id' in params: 4403 path_params['workflowStepId'] = params['workflow_step_id'] 4404 4405 query_params = {} 4406 4407 header_params = {} 4408 4409 form_params = [] 4410 local_var_files = {} 4411 4412 body_params = None 4413 # HTTP header `Accept` 4414 header_params['Accept'] = self.api_client.\ 4415 select_header_accept(['application/json']) 4416 4417 # Authentication setting 4418 auth_settings = [] 4419 4420 return self.api_client.call_api(resource_path, 'DELETE', 4421 path_params, 4422 query_params, 4423 header_params, 4424 body=body_params, 4425 post_params=form_params, 4426 files=local_var_files, 4427 response_type=None, 4428 auth_settings=auth_settings, 4429 callback=params.get('callback'), 4430 _return_http_data_only=params.get('_return_http_data_only'), 4431 _preload_content=params.get('_preload_content', True), 4432 _request_timeout=params.get('_request_timeout'), 4433 collection_formats=collection_formats) 4434 4435 def delete_envelope_scheduled_sending_definition(self, account_id, envelope_id, **kwargs): 4436 """ 4437 Deletes the scheduled sending rules for the envelope's workflow. 4438 This method makes a synchronous HTTP request by default. To make an 4439 asynchronous HTTP request, please define a `callback` function 4440 to be invoked when receiving the response. 4441 >>> def callback_function(response): 4442 >>> pprint(response) 4443 >>> 4444 >>> thread = api.delete_envelope_scheduled_sending_definition(account_id, envelope_id, callback=callback_function) 4445 4446 :param callback function: The callback function 4447 for asynchronous request. (optional) 4448 :param str account_id: The external account number (int) or account ID Guid. (required) 4449 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4450 :return: None 4451 If the method is called asynchronously, 4452 returns the request thread. 4453 """ 4454 kwargs['_return_http_data_only'] = True 4455 if kwargs.get('callback'): 4456 return self.delete_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 4457 else: 4458 (data) = self.delete_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 4459 return data 4460 4461 def delete_envelope_scheduled_sending_definition_with_http_info(self, account_id, envelope_id, **kwargs): 4462 """ 4463 Deletes the scheduled sending rules for the envelope's workflow. 4464 This method makes a synchronous HTTP request by default. To make an 4465 asynchronous HTTP request, please define a `callback` function 4466 to be invoked when receiving the response. 4467 >>> def callback_function(response): 4468 >>> pprint(response) 4469 >>> 4470 >>> thread = api.delete_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, callback=callback_function) 4471 4472 :param callback function: The callback function 4473 for asynchronous request. (optional) 4474 :param str account_id: The external account number (int) or account ID Guid. (required) 4475 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4476 :return: None 4477 If the method is called asynchronously, 4478 returns the request thread. 4479 """ 4480 4481 all_params = ['account_id', 'envelope_id'] 4482 all_params.append('callback') 4483 all_params.append('_return_http_data_only') 4484 all_params.append('_preload_content') 4485 all_params.append('_request_timeout') 4486 4487 params = locals() 4488 for key, val in iteritems(params['kwargs']): 4489 if key not in all_params: 4490 raise TypeError( 4491 "Got an unexpected keyword argument '%s'" 4492 " to method delete_envelope_scheduled_sending_definition" % key 4493 ) 4494 params[key] = val 4495 del params['kwargs'] 4496 # verify the required parameter 'account_id' is set 4497 if ('account_id' not in params) or (params['account_id'] is None): 4498 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_scheduled_sending_definition`") 4499 # verify the required parameter 'envelope_id' is set 4500 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4501 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_envelope_scheduled_sending_definition`") 4502 4503 4504 collection_formats = {} 4505 4506 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/scheduledSending'.replace('{format}', 'json') 4507 path_params = {} 4508 if 'account_id' in params: 4509 path_params['accountId'] = params['account_id'] 4510 if 'envelope_id' in params: 4511 path_params['envelopeId'] = params['envelope_id'] 4512 4513 query_params = {} 4514 4515 header_params = {} 4516 4517 form_params = [] 4518 local_var_files = {} 4519 4520 body_params = None 4521 # HTTP header `Accept` 4522 header_params['Accept'] = self.api_client.\ 4523 select_header_accept(['application/json']) 4524 4525 # Authentication setting 4526 auth_settings = [] 4527 4528 return self.api_client.call_api(resource_path, 'DELETE', 4529 path_params, 4530 query_params, 4531 header_params, 4532 body=body_params, 4533 post_params=form_params, 4534 files=local_var_files, 4535 response_type=None, 4536 auth_settings=auth_settings, 4537 callback=params.get('callback'), 4538 _return_http_data_only=params.get('_return_http_data_only'), 4539 _preload_content=params.get('_preload_content', True), 4540 _request_timeout=params.get('_request_timeout'), 4541 collection_formats=collection_formats) 4542 4543 def delete_envelope_transfer_rules(self, account_id, envelope_transfer_rule_id, **kwargs): 4544 """ 4545 Delete envelope transfer rules for an account. 4546 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. 4547 This method makes a synchronous HTTP request by default. To make an 4548 asynchronous HTTP request, please define a `callback` function 4549 to be invoked when receiving the response. 4550 >>> def callback_function(response): 4551 >>> pprint(response) 4552 >>> 4553 >>> thread = api.delete_envelope_transfer_rules(account_id, envelope_transfer_rule_id, callback=callback_function) 4554 4555 :param callback function: The callback function 4556 for asynchronous request. (optional) 4557 :param str account_id: The external account number (int) or account ID Guid. (required) 4558 :param str envelope_transfer_rule_id: (required) 4559 :return: None 4560 If the method is called asynchronously, 4561 returns the request thread. 4562 """ 4563 kwargs['_return_http_data_only'] = True 4564 if kwargs.get('callback'): 4565 return self.delete_envelope_transfer_rules_with_http_info(account_id, envelope_transfer_rule_id, **kwargs) 4566 else: 4567 (data) = self.delete_envelope_transfer_rules_with_http_info(account_id, envelope_transfer_rule_id, **kwargs) 4568 return data 4569 4570 def delete_envelope_transfer_rules_with_http_info(self, account_id, envelope_transfer_rule_id, **kwargs): 4571 """ 4572 Delete envelope transfer rules for an account. 4573 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. 4574 This method makes a synchronous HTTP request by default. To make an 4575 asynchronous HTTP request, please define a `callback` function 4576 to be invoked when receiving the response. 4577 >>> def callback_function(response): 4578 >>> pprint(response) 4579 >>> 4580 >>> thread = api.delete_envelope_transfer_rules_with_http_info(account_id, envelope_transfer_rule_id, callback=callback_function) 4581 4582 :param callback function: The callback function 4583 for asynchronous request. (optional) 4584 :param str account_id: The external account number (int) or account ID Guid. (required) 4585 :param str envelope_transfer_rule_id: (required) 4586 :return: None 4587 If the method is called asynchronously, 4588 returns the request thread. 4589 """ 4590 4591 all_params = ['account_id', 'envelope_transfer_rule_id'] 4592 all_params.append('callback') 4593 all_params.append('_return_http_data_only') 4594 all_params.append('_preload_content') 4595 all_params.append('_request_timeout') 4596 4597 params = locals() 4598 for key, val in iteritems(params['kwargs']): 4599 if key not in all_params: 4600 raise TypeError( 4601 "Got an unexpected keyword argument '%s'" 4602 " to method delete_envelope_transfer_rules" % key 4603 ) 4604 params[key] = val 4605 del params['kwargs'] 4606 # verify the required parameter 'account_id' is set 4607 if ('account_id' not in params) or (params['account_id'] is None): 4608 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_transfer_rules`") 4609 # verify the required parameter 'envelope_transfer_rule_id' is set 4610 if ('envelope_transfer_rule_id' not in params) or (params['envelope_transfer_rule_id'] is None): 4611 raise ValueError("Missing the required parameter `envelope_transfer_rule_id` when calling `delete_envelope_transfer_rules`") 4612 4613 4614 collection_formats = {} 4615 4616 resource_path = '/v2.1/accounts/{accountId}/envelopes/transfer_rules/{envelopeTransferRuleId}'.replace('{format}', 'json') 4617 path_params = {} 4618 if 'account_id' in params: 4619 path_params['accountId'] = params['account_id'] 4620 if 'envelope_transfer_rule_id' in params: 4621 path_params['envelopeTransferRuleId'] = params['envelope_transfer_rule_id'] 4622 4623 query_params = {} 4624 4625 header_params = {} 4626 4627 form_params = [] 4628 local_var_files = {} 4629 4630 body_params = None 4631 # HTTP header `Accept` 4632 header_params['Accept'] = self.api_client.\ 4633 select_header_accept(['application/json']) 4634 4635 # Authentication setting 4636 auth_settings = [] 4637 4638 return self.api_client.call_api(resource_path, 'DELETE', 4639 path_params, 4640 query_params, 4641 header_params, 4642 body=body_params, 4643 post_params=form_params, 4644 files=local_var_files, 4645 response_type=None, 4646 auth_settings=auth_settings, 4647 callback=params.get('callback'), 4648 _return_http_data_only=params.get('_return_http_data_only'), 4649 _preload_content=params.get('_preload_content', True), 4650 _request_timeout=params.get('_request_timeout'), 4651 collection_formats=collection_formats) 4652 4653 def delete_envelope_workflow_definition(self, account_id, envelope_id, **kwargs): 4654 """ 4655 Delete the workflow definition for an envelope. 4656 Deletes the specified envelope's workflow definition if it has one. 4657 This method makes a synchronous HTTP request by default. To make an 4658 asynchronous HTTP request, please define a `callback` function 4659 to be invoked when receiving the response. 4660 >>> def callback_function(response): 4661 >>> pprint(response) 4662 >>> 4663 >>> thread = api.delete_envelope_workflow_definition(account_id, envelope_id, callback=callback_function) 4664 4665 :param callback function: The callback function 4666 for asynchronous request. (optional) 4667 :param str account_id: The external account number (int) or account ID Guid. (required) 4668 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4669 :return: None 4670 If the method is called asynchronously, 4671 returns the request thread. 4672 """ 4673 kwargs['_return_http_data_only'] = True 4674 if kwargs.get('callback'): 4675 return self.delete_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 4676 else: 4677 (data) = self.delete_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 4678 return data 4679 4680 def delete_envelope_workflow_definition_with_http_info(self, account_id, envelope_id, **kwargs): 4681 """ 4682 Delete the workflow definition for an envelope. 4683 Deletes the specified envelope's workflow definition if it has one. 4684 This method makes a synchronous HTTP request by default. To make an 4685 asynchronous HTTP request, please define a `callback` function 4686 to be invoked when receiving the response. 4687 >>> def callback_function(response): 4688 >>> pprint(response) 4689 >>> 4690 >>> thread = api.delete_envelope_workflow_definition_with_http_info(account_id, envelope_id, callback=callback_function) 4691 4692 :param callback function: The callback function 4693 for asynchronous request. (optional) 4694 :param str account_id: The external account number (int) or account ID Guid. (required) 4695 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4696 :return: None 4697 If the method is called asynchronously, 4698 returns the request thread. 4699 """ 4700 4701 all_params = ['account_id', 'envelope_id'] 4702 all_params.append('callback') 4703 all_params.append('_return_http_data_only') 4704 all_params.append('_preload_content') 4705 all_params.append('_request_timeout') 4706 4707 params = locals() 4708 for key, val in iteritems(params['kwargs']): 4709 if key not in all_params: 4710 raise TypeError( 4711 "Got an unexpected keyword argument '%s'" 4712 " to method delete_envelope_workflow_definition" % key 4713 ) 4714 params[key] = val 4715 del params['kwargs'] 4716 # verify the required parameter 'account_id' is set 4717 if ('account_id' not in params) or (params['account_id'] is None): 4718 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_workflow_definition`") 4719 # verify the required parameter 'envelope_id' is set 4720 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4721 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_envelope_workflow_definition`") 4722 4723 4724 collection_formats = {} 4725 4726 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow'.replace('{format}', 'json') 4727 path_params = {} 4728 if 'account_id' in params: 4729 path_params['accountId'] = params['account_id'] 4730 if 'envelope_id' in params: 4731 path_params['envelopeId'] = params['envelope_id'] 4732 4733 query_params = {} 4734 4735 header_params = {} 4736 4737 form_params = [] 4738 local_var_files = {} 4739 4740 body_params = None 4741 # HTTP header `Accept` 4742 header_params['Accept'] = self.api_client.\ 4743 select_header_accept(['application/json']) 4744 4745 # Authentication setting 4746 auth_settings = [] 4747 4748 return self.api_client.call_api(resource_path, 'DELETE', 4749 path_params, 4750 query_params, 4751 header_params, 4752 body=body_params, 4753 post_params=form_params, 4754 files=local_var_files, 4755 response_type=None, 4756 auth_settings=auth_settings, 4757 callback=params.get('callback'), 4758 _return_http_data_only=params.get('_return_http_data_only'), 4759 _preload_content=params.get('_preload_content', True), 4760 _request_timeout=params.get('_request_timeout'), 4761 collection_formats=collection_formats) 4762 4763 def delete_envelope_workflow_step_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 4764 """ 4765 Deletes the envelope workflow step definition for an envelope's workflow by step id. 4766 This method makes a synchronous HTTP request by default. To make an 4767 asynchronous HTTP request, please define a `callback` function 4768 to be invoked when receiving the response. 4769 >>> def callback_function(response): 4770 >>> pprint(response) 4771 >>> 4772 >>> thread = api.delete_envelope_workflow_step_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 4773 4774 :param callback function: The callback function 4775 for asynchronous request. (optional) 4776 :param str account_id: The external account number (int) or account ID Guid. (required) 4777 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4778 :param str workflow_step_id: (required) 4779 :return: None 4780 If the method is called asynchronously, 4781 returns the request thread. 4782 """ 4783 kwargs['_return_http_data_only'] = True 4784 if kwargs.get('callback'): 4785 return self.delete_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 4786 else: 4787 (data) = self.delete_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 4788 return data 4789 4790 def delete_envelope_workflow_step_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 4791 """ 4792 Deletes the envelope workflow step definition for an envelope's workflow by step id. 4793 This method makes a synchronous HTTP request by default. To make an 4794 asynchronous HTTP request, please define a `callback` function 4795 to be invoked when receiving the response. 4796 >>> def callback_function(response): 4797 >>> pprint(response) 4798 >>> 4799 >>> thread = api.delete_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 4800 4801 :param callback function: The callback function 4802 for asynchronous request. (optional) 4803 :param str account_id: The external account number (int) or account ID Guid. (required) 4804 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4805 :param str workflow_step_id: (required) 4806 :return: None 4807 If the method is called asynchronously, 4808 returns the request thread. 4809 """ 4810 4811 all_params = ['account_id', 'envelope_id', 'workflow_step_id'] 4812 all_params.append('callback') 4813 all_params.append('_return_http_data_only') 4814 all_params.append('_preload_content') 4815 all_params.append('_request_timeout') 4816 4817 params = locals() 4818 for key, val in iteritems(params['kwargs']): 4819 if key not in all_params: 4820 raise TypeError( 4821 "Got an unexpected keyword argument '%s'" 4822 " to method delete_envelope_workflow_step_definition" % key 4823 ) 4824 params[key] = val 4825 del params['kwargs'] 4826 # verify the required parameter 'account_id' is set 4827 if ('account_id' not in params) or (params['account_id'] is None): 4828 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_workflow_step_definition`") 4829 # verify the required parameter 'envelope_id' is set 4830 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4831 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_envelope_workflow_step_definition`") 4832 # verify the required parameter 'workflow_step_id' is set 4833 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 4834 raise ValueError("Missing the required parameter `workflow_step_id` when calling `delete_envelope_workflow_step_definition`") 4835 4836 4837 collection_formats = {} 4838 4839 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 4840 path_params = {} 4841 if 'account_id' in params: 4842 path_params['accountId'] = params['account_id'] 4843 if 'envelope_id' in params: 4844 path_params['envelopeId'] = params['envelope_id'] 4845 if 'workflow_step_id' in params: 4846 path_params['workflowStepId'] = params['workflow_step_id'] 4847 4848 query_params = {} 4849 4850 header_params = {} 4851 4852 form_params = [] 4853 local_var_files = {} 4854 4855 body_params = None 4856 # HTTP header `Accept` 4857 header_params['Accept'] = self.api_client.\ 4858 select_header_accept(['application/json']) 4859 4860 # Authentication setting 4861 auth_settings = [] 4862 4863 return self.api_client.call_api(resource_path, 'DELETE', 4864 path_params, 4865 query_params, 4866 header_params, 4867 body=body_params, 4868 post_params=form_params, 4869 files=local_var_files, 4870 response_type=None, 4871 auth_settings=auth_settings, 4872 callback=params.get('callback'), 4873 _return_http_data_only=params.get('_return_http_data_only'), 4874 _preload_content=params.get('_preload_content', True), 4875 _request_timeout=params.get('_request_timeout'), 4876 collection_formats=collection_formats) 4877 4878 def delete_lock(self, account_id, envelope_id, **kwargs): 4879 """ 4880 Deletes an envelope lock. 4881 Deletes the lock from the specified envelope. The `X-DocuSign-Edit` header must be included in the request. 4882 This method makes a synchronous HTTP request by default. To make an 4883 asynchronous HTTP request, please define a `callback` function 4884 to be invoked when receiving the response. 4885 >>> def callback_function(response): 4886 >>> pprint(response) 4887 >>> 4888 >>> thread = api.delete_lock(account_id, envelope_id, callback=callback_function) 4889 4890 :param callback function: The callback function 4891 for asynchronous request. (optional) 4892 :param str account_id: The external account number (int) or account ID Guid. (required) 4893 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4894 :return: LockInformation 4895 If the method is called asynchronously, 4896 returns the request thread. 4897 """ 4898 kwargs['_return_http_data_only'] = True 4899 if kwargs.get('callback'): 4900 return self.delete_lock_with_http_info(account_id, envelope_id, **kwargs) 4901 else: 4902 (data) = self.delete_lock_with_http_info(account_id, envelope_id, **kwargs) 4903 return data 4904 4905 def delete_lock_with_http_info(self, account_id, envelope_id, **kwargs): 4906 """ 4907 Deletes an envelope lock. 4908 Deletes the lock from the specified envelope. The `X-DocuSign-Edit` header must be included in the request. 4909 This method makes a synchronous HTTP request by default. To make an 4910 asynchronous HTTP request, please define a `callback` function 4911 to be invoked when receiving the response. 4912 >>> def callback_function(response): 4913 >>> pprint(response) 4914 >>> 4915 >>> thread = api.delete_lock_with_http_info(account_id, envelope_id, callback=callback_function) 4916 4917 :param callback function: The callback function 4918 for asynchronous request. (optional) 4919 :param str account_id: The external account number (int) or account ID Guid. (required) 4920 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4921 :return: LockInformation 4922 If the method is called asynchronously, 4923 returns the request thread. 4924 """ 4925 4926 all_params = ['account_id', 'envelope_id'] 4927 all_params.append('callback') 4928 all_params.append('_return_http_data_only') 4929 all_params.append('_preload_content') 4930 all_params.append('_request_timeout') 4931 4932 params = locals() 4933 for key, val in iteritems(params['kwargs']): 4934 if key not in all_params: 4935 raise TypeError( 4936 "Got an unexpected keyword argument '%s'" 4937 " to method delete_lock" % key 4938 ) 4939 params[key] = val 4940 del params['kwargs'] 4941 # verify the required parameter 'account_id' is set 4942 if ('account_id' not in params) or (params['account_id'] is None): 4943 raise ValueError("Missing the required parameter `account_id` when calling `delete_lock`") 4944 # verify the required parameter 'envelope_id' is set 4945 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4946 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_lock`") 4947 4948 4949 collection_formats = {} 4950 4951 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/lock'.replace('{format}', 'json') 4952 path_params = {} 4953 if 'account_id' in params: 4954 path_params['accountId'] = params['account_id'] 4955 if 'envelope_id' in params: 4956 path_params['envelopeId'] = params['envelope_id'] 4957 4958 query_params = {} 4959 4960 header_params = {} 4961 4962 form_params = [] 4963 local_var_files = {} 4964 4965 body_params = None 4966 # HTTP header `Accept` 4967 header_params['Accept'] = self.api_client.\ 4968 select_header_accept(['application/json']) 4969 4970 # Authentication setting 4971 auth_settings = [] 4972 4973 return self.api_client.call_api(resource_path, 'DELETE', 4974 path_params, 4975 query_params, 4976 header_params, 4977 body=body_params, 4978 post_params=form_params, 4979 files=local_var_files, 4980 response_type='LockInformation', 4981 auth_settings=auth_settings, 4982 callback=params.get('callback'), 4983 _return_http_data_only=params.get('_return_http_data_only'), 4984 _preload_content=params.get('_preload_content', True), 4985 _request_timeout=params.get('_request_timeout'), 4986 collection_formats=collection_formats) 4987 4988 def delete_recipient(self, account_id, envelope_id, recipient_id, **kwargs): 4989 """ 4990 Deletes a recipient from an envelope. 4991 Deletes the specified recipient file from the specified envelope. This cannot be used if the envelope has been sent. 4992 This method makes a synchronous HTTP request by default. To make an 4993 asynchronous HTTP request, please define a `callback` function 4994 to be invoked when receiving the response. 4995 >>> def callback_function(response): 4996 >>> pprint(response) 4997 >>> 4998 >>> thread = api.delete_recipient(account_id, envelope_id, recipient_id, callback=callback_function) 4999 5000 :param callback function: The callback function 5001 for asynchronous request. (optional) 5002 :param str account_id: The external account number (int) or account ID Guid. (required) 5003 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5004 :param str recipient_id: The ID of the recipient being accessed. (required) 5005 :return: Recipients 5006 If the method is called asynchronously, 5007 returns the request thread. 5008 """ 5009 kwargs['_return_http_data_only'] = True 5010 if kwargs.get('callback'): 5011 return self.delete_recipient_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 5012 else: 5013 (data) = self.delete_recipient_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 5014 return data 5015 5016 def delete_recipient_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 5017 """ 5018 Deletes a recipient from an envelope. 5019 Deletes the specified recipient file from the specified envelope. This cannot be used if the envelope has been sent. 5020 This method makes a synchronous HTTP request by default. To make an 5021 asynchronous HTTP request, please define a `callback` function 5022 to be invoked when receiving the response. 5023 >>> def callback_function(response): 5024 >>> pprint(response) 5025 >>> 5026 >>> thread = api.delete_recipient_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 5027 5028 :param callback function: The callback function 5029 for asynchronous request. (optional) 5030 :param str account_id: The external account number (int) or account ID Guid. (required) 5031 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5032 :param str recipient_id: The ID of the recipient being accessed. (required) 5033 :return: Recipients 5034 If the method is called asynchronously, 5035 returns the request thread. 5036 """ 5037 5038 all_params = ['account_id', 'envelope_id', 'recipient_id'] 5039 all_params.append('callback') 5040 all_params.append('_return_http_data_only') 5041 all_params.append('_preload_content') 5042 all_params.append('_request_timeout') 5043 5044 params = locals() 5045 for key, val in iteritems(params['kwargs']): 5046 if key not in all_params: 5047 raise TypeError( 5048 "Got an unexpected keyword argument '%s'" 5049 " to method delete_recipient" % key 5050 ) 5051 params[key] = val 5052 del params['kwargs'] 5053 # verify the required parameter 'account_id' is set 5054 if ('account_id' not in params) or (params['account_id'] is None): 5055 raise ValueError("Missing the required parameter `account_id` when calling `delete_recipient`") 5056 # verify the required parameter 'envelope_id' is set 5057 if ('envelope_id' not in params) or (params['envelope_id'] is None): 5058 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_recipient`") 5059 # verify the required parameter 'recipient_id' is set 5060 if ('recipient_id' not in params) or (params['recipient_id'] is None): 5061 raise ValueError("Missing the required parameter `recipient_id` when calling `delete_recipient`") 5062 5063 5064 collection_formats = {} 5065 5066 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}'.replace('{format}', 'json') 5067 path_params = {} 5068 if 'account_id' in params: 5069 path_params['accountId'] = params['account_id'] 5070 if 'envelope_id' in params: 5071 path_params['envelopeId'] = params['envelope_id'] 5072 if 'recipient_id' in params: 5073 path_params['recipientId'] = params['recipient_id'] 5074 5075 query_params = {} 5076 5077 header_params = {} 5078 5079 form_params = [] 5080 local_var_files = {} 5081 5082 body_params = None 5083 # HTTP header `Accept` 5084 header_params['Accept'] = self.api_client.\ 5085 select_header_accept(['application/json']) 5086 5087 # Authentication setting 5088 auth_settings = [] 5089 5090 return self.api_client.call_api(resource_path, 'DELETE', 5091 path_params, 5092 query_params, 5093 header_params, 5094 body=body_params, 5095 post_params=form_params, 5096 files=local_var_files, 5097 response_type='Recipients', 5098 auth_settings=auth_settings, 5099 callback=params.get('callback'), 5100 _return_http_data_only=params.get('_return_http_data_only'), 5101 _preload_content=params.get('_preload_content', True), 5102 _request_timeout=params.get('_request_timeout'), 5103 collection_formats=collection_formats) 5104 5105 def delete_recipients(self, account_id, envelope_id, **kwargs): 5106 """ 5107 Deletes recipients from an envelope. 5108 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. 5109 This method makes a synchronous HTTP request by default. To make an 5110 asynchronous HTTP request, please define a `callback` function 5111 to be invoked when receiving the response. 5112 >>> def callback_function(response): 5113 >>> pprint(response) 5114 >>> 5115 >>> thread = api.delete_recipients(account_id, envelope_id, callback=callback_function) 5116 5117 :param callback function: The callback function 5118 for asynchronous request. (optional) 5119 :param str account_id: The external account number (int) or account ID Guid. (required) 5120 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5121 :param Recipients recipients: 5122 :return: Recipients 5123 If the method is called asynchronously, 5124 returns the request thread. 5125 """ 5126 kwargs['_return_http_data_only'] = True 5127 if kwargs.get('callback'): 5128 return self.delete_recipients_with_http_info(account_id, envelope_id, **kwargs) 5129 else: 5130 (data) = self.delete_recipients_with_http_info(account_id, envelope_id, **kwargs) 5131 return data 5132 5133 def delete_recipients_with_http_info(self, account_id, envelope_id, **kwargs): 5134 """ 5135 Deletes recipients from an envelope. 5136 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. 5137 This method makes a synchronous HTTP request by default. To make an 5138 asynchronous HTTP request, please define a `callback` function 5139 to be invoked when receiving the response. 5140 >>> def callback_function(response): 5141 >>> pprint(response) 5142 >>> 5143 >>> thread = api.delete_recipients_with_http_info(account_id, envelope_id, callback=callback_function) 5144 5145 :param callback function: The callback function 5146 for asynchronous request. (optional) 5147 :param str account_id: The external account number (int) or account ID Guid. (required) 5148 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5149 :param Recipients recipients: 5150 :return: Recipients 5151 If the method is called asynchronously, 5152 returns the request thread. 5153 """ 5154 5155 all_params = ['account_id', 'envelope_id', 'recipients'] 5156 all_params.append('callback') 5157 all_params.append('_return_http_data_only') 5158 all_params.append('_preload_content') 5159 all_params.append('_request_timeout') 5160 5161 params = locals() 5162 for key, val in iteritems(params['kwargs']): 5163 if key not in all_params: 5164 raise TypeError( 5165 "Got an unexpected keyword argument '%s'" 5166 " to method delete_recipients" % key 5167 ) 5168 params[key] = val 5169 del params['kwargs'] 5170 # verify the required parameter 'account_id' is set 5171 if ('account_id' not in params) or (params['account_id'] is None): 5172 raise ValueError("Missing the required parameter `account_id` when calling `delete_recipients`") 5173 # verify the required parameter 'envelope_id' is set 5174 if ('envelope_id' not in params) or (params['envelope_id'] is None): 5175 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_recipients`") 5176 5177 5178 collection_formats = {} 5179 5180 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients'.replace('{format}', 'json') 5181 path_params = {} 5182 if 'account_id' in params: 5183 path_params['accountId'] = params['account_id'] 5184 if 'envelope_id' in params: 5185 path_params['envelopeId'] = params['envelope_id'] 5186 5187 query_params = {} 5188 5189 header_params = {} 5190 5191 form_params = [] 5192 local_var_files = {} 5193 5194 body_params = None 5195 if 'recipients' in params: 5196 body_params = params['recipients'] 5197 # HTTP header `Accept` 5198 header_params['Accept'] = self.api_client.\ 5199 select_header_accept(['application/json']) 5200 5201 # Authentication setting 5202 auth_settings = [] 5203 5204 return self.api_client.call_api(resource_path, 'DELETE', 5205 path_params, 5206 query_params, 5207 header_params, 5208 body=body_params, 5209 post_params=form_params, 5210 files=local_var_files, 5211 response_type='Recipients', 5212 auth_settings=auth_settings, 5213 callback=params.get('callback'), 5214 _return_http_data_only=params.get('_return_http_data_only'), 5215 _preload_content=params.get('_preload_content', True), 5216 _request_timeout=params.get('_request_timeout'), 5217 collection_formats=collection_formats) 5218 5219 def delete_tabs(self, account_id, envelope_id, recipient_id, **kwargs): 5220 """ 5221 Deletes the tabs associated with a recipient. 5222 Deletes one or more tabs associated with a recipient in a draft envelope. 5223 This method makes a synchronous HTTP request by default. To make an 5224 asynchronous HTTP request, please define a `callback` function 5225 to be invoked when receiving the response. 5226 >>> def callback_function(response): 5227 >>> pprint(response) 5228 >>> 5229 >>> thread = api.delete_tabs(account_id, envelope_id, recipient_id, callback=callback_function) 5230 5231 :param callback function: The callback function 5232 for asynchronous request. (optional) 5233 :param str account_id: The external account number (int) or account ID Guid. (required) 5234 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5235 :param str recipient_id: The ID of the recipient being accessed. (required) 5236 :param Tabs tabs: 5237 :return: Tabs 5238 If the method is called asynchronously, 5239 returns the request thread. 5240 """ 5241 kwargs['_return_http_data_only'] = True 5242 if kwargs.get('callback'): 5243 return self.delete_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 5244 else: 5245 (data) = self.delete_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 5246 return data 5247 5248 def delete_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 5249 """ 5250 Deletes the tabs associated with a recipient. 5251 Deletes one or more tabs associated with a recipient in a draft envelope. 5252 This method makes a synchronous HTTP request by default. To make an 5253 asynchronous HTTP request, please define a `callback` function 5254 to be invoked when receiving the response. 5255 >>> def callback_function(response): 5256 >>> pprint(response) 5257 >>> 5258 >>> thread = api.delete_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 5259 5260 :param callback function: The callback function 5261 for asynchronous request. (optional) 5262 :param str account_id: The external account number (int) or account ID Guid. (required) 5263 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5264 :param str recipient_id: The ID of the recipient being accessed. (required) 5265 :param Tabs tabs: 5266 :return: Tabs 5267 If the method is called asynchronously, 5268 returns the request thread. 5269 """ 5270 5271 all_params = ['account_id', 'envelope_id', 'recipient_id', 'tabs'] 5272 all_params.append('callback') 5273 all_params.append('_return_http_data_only') 5274 all_params.append('_preload_content') 5275 all_params.append('_request_timeout') 5276 5277 params = locals() 5278 for key, val in iteritems(params['kwargs']): 5279 if key not in all_params: 5280 raise TypeError( 5281 "Got an unexpected keyword argument '%s'" 5282 " to method delete_tabs" % key 5283 ) 5284 params[key] = val 5285 del params['kwargs'] 5286 # verify the required parameter 'account_id' is set 5287 if ('account_id' not in params) or (params['account_id'] is None): 5288 raise ValueError("Missing the required parameter `account_id` when calling `delete_tabs`") 5289 # verify the required parameter 'envelope_id' is set 5290 if ('envelope_id' not in params) or (params['envelope_id'] is None): 5291 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_tabs`") 5292 # verify the required parameter 'recipient_id' is set 5293 if ('recipient_id' not in params) or (params['recipient_id'] is None): 5294 raise ValueError("Missing the required parameter `recipient_id` when calling `delete_tabs`") 5295 5296 5297 collection_formats = {} 5298 5299 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/tabs'.replace('{format}', 'json') 5300 path_params = {} 5301 if 'account_id' in params: 5302 path_params['accountId'] = params['account_id'] 5303 if 'envelope_id' in params: 5304 path_params['envelopeId'] = params['envelope_id'] 5305 if 'recipient_id' in params: 5306 path_params['recipientId'] = params['recipient_id'] 5307 5308 query_params = {} 5309 5310 header_params = {} 5311 5312 form_params = [] 5313 local_var_files = {} 5314 5315 body_params = None 5316 if 'tabs' in params: 5317 body_params = params['tabs'] 5318 # HTTP header `Accept` 5319 header_params['Accept'] = self.api_client.\ 5320 select_header_accept(['application/json']) 5321 5322 # Authentication setting 5323 auth_settings = [] 5324 5325 return self.api_client.call_api(resource_path, 'DELETE', 5326 path_params, 5327 query_params, 5328 header_params, 5329 body=body_params, 5330 post_params=form_params, 5331 files=local_var_files, 5332 response_type='Tabs', 5333 auth_settings=auth_settings, 5334 callback=params.get('callback'), 5335 _return_http_data_only=params.get('_return_http_data_only'), 5336 _preload_content=params.get('_preload_content', True), 5337 _request_timeout=params.get('_request_timeout'), 5338 collection_formats=collection_formats) 5339 5340 def delete_template_delayed_routing_definition(self, account_id, template_id, workflow_step_id, **kwargs): 5341 """ 5342 Deletes the delayed routing rules for the specified template workflow step. 5343 This method makes a synchronous HTTP request by default. To make an 5344 asynchronous HTTP request, please define a `callback` function 5345 to be invoked when receiving the response. 5346 >>> def callback_function(response): 5347 >>> pprint(response) 5348 >>> 5349 >>> thread = api.delete_template_delayed_routing_definition(account_id, template_id, workflow_step_id, callback=callback_function) 5350 5351 :param callback function: The callback function 5352 for asynchronous request. (optional) 5353 :param str account_id: The external account number (int) or account ID Guid. (required) 5354 :param str template_id: The ID of the template being accessed. (required) 5355 :param str workflow_step_id: (required) 5356 :return: None 5357 If the method is called asynchronously, 5358 returns the request thread. 5359 """ 5360 kwargs['_return_http_data_only'] = True 5361 if kwargs.get('callback'): 5362 return self.delete_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 5363 else: 5364 (data) = self.delete_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 5365 return data 5366 5367 def delete_template_delayed_routing_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 5368 """ 5369 Deletes the delayed routing rules for the specified template workflow step. 5370 This method makes a synchronous HTTP request by default. To make an 5371 asynchronous HTTP request, please define a `callback` function 5372 to be invoked when receiving the response. 5373 >>> def callback_function(response): 5374 >>> pprint(response) 5375 >>> 5376 >>> thread = api.delete_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 5377 5378 :param callback function: The callback function 5379 for asynchronous request. (optional) 5380 :param str account_id: The external account number (int) or account ID Guid. (required) 5381 :param str template_id: The ID of the template being accessed. (required) 5382 :param str workflow_step_id: (required) 5383 :return: None 5384 If the method is called asynchronously, 5385 returns the request thread. 5386 """ 5387 5388 all_params = ['account_id', 'template_id', 'workflow_step_id'] 5389 all_params.append('callback') 5390 all_params.append('_return_http_data_only') 5391 all_params.append('_preload_content') 5392 all_params.append('_request_timeout') 5393 5394 params = locals() 5395 for key, val in iteritems(params['kwargs']): 5396 if key not in all_params: 5397 raise TypeError( 5398 "Got an unexpected keyword argument '%s'" 5399 " to method delete_template_delayed_routing_definition" % key 5400 ) 5401 params[key] = val 5402 del params['kwargs'] 5403 # verify the required parameter 'account_id' is set 5404 if ('account_id' not in params) or (params['account_id'] is None): 5405 raise ValueError("Missing the required parameter `account_id` when calling `delete_template_delayed_routing_definition`") 5406 # verify the required parameter 'template_id' is set 5407 if ('template_id' not in params) or (params['template_id'] is None): 5408 raise ValueError("Missing the required parameter `template_id` when calling `delete_template_delayed_routing_definition`") 5409 # verify the required parameter 'workflow_step_id' is set 5410 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 5411 raise ValueError("Missing the required parameter `workflow_step_id` when calling `delete_template_delayed_routing_definition`") 5412 5413 5414 collection_formats = {} 5415 5416 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 5417 path_params = {} 5418 if 'account_id' in params: 5419 path_params['accountId'] = params['account_id'] 5420 if 'template_id' in params: 5421 path_params['templateId'] = params['template_id'] 5422 if 'workflow_step_id' in params: 5423 path_params['workflowStepId'] = params['workflow_step_id'] 5424 5425 query_params = {} 5426 5427 header_params = {} 5428 5429 form_params = [] 5430 local_var_files = {} 5431 5432 body_params = None 5433 # HTTP header `Accept` 5434 header_params['Accept'] = self.api_client.\ 5435 select_header_accept(['application/json']) 5436 5437 # Authentication setting 5438 auth_settings = [] 5439 5440 return self.api_client.call_api(resource_path, 'DELETE', 5441 path_params, 5442 query_params, 5443 header_params, 5444 body=body_params, 5445 post_params=form_params, 5446 files=local_var_files, 5447 response_type=None, 5448 auth_settings=auth_settings, 5449 callback=params.get('callback'), 5450 _return_http_data_only=params.get('_return_http_data_only'), 5451 _preload_content=params.get('_preload_content', True), 5452 _request_timeout=params.get('_request_timeout'), 5453 collection_formats=collection_formats) 5454 5455 def delete_template_scheduled_sending_definition(self, account_id, template_id, **kwargs): 5456 """ 5457 Deletes the scheduled sending rules for the template's workflow. 5458 This method makes a synchronous HTTP request by default. To make an 5459 asynchronous HTTP request, please define a `callback` function 5460 to be invoked when receiving the response. 5461 >>> def callback_function(response): 5462 >>> pprint(response) 5463 >>> 5464 >>> thread = api.delete_template_scheduled_sending_definition(account_id, template_id, callback=callback_function) 5465 5466 :param callback function: The callback function 5467 for asynchronous request. (optional) 5468 :param str account_id: The external account number (int) or account ID Guid. (required) 5469 :param str template_id: The ID of the template being accessed. (required) 5470 :return: None 5471 If the method is called asynchronously, 5472 returns the request thread. 5473 """ 5474 kwargs['_return_http_data_only'] = True 5475 if kwargs.get('callback'): 5476 return self.delete_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 5477 else: 5478 (data) = self.delete_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 5479 return data 5480 5481 def delete_template_scheduled_sending_definition_with_http_info(self, account_id, template_id, **kwargs): 5482 """ 5483 Deletes the scheduled sending rules for the template's workflow. 5484 This method makes a synchronous HTTP request by default. To make an 5485 asynchronous HTTP request, please define a `callback` function 5486 to be invoked when receiving the response. 5487 >>> def callback_function(response): 5488 >>> pprint(response) 5489 >>> 5490 >>> thread = api.delete_template_scheduled_sending_definition_with_http_info(account_id, template_id, callback=callback_function) 5491 5492 :param callback function: The callback function 5493 for asynchronous request. (optional) 5494 :param str account_id: The external account number (int) or account ID Guid. (required) 5495 :param str template_id: The ID of the template being accessed. (required) 5496 :return: None 5497 If the method is called asynchronously, 5498 returns the request thread. 5499 """ 5500 5501 all_params = ['account_id', 'template_id'] 5502 all_params.append('callback') 5503 all_params.append('_return_http_data_only') 5504 all_params.append('_preload_content') 5505 all_params.append('_request_timeout') 5506 5507 params = locals() 5508 for key, val in iteritems(params['kwargs']): 5509 if key not in all_params: 5510 raise TypeError( 5511 "Got an unexpected keyword argument '%s'" 5512 " to method delete_template_scheduled_sending_definition" % key 5513 ) 5514 params[key] = val 5515 del params['kwargs'] 5516 # verify the required parameter 'account_id' is set 5517 if ('account_id' not in params) or (params['account_id'] is None): 5518 raise ValueError("Missing the required parameter `account_id` when calling `delete_template_scheduled_sending_definition`") 5519 # verify the required parameter 'template_id' is set 5520 if ('template_id' not in params) or (params['template_id'] is None): 5521 raise ValueError("Missing the required parameter `template_id` when calling `delete_template_scheduled_sending_definition`") 5522 5523 5524 collection_formats = {} 5525 5526 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/scheduledSending'.replace('{format}', 'json') 5527 path_params = {} 5528 if 'account_id' in params: 5529 path_params['accountId'] = params['account_id'] 5530 if 'template_id' in params: 5531 path_params['templateId'] = params['template_id'] 5532 5533 query_params = {} 5534 5535 header_params = {} 5536 5537 form_params = [] 5538 local_var_files = {} 5539 5540 body_params = None 5541 # HTTP header `Accept` 5542 header_params['Accept'] = self.api_client.\ 5543 select_header_accept(['application/json']) 5544 5545 # Authentication setting 5546 auth_settings = [] 5547 5548 return self.api_client.call_api(resource_path, 'DELETE', 5549 path_params, 5550 query_params, 5551 header_params, 5552 body=body_params, 5553 post_params=form_params, 5554 files=local_var_files, 5555 response_type=None, 5556 auth_settings=auth_settings, 5557 callback=params.get('callback'), 5558 _return_http_data_only=params.get('_return_http_data_only'), 5559 _preload_content=params.get('_preload_content', True), 5560 _request_timeout=params.get('_request_timeout'), 5561 collection_formats=collection_formats) 5562 5563 def delete_template_workflow_definition(self, account_id, template_id, **kwargs): 5564 """ 5565 Delete the workflow definition for a template. 5566 Deletes the specified template's workflow definition if it has one. 5567 This method makes a synchronous HTTP request by default. To make an 5568 asynchronous HTTP request, please define a `callback` function 5569 to be invoked when receiving the response. 5570 >>> def callback_function(response): 5571 >>> pprint(response) 5572 >>> 5573 >>> thread = api.delete_template_workflow_definition(account_id, template_id, callback=callback_function) 5574 5575 :param callback function: The callback function 5576 for asynchronous request. (optional) 5577 :param str account_id: The external account number (int) or account ID Guid. (required) 5578 :param str template_id: The ID of the template being accessed. (required) 5579 :return: None 5580 If the method is called asynchronously, 5581 returns the request thread. 5582 """ 5583 kwargs['_return_http_data_only'] = True 5584 if kwargs.get('callback'): 5585 return self.delete_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 5586 else: 5587 (data) = self.delete_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 5588 return data 5589 5590 def delete_template_workflow_definition_with_http_info(self, account_id, template_id, **kwargs): 5591 """ 5592 Delete the workflow definition for a template. 5593 Deletes the specified template's workflow definition if it has one. 5594 This method makes a synchronous HTTP request by default. To make an 5595 asynchronous HTTP request, please define a `callback` function 5596 to be invoked when receiving the response. 5597 >>> def callback_function(response): 5598 >>> pprint(response) 5599 >>> 5600 >>> thread = api.delete_template_workflow_definition_with_http_info(account_id, template_id, callback=callback_function) 5601 5602 :param callback function: The callback function 5603 for asynchronous request. (optional) 5604 :param str account_id: The external account number (int) or account ID Guid. (required) 5605 :param str template_id: The ID of the template being accessed. (required) 5606 :return: None 5607 If the method is called asynchronously, 5608 returns the request thread. 5609 """ 5610 5611 all_params = ['account_id', 'template_id'] 5612 all_params.append('callback') 5613 all_params.append('_return_http_data_only') 5614 all_params.append('_preload_content') 5615 all_params.append('_request_timeout') 5616 5617 params = locals() 5618 for key, val in iteritems(params['kwargs']): 5619 if key not in all_params: 5620 raise TypeError( 5621 "Got an unexpected keyword argument '%s'" 5622 " to method delete_template_workflow_definition" % key 5623 ) 5624 params[key] = val 5625 del params['kwargs'] 5626 # verify the required parameter 'account_id' is set 5627 if ('account_id' not in params) or (params['account_id'] is None): 5628 raise ValueError("Missing the required parameter `account_id` when calling `delete_template_workflow_definition`") 5629 # verify the required parameter 'template_id' is set 5630 if ('template_id' not in params) or (params['template_id'] is None): 5631 raise ValueError("Missing the required parameter `template_id` when calling `delete_template_workflow_definition`") 5632 5633 5634 collection_formats = {} 5635 5636 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow'.replace('{format}', 'json') 5637 path_params = {} 5638 if 'account_id' in params: 5639 path_params['accountId'] = params['account_id'] 5640 if 'template_id' in params: 5641 path_params['templateId'] = params['template_id'] 5642 5643 query_params = {} 5644 5645 header_params = {} 5646 5647 form_params = [] 5648 local_var_files = {} 5649 5650 body_params = None 5651 # HTTP header `Accept` 5652 header_params['Accept'] = self.api_client.\ 5653 select_header_accept(['application/json']) 5654 5655 # Authentication setting 5656 auth_settings = [] 5657 5658 return self.api_client.call_api(resource_path, 'DELETE', 5659 path_params, 5660 query_params, 5661 header_params, 5662 body=body_params, 5663 post_params=form_params, 5664 files=local_var_files, 5665 response_type=None, 5666 auth_settings=auth_settings, 5667 callback=params.get('callback'), 5668 _return_http_data_only=params.get('_return_http_data_only'), 5669 _preload_content=params.get('_preload_content', True), 5670 _request_timeout=params.get('_request_timeout'), 5671 collection_formats=collection_formats) 5672 5673 def delete_template_workflow_step_definition(self, account_id, template_id, workflow_step_id, **kwargs): 5674 """ 5675 Deletes the workflow step definition for an template's workflow by step id. 5676 This method makes a synchronous HTTP request by default. To make an 5677 asynchronous HTTP request, please define a `callback` function 5678 to be invoked when receiving the response. 5679 >>> def callback_function(response): 5680 >>> pprint(response) 5681 >>> 5682 >>> thread = api.delete_template_workflow_step_definition(account_id, template_id, workflow_step_id, callback=callback_function) 5683 5684 :param callback function: The callback function 5685 for asynchronous request. (optional) 5686 :param str account_id: The external account number (int) or account ID Guid. (required) 5687 :param str template_id: The ID of the template being accessed. (required) 5688 :param str workflow_step_id: (required) 5689 :return: None 5690 If the method is called asynchronously, 5691 returns the request thread. 5692 """ 5693 kwargs['_return_http_data_only'] = True 5694 if kwargs.get('callback'): 5695 return self.delete_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 5696 else: 5697 (data) = self.delete_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 5698 return data 5699 5700 def delete_template_workflow_step_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 5701 """ 5702 Deletes the workflow step definition for an template's workflow by step id. 5703 This method makes a synchronous HTTP request by default. To make an 5704 asynchronous HTTP request, please define a `callback` function 5705 to be invoked when receiving the response. 5706 >>> def callback_function(response): 5707 >>> pprint(response) 5708 >>> 5709 >>> thread = api.delete_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 5710 5711 :param callback function: The callback function 5712 for asynchronous request. (optional) 5713 :param str account_id: The external account number (int) or account ID Guid. (required) 5714 :param str template_id: The ID of the template being accessed. (required) 5715 :param str workflow_step_id: (required) 5716 :return: None 5717 If the method is called asynchronously, 5718 returns the request thread. 5719 """ 5720 5721 all_params = ['account_id', 'template_id', 'workflow_step_id'] 5722 all_params.append('callback') 5723 all_params.append('_return_http_data_only') 5724 all_params.append('_preload_content') 5725 all_params.append('_request_timeout') 5726 5727 params = locals() 5728 for key, val in iteritems(params['kwargs']): 5729 if key not in all_params: 5730 raise TypeError( 5731 "Got an unexpected keyword argument '%s'" 5732 " to method delete_template_workflow_step_definition" % key 5733 ) 5734 params[key] = val 5735 del params['kwargs'] 5736 # verify the required parameter 'account_id' is set 5737 if ('account_id' not in params) or (params['account_id'] is None): 5738 raise ValueError("Missing the required parameter `account_id` when calling `delete_template_workflow_step_definition`") 5739 # verify the required parameter 'template_id' is set 5740 if ('template_id' not in params) or (params['template_id'] is None): 5741 raise ValueError("Missing the required parameter `template_id` when calling `delete_template_workflow_step_definition`") 5742 # verify the required parameter 'workflow_step_id' is set 5743 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 5744 raise ValueError("Missing the required parameter `workflow_step_id` when calling `delete_template_workflow_step_definition`") 5745 5746 5747 collection_formats = {} 5748 5749 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 5750 path_params = {} 5751 if 'account_id' in params: 5752 path_params['accountId'] = params['account_id'] 5753 if 'template_id' in params: 5754 path_params['templateId'] = params['template_id'] 5755 if 'workflow_step_id' in params: 5756 path_params['workflowStepId'] = params['workflow_step_id'] 5757 5758 query_params = {} 5759 5760 header_params = {} 5761 5762 form_params = [] 5763 local_var_files = {} 5764 5765 body_params = None 5766 # HTTP header `Accept` 5767 header_params['Accept'] = self.api_client.\ 5768 select_header_accept(['application/json']) 5769 5770 # Authentication setting 5771 auth_settings = [] 5772 5773 return self.api_client.call_api(resource_path, 'DELETE', 5774 path_params, 5775 query_params, 5776 header_params, 5777 body=body_params, 5778 post_params=form_params, 5779 files=local_var_files, 5780 response_type=None, 5781 auth_settings=auth_settings, 5782 callback=params.get('callback'), 5783 _return_http_data_only=params.get('_return_http_data_only'), 5784 _preload_content=params.get('_preload_content', True), 5785 _request_timeout=params.get('_request_timeout'), 5786 collection_formats=collection_formats) 5787 5788 def delete_templates_from_document(self, account_id, document_id, envelope_id, template_id, **kwargs): 5789 """ 5790 Deletes a template from a document in an existing envelope. 5791 Deletes the specified template from a document in an existing envelope. 5792 This method makes a synchronous HTTP request by default. To make an 5793 asynchronous HTTP request, please define a `callback` function 5794 to be invoked when receiving the response. 5795 >>> def callback_function(response): 5796 >>> pprint(response) 5797 >>> 5798 >>> thread = api.delete_templates_from_document(account_id, document_id, envelope_id, template_id, callback=callback_function) 5799 5800 :param callback function: The callback function 5801 for asynchronous request. (optional) 5802 :param str account_id: The external account number (int) or account ID Guid. (required) 5803 :param str document_id: The ID of the document being accessed. (required) 5804 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5805 :param str template_id: The ID of the template being accessed. (required) 5806 :return: None 5807 If the method is called asynchronously, 5808 returns the request thread. 5809 """ 5810 kwargs['_return_http_data_only'] = True 5811 if kwargs.get('callback'): 5812 return self.delete_templates_from_document_with_http_info(account_id, document_id, envelope_id, template_id, **kwargs) 5813 else: 5814 (data) = self.delete_templates_from_document_with_http_info(account_id, document_id, envelope_id, template_id, **kwargs) 5815 return data 5816 5817 def delete_templates_from_document_with_http_info(self, account_id, document_id, envelope_id, template_id, **kwargs): 5818 """ 5819 Deletes a template from a document in an existing envelope. 5820 Deletes the specified template from a document in an existing envelope. 5821 This method makes a synchronous HTTP request by default. To make an 5822 asynchronous HTTP request, please define a `callback` function 5823 to be invoked when receiving the response. 5824 >>> def callback_function(response): 5825 >>> pprint(response) 5826 >>> 5827 >>> thread = api.delete_templates_from_document_with_http_info(account_id, document_id, envelope_id, template_id, callback=callback_function) 5828 5829 :param callback function: The callback function 5830 for asynchronous request. (optional) 5831 :param str account_id: The external account number (int) or account ID Guid. (required) 5832 :param str document_id: The ID of the document being accessed. (required) 5833 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5834 :param str template_id: The ID of the template being accessed. (required) 5835 :return: None 5836 If the method is called asynchronously, 5837 returns the request thread. 5838 """ 5839 5840 all_params = ['account_id', 'document_id', 'envelope_id', 'template_id'] 5841 all_params.append('callback') 5842 all_params.append('_return_http_data_only') 5843 all_params.append('_preload_content') 5844 all_params.append('_request_timeout') 5845 5846 params = locals() 5847 for key, val in iteritems(params['kwargs']): 5848 if key not in all_params: 5849 raise TypeError( 5850 "Got an unexpected keyword argument '%s'" 5851 " to method delete_templates_from_document" % key 5852 ) 5853 params[key] = val 5854 del params['kwargs'] 5855 # verify the required parameter 'account_id' is set 5856 if ('account_id' not in params) or (params['account_id'] is None): 5857 raise ValueError("Missing the required parameter `account_id` when calling `delete_templates_from_document`") 5858 # verify the required parameter 'document_id' is set 5859 if ('document_id' not in params) or (params['document_id'] is None): 5860 raise ValueError("Missing the required parameter `document_id` when calling `delete_templates_from_document`") 5861 # verify the required parameter 'envelope_id' is set 5862 if ('envelope_id' not in params) or (params['envelope_id'] is None): 5863 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_templates_from_document`") 5864 # verify the required parameter 'template_id' is set 5865 if ('template_id' not in params) or (params['template_id'] is None): 5866 raise ValueError("Missing the required parameter `template_id` when calling `delete_templates_from_document`") 5867 5868 5869 collection_formats = {} 5870 5871 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/templates/{templateId}'.replace('{format}', 'json') 5872 path_params = {} 5873 if 'account_id' in params: 5874 path_params['accountId'] = params['account_id'] 5875 if 'document_id' in params: 5876 path_params['documentId'] = params['document_id'] 5877 if 'envelope_id' in params: 5878 path_params['envelopeId'] = params['envelope_id'] 5879 if 'template_id' in params: 5880 path_params['templateId'] = params['template_id'] 5881 5882 query_params = {} 5883 5884 header_params = {} 5885 5886 form_params = [] 5887 local_var_files = {} 5888 5889 body_params = None 5890 # HTTP header `Accept` 5891 header_params['Accept'] = self.api_client.\ 5892 select_header_accept(['application/json']) 5893 5894 # Authentication setting 5895 auth_settings = [] 5896 5897 return self.api_client.call_api(resource_path, 'DELETE', 5898 path_params, 5899 query_params, 5900 header_params, 5901 body=body_params, 5902 post_params=form_params, 5903 files=local_var_files, 5904 response_type=None, 5905 auth_settings=auth_settings, 5906 callback=params.get('callback'), 5907 _return_http_data_only=params.get('_return_http_data_only'), 5908 _preload_content=params.get('_preload_content', True), 5909 _request_timeout=params.get('_request_timeout'), 5910 collection_formats=collection_formats) 5911 5912 def get_attachment(self, account_id, attachment_id, envelope_id, **kwargs): 5913 """ 5914 Retrieves an attachment from the envelope. 5915 Retrieves an attachment from an envelope. 5916 This method makes a synchronous HTTP request by default. To make an 5917 asynchronous HTTP request, please define a `callback` function 5918 to be invoked when receiving the response. 5919 >>> def callback_function(response): 5920 >>> pprint(response) 5921 >>> 5922 >>> thread = api.get_attachment(account_id, attachment_id, envelope_id, callback=callback_function) 5923 5924 :param callback function: The callback function 5925 for asynchronous request. (optional) 5926 :param str account_id: The external account number (int) or account ID Guid. (required) 5927 :param str attachment_id: (required) 5928 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5929 :return: None 5930 If the method is called asynchronously, 5931 returns the request thread. 5932 """ 5933 kwargs['_return_http_data_only'] = True 5934 if kwargs.get('callback'): 5935 return self.get_attachment_with_http_info(account_id, attachment_id, envelope_id, **kwargs) 5936 else: 5937 (data) = self.get_attachment_with_http_info(account_id, attachment_id, envelope_id, **kwargs) 5938 return data 5939 5940 def get_attachment_with_http_info(self, account_id, attachment_id, envelope_id, **kwargs): 5941 """ 5942 Retrieves an attachment from the envelope. 5943 Retrieves an attachment from an envelope. 5944 This method makes a synchronous HTTP request by default. To make an 5945 asynchronous HTTP request, please define a `callback` function 5946 to be invoked when receiving the response. 5947 >>> def callback_function(response): 5948 >>> pprint(response) 5949 >>> 5950 >>> thread = api.get_attachment_with_http_info(account_id, attachment_id, envelope_id, callback=callback_function) 5951 5952 :param callback function: The callback function 5953 for asynchronous request. (optional) 5954 :param str account_id: The external account number (int) or account ID Guid. (required) 5955 :param str attachment_id: (required) 5956 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5957 :return: None 5958 If the method is called asynchronously, 5959 returns the request thread. 5960 """ 5961 5962 all_params = ['account_id', 'attachment_id', 'envelope_id'] 5963 all_params.append('callback') 5964 all_params.append('_return_http_data_only') 5965 all_params.append('_preload_content') 5966 all_params.append('_request_timeout') 5967 5968 params = locals() 5969 for key, val in iteritems(params['kwargs']): 5970 if key not in all_params: 5971 raise TypeError( 5972 "Got an unexpected keyword argument '%s'" 5973 " to method get_attachment" % key 5974 ) 5975 params[key] = val 5976 del params['kwargs'] 5977 # verify the required parameter 'account_id' is set 5978 if ('account_id' not in params) or (params['account_id'] is None): 5979 raise ValueError("Missing the required parameter `account_id` when calling `get_attachment`") 5980 # verify the required parameter 'attachment_id' is set 5981 if ('attachment_id' not in params) or (params['attachment_id'] is None): 5982 raise ValueError("Missing the required parameter `attachment_id` when calling `get_attachment`") 5983 # verify the required parameter 'envelope_id' is set 5984 if ('envelope_id' not in params) or (params['envelope_id'] is None): 5985 raise ValueError("Missing the required parameter `envelope_id` when calling `get_attachment`") 5986 5987 5988 collection_formats = {} 5989 5990 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments/{attachmentId}'.replace('{format}', 'json') 5991 path_params = {} 5992 if 'account_id' in params: 5993 path_params['accountId'] = params['account_id'] 5994 if 'attachment_id' in params: 5995 path_params['attachmentId'] = params['attachment_id'] 5996 if 'envelope_id' in params: 5997 path_params['envelopeId'] = params['envelope_id'] 5998 5999 query_params = {} 6000 6001 header_params = {} 6002 6003 form_params = [] 6004 local_var_files = {} 6005 6006 body_params = None 6007 # HTTP header `Accept` 6008 header_params['Accept'] = self.api_client.\ 6009 select_header_accept(['application/json']) 6010 6011 # Authentication setting 6012 auth_settings = [] 6013 6014 return self.api_client.call_api(resource_path, 'GET', 6015 path_params, 6016 query_params, 6017 header_params, 6018 body=body_params, 6019 post_params=form_params, 6020 files=local_var_files, 6021 response_type=None, 6022 auth_settings=auth_settings, 6023 callback=params.get('callback'), 6024 _return_http_data_only=params.get('_return_http_data_only'), 6025 _preload_content=params.get('_preload_content', True), 6026 _request_timeout=params.get('_request_timeout'), 6027 collection_formats=collection_formats) 6028 6029 def get_attachments(self, account_id, envelope_id, **kwargs): 6030 """ 6031 Returns a list of attachments associated with the specified envelope 6032 Returns a list of attachments associated with a specified envelope 6033 This method makes a synchronous HTTP request by default. To make an 6034 asynchronous HTTP request, please define a `callback` function 6035 to be invoked when receiving the response. 6036 >>> def callback_function(response): 6037 >>> pprint(response) 6038 >>> 6039 >>> thread = api.get_attachments(account_id, envelope_id, callback=callback_function) 6040 6041 :param callback function: The callback function 6042 for asynchronous request. (optional) 6043 :param str account_id: The external account number (int) or account ID Guid. (required) 6044 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6045 :return: EnvelopeAttachmentsResult 6046 If the method is called asynchronously, 6047 returns the request thread. 6048 """ 6049 kwargs['_return_http_data_only'] = True 6050 if kwargs.get('callback'): 6051 return self.get_attachments_with_http_info(account_id, envelope_id, **kwargs) 6052 else: 6053 (data) = self.get_attachments_with_http_info(account_id, envelope_id, **kwargs) 6054 return data 6055 6056 def get_attachments_with_http_info(self, account_id, envelope_id, **kwargs): 6057 """ 6058 Returns a list of attachments associated with the specified envelope 6059 Returns a list of attachments associated with a specified envelope 6060 This method makes a synchronous HTTP request by default. To make an 6061 asynchronous HTTP request, please define a `callback` function 6062 to be invoked when receiving the response. 6063 >>> def callback_function(response): 6064 >>> pprint(response) 6065 >>> 6066 >>> thread = api.get_attachments_with_http_info(account_id, envelope_id, callback=callback_function) 6067 6068 :param callback function: The callback function 6069 for asynchronous request. (optional) 6070 :param str account_id: The external account number (int) or account ID Guid. (required) 6071 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6072 :return: EnvelopeAttachmentsResult 6073 If the method is called asynchronously, 6074 returns the request thread. 6075 """ 6076 6077 all_params = ['account_id', 'envelope_id'] 6078 all_params.append('callback') 6079 all_params.append('_return_http_data_only') 6080 all_params.append('_preload_content') 6081 all_params.append('_request_timeout') 6082 6083 params = locals() 6084 for key, val in iteritems(params['kwargs']): 6085 if key not in all_params: 6086 raise TypeError( 6087 "Got an unexpected keyword argument '%s'" 6088 " to method get_attachments" % key 6089 ) 6090 params[key] = val 6091 del params['kwargs'] 6092 # verify the required parameter 'account_id' is set 6093 if ('account_id' not in params) or (params['account_id'] is None): 6094 raise ValueError("Missing the required parameter `account_id` when calling `get_attachments`") 6095 # verify the required parameter 'envelope_id' is set 6096 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6097 raise ValueError("Missing the required parameter `envelope_id` when calling `get_attachments`") 6098 6099 6100 collection_formats = {} 6101 6102 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments'.replace('{format}', 'json') 6103 path_params = {} 6104 if 'account_id' in params: 6105 path_params['accountId'] = params['account_id'] 6106 if 'envelope_id' in params: 6107 path_params['envelopeId'] = params['envelope_id'] 6108 6109 query_params = {} 6110 6111 header_params = {} 6112 6113 form_params = [] 6114 local_var_files = {} 6115 6116 body_params = None 6117 # HTTP header `Accept` 6118 header_params['Accept'] = self.api_client.\ 6119 select_header_accept(['application/json']) 6120 6121 # Authentication setting 6122 auth_settings = [] 6123 6124 return self.api_client.call_api(resource_path, 'GET', 6125 path_params, 6126 query_params, 6127 header_params, 6128 body=body_params, 6129 post_params=form_params, 6130 files=local_var_files, 6131 response_type='EnvelopeAttachmentsResult', 6132 auth_settings=auth_settings, 6133 callback=params.get('callback'), 6134 _return_http_data_only=params.get('_return_http_data_only'), 6135 _preload_content=params.get('_preload_content', True), 6136 _request_timeout=params.get('_request_timeout'), 6137 collection_formats=collection_formats) 6138 6139 def get_chunked_upload(self, account_id, chunked_upload_id, **kwargs): 6140 """ 6141 Retrieves the current metadata of a ChunkedUpload. 6142 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. 6143 This method makes a synchronous HTTP request by default. To make an 6144 asynchronous HTTP request, please define a `callback` function 6145 to be invoked when receiving the response. 6146 >>> def callback_function(response): 6147 >>> pprint(response) 6148 >>> 6149 >>> thread = api.get_chunked_upload(account_id, chunked_upload_id, callback=callback_function) 6150 6151 :param callback function: The callback function 6152 for asynchronous request. (optional) 6153 :param str account_id: The external account number (int) or account ID Guid. (required) 6154 :param str chunked_upload_id: (required) 6155 :param str include: 6156 :return: ChunkedUploadResponse 6157 If the method is called asynchronously, 6158 returns the request thread. 6159 """ 6160 kwargs['_return_http_data_only'] = True 6161 if kwargs.get('callback'): 6162 return self.get_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 6163 else: 6164 (data) = self.get_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 6165 return data 6166 6167 def get_chunked_upload_with_http_info(self, account_id, chunked_upload_id, **kwargs): 6168 """ 6169 Retrieves the current metadata of a ChunkedUpload. 6170 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. 6171 This method makes a synchronous HTTP request by default. To make an 6172 asynchronous HTTP request, please define a `callback` function 6173 to be invoked when receiving the response. 6174 >>> def callback_function(response): 6175 >>> pprint(response) 6176 >>> 6177 >>> thread = api.get_chunked_upload_with_http_info(account_id, chunked_upload_id, callback=callback_function) 6178 6179 :param callback function: The callback function 6180 for asynchronous request. (optional) 6181 :param str account_id: The external account number (int) or account ID Guid. (required) 6182 :param str chunked_upload_id: (required) 6183 :param str include: 6184 :return: ChunkedUploadResponse 6185 If the method is called asynchronously, 6186 returns the request thread. 6187 """ 6188 6189 all_params = ['account_id', 'chunked_upload_id', 'include'] 6190 all_params.append('callback') 6191 all_params.append('_return_http_data_only') 6192 all_params.append('_preload_content') 6193 all_params.append('_request_timeout') 6194 6195 params = locals() 6196 for key, val in iteritems(params['kwargs']): 6197 if key not in all_params: 6198 raise TypeError( 6199 "Got an unexpected keyword argument '%s'" 6200 " to method get_chunked_upload" % key 6201 ) 6202 params[key] = val 6203 del params['kwargs'] 6204 # verify the required parameter 'account_id' is set 6205 if ('account_id' not in params) or (params['account_id'] is None): 6206 raise ValueError("Missing the required parameter `account_id` when calling `get_chunked_upload`") 6207 # verify the required parameter 'chunked_upload_id' is set 6208 if ('chunked_upload_id' not in params) or (params['chunked_upload_id'] is None): 6209 raise ValueError("Missing the required parameter `chunked_upload_id` when calling `get_chunked_upload`") 6210 6211 6212 collection_formats = {} 6213 6214 resource_path = '/v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}'.replace('{format}', 'json') 6215 path_params = {} 6216 if 'account_id' in params: 6217 path_params['accountId'] = params['account_id'] 6218 if 'chunked_upload_id' in params: 6219 path_params['chunkedUploadId'] = params['chunked_upload_id'] 6220 6221 query_params = {} 6222 if 'include' in params: 6223 query_params['include'] = params['include'] 6224 6225 header_params = {} 6226 6227 form_params = [] 6228 local_var_files = {} 6229 6230 body_params = None 6231 # HTTP header `Accept` 6232 header_params['Accept'] = self.api_client.\ 6233 select_header_accept(['application/json']) 6234 6235 # Authentication setting 6236 auth_settings = [] 6237 6238 return self.api_client.call_api(resource_path, 'GET', 6239 path_params, 6240 query_params, 6241 header_params, 6242 body=body_params, 6243 post_params=form_params, 6244 files=local_var_files, 6245 response_type='ChunkedUploadResponse', 6246 auth_settings=auth_settings, 6247 callback=params.get('callback'), 6248 _return_http_data_only=params.get('_return_http_data_only'), 6249 _preload_content=params.get('_preload_content', True), 6250 _request_timeout=params.get('_request_timeout'), 6251 collection_formats=collection_formats) 6252 6253 def get_comments_transcript(self, account_id, envelope_id, **kwargs): 6254 """ 6255 Gets comment transcript for envelope and user 6256 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**). 6257 This method makes a synchronous HTTP request by default. To make an 6258 asynchronous HTTP request, please define a `callback` function 6259 to be invoked when receiving the response. 6260 >>> def callback_function(response): 6261 >>> pprint(response) 6262 >>> 6263 >>> thread = api.get_comments_transcript(account_id, envelope_id, callback=callback_function) 6264 6265 :param callback function: The callback function 6266 for asynchronous request. (optional) 6267 :param str account_id: The external account number (int) or account ID Guid. (required) 6268 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6269 :param str encoding: 6270 :return: file 6271 If the method is called asynchronously, 6272 returns the request thread. 6273 """ 6274 kwargs['_return_http_data_only'] = True 6275 if kwargs.get('callback'): 6276 return self.get_comments_transcript_with_http_info(account_id, envelope_id, **kwargs) 6277 else: 6278 (data) = self.get_comments_transcript_with_http_info(account_id, envelope_id, **kwargs) 6279 return data 6280 6281 def get_comments_transcript_with_http_info(self, account_id, envelope_id, **kwargs): 6282 """ 6283 Gets comment transcript for envelope and user 6284 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**). 6285 This method makes a synchronous HTTP request by default. To make an 6286 asynchronous HTTP request, please define a `callback` function 6287 to be invoked when receiving the response. 6288 >>> def callback_function(response): 6289 >>> pprint(response) 6290 >>> 6291 >>> thread = api.get_comments_transcript_with_http_info(account_id, envelope_id, callback=callback_function) 6292 6293 :param callback function: The callback function 6294 for asynchronous request. (optional) 6295 :param str account_id: The external account number (int) or account ID Guid. (required) 6296 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6297 :param str encoding: 6298 :return: file 6299 If the method is called asynchronously, 6300 returns the request thread. 6301 """ 6302 6303 all_params = ['account_id', 'envelope_id', 'encoding'] 6304 all_params.append('callback') 6305 all_params.append('_return_http_data_only') 6306 all_params.append('_preload_content') 6307 all_params.append('_request_timeout') 6308 6309 params = locals() 6310 for key, val in iteritems(params['kwargs']): 6311 if key not in all_params: 6312 raise TypeError( 6313 "Got an unexpected keyword argument '%s'" 6314 " to method get_comments_transcript" % key 6315 ) 6316 params[key] = val 6317 del params['kwargs'] 6318 # verify the required parameter 'account_id' is set 6319 if ('account_id' not in params) or (params['account_id'] is None): 6320 raise ValueError("Missing the required parameter `account_id` when calling `get_comments_transcript`") 6321 # verify the required parameter 'envelope_id' is set 6322 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6323 raise ValueError("Missing the required parameter `envelope_id` when calling `get_comments_transcript`") 6324 6325 6326 collection_formats = {} 6327 6328 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/comments/transcript'.replace('{format}', 'json') 6329 path_params = {} 6330 if 'account_id' in params: 6331 path_params['accountId'] = params['account_id'] 6332 if 'envelope_id' in params: 6333 path_params['envelopeId'] = params['envelope_id'] 6334 6335 query_params = {} 6336 if 'encoding' in params: 6337 query_params['encoding'] = params['encoding'] 6338 6339 header_params = {} 6340 6341 form_params = [] 6342 local_var_files = {} 6343 6344 body_params = None 6345 # HTTP header `Accept` 6346 header_params['Accept'] = self.api_client.\ 6347 select_header_accept(['application/pdf']) 6348 6349 # Authentication setting 6350 auth_settings = [] 6351 6352 return self.api_client.call_api(resource_path, 'GET', 6353 path_params, 6354 query_params, 6355 header_params, 6356 body=body_params, 6357 post_params=form_params, 6358 files=local_var_files, 6359 response_type='file', 6360 auth_settings=auth_settings, 6361 callback=params.get('callback'), 6362 _return_http_data_only=params.get('_return_http_data_only'), 6363 _preload_content=params.get('_preload_content', True), 6364 _request_timeout=params.get('_request_timeout'), 6365 collection_formats=collection_formats) 6366 6367 def get_consumer_disclosure(self, account_id, envelope_id, lang_code, recipient_id, **kwargs): 6368 """ 6369 Reserved: Gets the Electronic Record and Signature Disclosure associated with the account. 6370 Reserved: Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, associated with the account. 6371 This method makes a synchronous HTTP request by default. To make an 6372 asynchronous HTTP request, please define a `callback` function 6373 to be invoked when receiving the response. 6374 >>> def callback_function(response): 6375 >>> pprint(response) 6376 >>> 6377 >>> thread = api.get_consumer_disclosure(account_id, envelope_id, lang_code, recipient_id, callback=callback_function) 6378 6379 :param callback function: The callback function 6380 for asynchronous request. (optional) 6381 :param str account_id: The external account number (int) or account ID Guid. (required) 6382 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6383 :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), 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) 6384 :param str recipient_id: The ID of the recipient being accessed. (required) 6385 :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. 6386 :return: ConsumerDisclosure 6387 If the method is called asynchronously, 6388 returns the request thread. 6389 """ 6390 kwargs['_return_http_data_only'] = True 6391 if kwargs.get('callback'): 6392 return self.get_consumer_disclosure_with_http_info(account_id, envelope_id, lang_code, recipient_id, **kwargs) 6393 else: 6394 (data) = self.get_consumer_disclosure_with_http_info(account_id, envelope_id, lang_code, recipient_id, **kwargs) 6395 return data 6396 6397 def get_consumer_disclosure_with_http_info(self, account_id, envelope_id, lang_code, recipient_id, **kwargs): 6398 """ 6399 Reserved: Gets the Electronic Record and Signature Disclosure associated with the account. 6400 Reserved: Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, associated with the account. 6401 This method makes a synchronous HTTP request by default. To make an 6402 asynchronous HTTP request, please define a `callback` function 6403 to be invoked when receiving the response. 6404 >>> def callback_function(response): 6405 >>> pprint(response) 6406 >>> 6407 >>> thread = api.get_consumer_disclosure_with_http_info(account_id, envelope_id, lang_code, recipient_id, callback=callback_function) 6408 6409 :param callback function: The callback function 6410 for asynchronous request. (optional) 6411 :param str account_id: The external account number (int) or account ID Guid. (required) 6412 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6413 :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), 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) 6414 :param str recipient_id: The ID of the recipient being accessed. (required) 6415 :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. 6416 :return: ConsumerDisclosure 6417 If the method is called asynchronously, 6418 returns the request thread. 6419 """ 6420 6421 all_params = ['account_id', 'envelope_id', 'lang_code', 'recipient_id', 'lang_code2'] 6422 all_params.append('callback') 6423 all_params.append('_return_http_data_only') 6424 all_params.append('_preload_content') 6425 all_params.append('_request_timeout') 6426 6427 params = locals() 6428 for key, val in iteritems(params['kwargs']): 6429 if key not in all_params: 6430 raise TypeError( 6431 "Got an unexpected keyword argument '%s'" 6432 " to method get_consumer_disclosure" % key 6433 ) 6434 params[key] = val 6435 del params['kwargs'] 6436 # verify the required parameter 'account_id' is set 6437 if ('account_id' not in params) or (params['account_id'] is None): 6438 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure`") 6439 # verify the required parameter 'envelope_id' is set 6440 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6441 raise ValueError("Missing the required parameter `envelope_id` when calling `get_consumer_disclosure`") 6442 # verify the required parameter 'lang_code' is set 6443 if ('lang_code' not in params) or (params['lang_code'] is None): 6444 raise ValueError("Missing the required parameter `lang_code` when calling `get_consumer_disclosure`") 6445 # verify the required parameter 'recipient_id' is set 6446 if ('recipient_id' not in params) or (params['recipient_id'] is None): 6447 raise ValueError("Missing the required parameter `recipient_id` when calling `get_consumer_disclosure`") 6448 6449 6450 collection_formats = {} 6451 6452 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 6453 path_params = {} 6454 if 'account_id' in params: 6455 path_params['accountId'] = params['account_id'] 6456 if 'envelope_id' in params: 6457 path_params['envelopeId'] = params['envelope_id'] 6458 if 'lang_code' in params: 6459 path_params['langCode'] = params['lang_code'] 6460 if 'recipient_id' in params: 6461 path_params['recipientId'] = params['recipient_id'] 6462 6463 query_params = {} 6464 if 'lang_code2' in params: 6465 query_params['langCode'] = params['lang_code2'] 6466 6467 header_params = {} 6468 6469 form_params = [] 6470 local_var_files = {} 6471 6472 body_params = None 6473 # HTTP header `Accept` 6474 header_params['Accept'] = self.api_client.\ 6475 select_header_accept(['application/json']) 6476 6477 # Authentication setting 6478 auth_settings = [] 6479 6480 return self.api_client.call_api(resource_path, 'GET', 6481 path_params, 6482 query_params, 6483 header_params, 6484 body=body_params, 6485 post_params=form_params, 6486 files=local_var_files, 6487 response_type='ConsumerDisclosure', 6488 auth_settings=auth_settings, 6489 callback=params.get('callback'), 6490 _return_http_data_only=params.get('_return_http_data_only'), 6491 _preload_content=params.get('_preload_content', True), 6492 _request_timeout=params.get('_request_timeout'), 6493 collection_formats=collection_formats) 6494 6495 def get_consumer_disclosure_default(self, account_id, envelope_id, recipient_id, **kwargs): 6496 """ 6497 Gets the Electronic Record and Signature Disclosure associated with the account. 6498 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. 6499 This method makes a synchronous HTTP request by default. To make an 6500 asynchronous HTTP request, please define a `callback` function 6501 to be invoked when receiving the response. 6502 >>> def callback_function(response): 6503 >>> pprint(response) 6504 >>> 6505 >>> thread = api.get_consumer_disclosure_default(account_id, envelope_id, recipient_id, callback=callback_function) 6506 6507 :param callback function: The callback function 6508 for asynchronous request. (optional) 6509 :param str account_id: The external account number (int) or account ID Guid. (required) 6510 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6511 :param str recipient_id: The ID of the recipient being accessed. (required) 6512 :param str lang_code: 6513 :return: ConsumerDisclosure 6514 If the method is called asynchronously, 6515 returns the request thread. 6516 """ 6517 kwargs['_return_http_data_only'] = True 6518 if kwargs.get('callback'): 6519 return self.get_consumer_disclosure_default_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 6520 else: 6521 (data) = self.get_consumer_disclosure_default_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 6522 return data 6523 6524 def get_consumer_disclosure_default_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 6525 """ 6526 Gets the Electronic Record and Signature Disclosure associated with the account. 6527 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. 6528 This method makes a synchronous HTTP request by default. To make an 6529 asynchronous HTTP request, please define a `callback` function 6530 to be invoked when receiving the response. 6531 >>> def callback_function(response): 6532 >>> pprint(response) 6533 >>> 6534 >>> thread = api.get_consumer_disclosure_default_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 6535 6536 :param callback function: The callback function 6537 for asynchronous request. (optional) 6538 :param str account_id: The external account number (int) or account ID Guid. (required) 6539 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6540 :param str recipient_id: The ID of the recipient being accessed. (required) 6541 :param str lang_code: 6542 :return: ConsumerDisclosure 6543 If the method is called asynchronously, 6544 returns the request thread. 6545 """ 6546 6547 all_params = ['account_id', 'envelope_id', 'recipient_id', 'lang_code'] 6548 all_params.append('callback') 6549 all_params.append('_return_http_data_only') 6550 all_params.append('_preload_content') 6551 all_params.append('_request_timeout') 6552 6553 params = locals() 6554 for key, val in iteritems(params['kwargs']): 6555 if key not in all_params: 6556 raise TypeError( 6557 "Got an unexpected keyword argument '%s'" 6558 " to method get_consumer_disclosure_default" % key 6559 ) 6560 params[key] = val 6561 del params['kwargs'] 6562 # verify the required parameter 'account_id' is set 6563 if ('account_id' not in params) or (params['account_id'] is None): 6564 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure_default`") 6565 # verify the required parameter 'envelope_id' is set 6566 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6567 raise ValueError("Missing the required parameter `envelope_id` when calling `get_consumer_disclosure_default`") 6568 # verify the required parameter 'recipient_id' is set 6569 if ('recipient_id' not in params) or (params['recipient_id'] is None): 6570 raise ValueError("Missing the required parameter `recipient_id` when calling `get_consumer_disclosure_default`") 6571 6572 6573 collection_formats = {} 6574 6575 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/consumer_disclosure'.replace('{format}', 'json') 6576 path_params = {} 6577 if 'account_id' in params: 6578 path_params['accountId'] = params['account_id'] 6579 if 'envelope_id' in params: 6580 path_params['envelopeId'] = params['envelope_id'] 6581 if 'recipient_id' in params: 6582 path_params['recipientId'] = params['recipient_id'] 6583 6584 query_params = {} 6585 if 'lang_code' in params: 6586 query_params['langCode'] = params['lang_code'] 6587 6588 header_params = {} 6589 6590 form_params = [] 6591 local_var_files = {} 6592 6593 body_params = None 6594 # HTTP header `Accept` 6595 header_params['Accept'] = self.api_client.\ 6596 select_header_accept(['application/json']) 6597 6598 # Authentication setting 6599 auth_settings = [] 6600 6601 return self.api_client.call_api(resource_path, 'GET', 6602 path_params, 6603 query_params, 6604 header_params, 6605 body=body_params, 6606 post_params=form_params, 6607 files=local_var_files, 6608 response_type='ConsumerDisclosure', 6609 auth_settings=auth_settings, 6610 callback=params.get('callback'), 6611 _return_http_data_only=params.get('_return_http_data_only'), 6612 _preload_content=params.get('_preload_content', True), 6613 _request_timeout=params.get('_request_timeout'), 6614 collection_formats=collection_formats) 6615 6616 def get_document(self, account_id, document_id, envelope_id, **kwargs): 6617 """ 6618 Gets a document from an envelope. 6619 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 6620 This method makes a synchronous HTTP request by default. To make an 6621 asynchronous HTTP request, please define a `callback` function 6622 to be invoked when receiving the response. 6623 >>> def callback_function(response): 6624 >>> pprint(response) 6625 >>> 6626 >>> thread = api.get_document(account_id, document_id, envelope_id, callback=callback_function) 6627 6628 :param callback function: The callback function 6629 for asynchronous request. (optional) 6630 :param str account_id: The external account number (int) or account ID Guid. (required) 6631 :param str document_id: The ID of the document being accessed. (required) 6632 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6633 :param str certificate: When set to **false**, the envelope signing certificate is removed from the download. 6634 :param str documents_by_userid: 6635 :param str encoding: 6636 :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. 6637 :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). 6638 :param str recipient_id: 6639 :param str shared_user_id: 6640 :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. 6641 :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. 6642 :return: file 6643 If the method is called asynchronously, 6644 returns the request thread. 6645 """ 6646 kwargs['_return_http_data_only'] = True 6647 if kwargs.get('callback'): 6648 return self.get_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 6649 else: 6650 (data) = self.get_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 6651 return data 6652 6653 def get_document_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 6654 """ 6655 Gets a document from an envelope. 6656 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 6657 This method makes a synchronous HTTP request by default. To make an 6658 asynchronous HTTP request, please define a `callback` function 6659 to be invoked when receiving the response. 6660 >>> def callback_function(response): 6661 >>> pprint(response) 6662 >>> 6663 >>> thread = api.get_document_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 6664 6665 :param callback function: The callback function 6666 for asynchronous request. (optional) 6667 :param str account_id: The external account number (int) or account ID Guid. (required) 6668 :param str document_id: The ID of the document being accessed. (required) 6669 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6670 :param str certificate: When set to **false**, the envelope signing certificate is removed from the download. 6671 :param str documents_by_userid: 6672 :param str encoding: 6673 :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. 6674 :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). 6675 :param str recipient_id: 6676 :param str shared_user_id: 6677 :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. 6678 :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. 6679 :return: file 6680 If the method is called asynchronously, 6681 returns the request thread. 6682 """ 6683 6684 all_params = ['account_id', 'document_id', 'envelope_id', 'certificate', 'documents_by_userid', 'encoding', 'encrypt', 'language', 'recipient_id', 'shared_user_id', 'show_changes', 'watermark'] 6685 all_params.append('callback') 6686 all_params.append('_return_http_data_only') 6687 all_params.append('_preload_content') 6688 all_params.append('_request_timeout') 6689 6690 params = locals() 6691 for key, val in iteritems(params['kwargs']): 6692 if key not in all_params: 6693 raise TypeError( 6694 "Got an unexpected keyword argument '%s'" 6695 " to method get_document" % key 6696 ) 6697 params[key] = val 6698 del params['kwargs'] 6699 # verify the required parameter 'account_id' is set 6700 if ('account_id' not in params) or (params['account_id'] is None): 6701 raise ValueError("Missing the required parameter `account_id` when calling `get_document`") 6702 # verify the required parameter 'document_id' is set 6703 if ('document_id' not in params) or (params['document_id'] is None): 6704 raise ValueError("Missing the required parameter `document_id` when calling `get_document`") 6705 # verify the required parameter 'envelope_id' is set 6706 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6707 raise ValueError("Missing the required parameter `envelope_id` when calling `get_document`") 6708 6709 6710 collection_formats = {} 6711 6712 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}'.replace('{format}', 'json') 6713 path_params = {} 6714 if 'account_id' in params: 6715 path_params['accountId'] = params['account_id'] 6716 if 'document_id' in params: 6717 path_params['documentId'] = params['document_id'] 6718 if 'envelope_id' in params: 6719 path_params['envelopeId'] = params['envelope_id'] 6720 6721 query_params = {} 6722 if 'certificate' in params: 6723 query_params['certificate'] = params['certificate'] 6724 if 'documents_by_userid' in params: 6725 query_params['documents_by_userid'] = params['documents_by_userid'] 6726 if 'encoding' in params: 6727 query_params['encoding'] = params['encoding'] 6728 if 'encrypt' in params: 6729 query_params['encrypt'] = params['encrypt'] 6730 if 'language' in params: 6731 query_params['language'] = params['language'] 6732 if 'recipient_id' in params: 6733 query_params['recipient_id'] = params['recipient_id'] 6734 if 'shared_user_id' in params: 6735 query_params['shared_user_id'] = params['shared_user_id'] 6736 if 'show_changes' in params: 6737 query_params['show_changes'] = params['show_changes'] 6738 if 'watermark' in params: 6739 query_params['watermark'] = params['watermark'] 6740 6741 header_params = {} 6742 6743 form_params = [] 6744 local_var_files = {} 6745 6746 body_params = None 6747 # HTTP header `Accept` 6748 header_params['Accept'] = self.api_client.\ 6749 select_header_accept(['application/pdf']) 6750 6751 # Authentication setting 6752 auth_settings = [] 6753 6754 return self.api_client.call_api(resource_path, 'GET', 6755 path_params, 6756 query_params, 6757 header_params, 6758 body=body_params, 6759 post_params=form_params, 6760 files=local_var_files, 6761 response_type='file', 6762 auth_settings=auth_settings, 6763 callback=params.get('callback'), 6764 _return_http_data_only=params.get('_return_http_data_only'), 6765 _preload_content=params.get('_preload_content', True), 6766 _request_timeout=params.get('_request_timeout'), 6767 collection_formats=collection_formats) 6768 6769 def get_document_page_image(self, account_id, document_id, envelope_id, page_number, **kwargs): 6770 """ 6771 Gets a page image from an envelope for display. 6772 Retrieves a page image for display from the specified envelope. 6773 This method makes a synchronous HTTP request by default. To make an 6774 asynchronous HTTP request, please define a `callback` function 6775 to be invoked when receiving the response. 6776 >>> def callback_function(response): 6777 >>> pprint(response) 6778 >>> 6779 >>> thread = api.get_document_page_image(account_id, document_id, envelope_id, page_number, callback=callback_function) 6780 6781 :param callback function: The callback function 6782 for asynchronous request. (optional) 6783 :param str account_id: The external account number (int) or account ID Guid. (required) 6784 :param str document_id: The ID of the document being accessed. (required) 6785 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6786 :param str page_number: The page number being accessed. (required) 6787 :param str dpi: Sets the dpi for the image. 6788 :param str max_height: Sets the maximum height for the page image in pixels. The dpi is recalculated based on this setting. 6789 :param str max_width: Sets the maximum width for the page image in pixels. The dpi is recalculated based on this setting. 6790 :param str show_changes: 6791 :return: file 6792 If the method is called asynchronously, 6793 returns the request thread. 6794 """ 6795 kwargs['_return_http_data_only'] = True 6796 if kwargs.get('callback'): 6797 return self.get_document_page_image_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 6798 else: 6799 (data) = self.get_document_page_image_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 6800 return data 6801 6802 def get_document_page_image_with_http_info(self, account_id, document_id, envelope_id, page_number, **kwargs): 6803 """ 6804 Gets a page image from an envelope for display. 6805 Retrieves a page image for display from the specified envelope. 6806 This method makes a synchronous HTTP request by default. To make an 6807 asynchronous HTTP request, please define a `callback` function 6808 to be invoked when receiving the response. 6809 >>> def callback_function(response): 6810 >>> pprint(response) 6811 >>> 6812 >>> thread = api.get_document_page_image_with_http_info(account_id, document_id, envelope_id, page_number, callback=callback_function) 6813 6814 :param callback function: The callback function 6815 for asynchronous request. (optional) 6816 :param str account_id: The external account number (int) or account ID Guid. (required) 6817 :param str document_id: The ID of the document being accessed. (required) 6818 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6819 :param str page_number: The page number being accessed. (required) 6820 :param str dpi: Sets the dpi for the image. 6821 :param str max_height: Sets the maximum height for the page image in pixels. The dpi is recalculated based on this setting. 6822 :param str max_width: Sets the maximum width for the page image in pixels. The dpi is recalculated based on this setting. 6823 :param str show_changes: 6824 :return: file 6825 If the method is called asynchronously, 6826 returns the request thread. 6827 """ 6828 6829 all_params = ['account_id', 'document_id', 'envelope_id', 'page_number', 'dpi', 'max_height', 'max_width', 'show_changes'] 6830 all_params.append('callback') 6831 all_params.append('_return_http_data_only') 6832 all_params.append('_preload_content') 6833 all_params.append('_request_timeout') 6834 6835 params = locals() 6836 for key, val in iteritems(params['kwargs']): 6837 if key not in all_params: 6838 raise TypeError( 6839 "Got an unexpected keyword argument '%s'" 6840 " to method get_document_page_image" % key 6841 ) 6842 params[key] = val 6843 del params['kwargs'] 6844 # verify the required parameter 'account_id' is set 6845 if ('account_id' not in params) or (params['account_id'] is None): 6846 raise ValueError("Missing the required parameter `account_id` when calling `get_document_page_image`") 6847 # verify the required parameter 'document_id' is set 6848 if ('document_id' not in params) or (params['document_id'] is None): 6849 raise ValueError("Missing the required parameter `document_id` when calling `get_document_page_image`") 6850 # verify the required parameter 'envelope_id' is set 6851 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6852 raise ValueError("Missing the required parameter `envelope_id` when calling `get_document_page_image`") 6853 # verify the required parameter 'page_number' is set 6854 if ('page_number' not in params) or (params['page_number'] is None): 6855 raise ValueError("Missing the required parameter `page_number` when calling `get_document_page_image`") 6856 6857 6858 collection_formats = {} 6859 6860 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/pages/{pageNumber}/page_image'.replace('{format}', 'json') 6861 path_params = {} 6862 if 'account_id' in params: 6863 path_params['accountId'] = params['account_id'] 6864 if 'document_id' in params: 6865 path_params['documentId'] = params['document_id'] 6866 if 'envelope_id' in params: 6867 path_params['envelopeId'] = params['envelope_id'] 6868 if 'page_number' in params: 6869 path_params['pageNumber'] = params['page_number'] 6870 6871 query_params = {} 6872 if 'dpi' in params: 6873 query_params['dpi'] = params['dpi'] 6874 if 'max_height' in params: 6875 query_params['max_height'] = params['max_height'] 6876 if 'max_width' in params: 6877 query_params['max_width'] = params['max_width'] 6878 if 'show_changes' in params: 6879 query_params['show_changes'] = params['show_changes'] 6880 6881 header_params = {} 6882 6883 form_params = [] 6884 local_var_files = {} 6885 6886 body_params = None 6887 # HTTP header `Accept` 6888 header_params['Accept'] = self.api_client.\ 6889 select_header_accept(['image/png']) 6890 6891 # Authentication setting 6892 auth_settings = [] 6893 6894 return self.api_client.call_api(resource_path, 'GET', 6895 path_params, 6896 query_params, 6897 header_params, 6898 body=body_params, 6899 post_params=form_params, 6900 files=local_var_files, 6901 response_type='file', 6902 auth_settings=auth_settings, 6903 callback=params.get('callback'), 6904 _return_http_data_only=params.get('_return_http_data_only'), 6905 _preload_content=params.get('_preload_content', True), 6906 _request_timeout=params.get('_request_timeout'), 6907 collection_formats=collection_formats) 6908 6909 def get_document_tabs(self, account_id, document_id, envelope_id, **kwargs): 6910 """ 6911 Returns tabs on the document. 6912 Returns the tabs on the document specified by `documentId` in the envelope specified by `envelopeId`. 6913 This method makes a synchronous HTTP request by default. To make an 6914 asynchronous HTTP request, please define a `callback` function 6915 to be invoked when receiving the response. 6916 >>> def callback_function(response): 6917 >>> pprint(response) 6918 >>> 6919 >>> thread = api.get_document_tabs(account_id, document_id, envelope_id, callback=callback_function) 6920 6921 :param callback function: The callback function 6922 for asynchronous request. (optional) 6923 :param str account_id: The external account number (int) or account ID Guid. (required) 6924 :param str document_id: The ID of the document being accessed. (required) 6925 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6926 :param str include_metadata: 6927 :param str page_numbers: 6928 :return: Tabs 6929 If the method is called asynchronously, 6930 returns the request thread. 6931 """ 6932 kwargs['_return_http_data_only'] = True 6933 if kwargs.get('callback'): 6934 return self.get_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 6935 else: 6936 (data) = self.get_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 6937 return data 6938 6939 def get_document_tabs_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 6940 """ 6941 Returns tabs on the document. 6942 Returns the tabs on the document specified by `documentId` in the envelope specified by `envelopeId`. 6943 This method makes a synchronous HTTP request by default. To make an 6944 asynchronous HTTP request, please define a `callback` function 6945 to be invoked when receiving the response. 6946 >>> def callback_function(response): 6947 >>> pprint(response) 6948 >>> 6949 >>> thread = api.get_document_tabs_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 6950 6951 :param callback function: The callback function 6952 for asynchronous request. (optional) 6953 :param str account_id: The external account number (int) or account ID Guid. (required) 6954 :param str document_id: The ID of the document being accessed. (required) 6955 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6956 :param str include_metadata: 6957 :param str page_numbers: 6958 :return: Tabs 6959 If the method is called asynchronously, 6960 returns the request thread. 6961 """ 6962 6963 all_params = ['account_id', 'document_id', 'envelope_id', 'include_metadata', 'page_numbers'] 6964 all_params.append('callback') 6965 all_params.append('_return_http_data_only') 6966 all_params.append('_preload_content') 6967 all_params.append('_request_timeout') 6968 6969 params = locals() 6970 for key, val in iteritems(params['kwargs']): 6971 if key not in all_params: 6972 raise TypeError( 6973 "Got an unexpected keyword argument '%s'" 6974 " to method get_document_tabs" % key 6975 ) 6976 params[key] = val 6977 del params['kwargs'] 6978 # verify the required parameter 'account_id' is set 6979 if ('account_id' not in params) or (params['account_id'] is None): 6980 raise ValueError("Missing the required parameter `account_id` when calling `get_document_tabs`") 6981 # verify the required parameter 'document_id' is set 6982 if ('document_id' not in params) or (params['document_id'] is None): 6983 raise ValueError("Missing the required parameter `document_id` when calling `get_document_tabs`") 6984 # verify the required parameter 'envelope_id' is set 6985 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6986 raise ValueError("Missing the required parameter `envelope_id` when calling `get_document_tabs`") 6987 6988 6989 collection_formats = {} 6990 6991 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/tabs'.replace('{format}', 'json') 6992 path_params = {} 6993 if 'account_id' in params: 6994 path_params['accountId'] = params['account_id'] 6995 if 'document_id' in params: 6996 path_params['documentId'] = params['document_id'] 6997 if 'envelope_id' in params: 6998 path_params['envelopeId'] = params['envelope_id'] 6999 7000 query_params = {} 7001 if 'include_metadata' in params: 7002 query_params['include_metadata'] = params['include_metadata'] 7003 if 'page_numbers' in params: 7004 query_params['page_numbers'] = params['page_numbers'] 7005 7006 header_params = {} 7007 7008 form_params = [] 7009 local_var_files = {} 7010 7011 body_params = None 7012 # HTTP header `Accept` 7013 header_params['Accept'] = self.api_client.\ 7014 select_header_accept(['application/json']) 7015 7016 # Authentication setting 7017 auth_settings = [] 7018 7019 return self.api_client.call_api(resource_path, 'GET', 7020 path_params, 7021 query_params, 7022 header_params, 7023 body=body_params, 7024 post_params=form_params, 7025 files=local_var_files, 7026 response_type='Tabs', 7027 auth_settings=auth_settings, 7028 callback=params.get('callback'), 7029 _return_http_data_only=params.get('_return_http_data_only'), 7030 _preload_content=params.get('_preload_content', True), 7031 _request_timeout=params.get('_request_timeout'), 7032 collection_formats=collection_formats) 7033 7034 def get_email_settings(self, account_id, envelope_id, **kwargs): 7035 """ 7036 Gets the email setting overrides for an envelope. 7037 Retrieves the email override settings for the specified envelope. 7038 This method makes a synchronous HTTP request by default. To make an 7039 asynchronous HTTP request, please define a `callback` function 7040 to be invoked when receiving the response. 7041 >>> def callback_function(response): 7042 >>> pprint(response) 7043 >>> 7044 >>> thread = api.get_email_settings(account_id, envelope_id, callback=callback_function) 7045 7046 :param callback function: The callback function 7047 for asynchronous request. (optional) 7048 :param str account_id: The external account number (int) or account ID Guid. (required) 7049 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7050 :return: EmailSettings 7051 If the method is called asynchronously, 7052 returns the request thread. 7053 """ 7054 kwargs['_return_http_data_only'] = True 7055 if kwargs.get('callback'): 7056 return self.get_email_settings_with_http_info(account_id, envelope_id, **kwargs) 7057 else: 7058 (data) = self.get_email_settings_with_http_info(account_id, envelope_id, **kwargs) 7059 return data 7060 7061 def get_email_settings_with_http_info(self, account_id, envelope_id, **kwargs): 7062 """ 7063 Gets the email setting overrides for an envelope. 7064 Retrieves the email override settings for the specified envelope. 7065 This method makes a synchronous HTTP request by default. To make an 7066 asynchronous HTTP request, please define a `callback` function 7067 to be invoked when receiving the response. 7068 >>> def callback_function(response): 7069 >>> pprint(response) 7070 >>> 7071 >>> thread = api.get_email_settings_with_http_info(account_id, envelope_id, callback=callback_function) 7072 7073 :param callback function: The callback function 7074 for asynchronous request. (optional) 7075 :param str account_id: The external account number (int) or account ID Guid. (required) 7076 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7077 :return: EmailSettings 7078 If the method is called asynchronously, 7079 returns the request thread. 7080 """ 7081 7082 all_params = ['account_id', 'envelope_id'] 7083 all_params.append('callback') 7084 all_params.append('_return_http_data_only') 7085 all_params.append('_preload_content') 7086 all_params.append('_request_timeout') 7087 7088 params = locals() 7089 for key, val in iteritems(params['kwargs']): 7090 if key not in all_params: 7091 raise TypeError( 7092 "Got an unexpected keyword argument '%s'" 7093 " to method get_email_settings" % key 7094 ) 7095 params[key] = val 7096 del params['kwargs'] 7097 # verify the required parameter 'account_id' is set 7098 if ('account_id' not in params) or (params['account_id'] is None): 7099 raise ValueError("Missing the required parameter `account_id` when calling `get_email_settings`") 7100 # verify the required parameter 'envelope_id' is set 7101 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7102 raise ValueError("Missing the required parameter `envelope_id` when calling `get_email_settings`") 7103 7104 7105 collection_formats = {} 7106 7107 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/email_settings'.replace('{format}', 'json') 7108 path_params = {} 7109 if 'account_id' in params: 7110 path_params['accountId'] = params['account_id'] 7111 if 'envelope_id' in params: 7112 path_params['envelopeId'] = params['envelope_id'] 7113 7114 query_params = {} 7115 7116 header_params = {} 7117 7118 form_params = [] 7119 local_var_files = {} 7120 7121 body_params = None 7122 # HTTP header `Accept` 7123 header_params['Accept'] = self.api_client.\ 7124 select_header_accept(['application/json']) 7125 7126 # Authentication setting 7127 auth_settings = [] 7128 7129 return self.api_client.call_api(resource_path, 'GET', 7130 path_params, 7131 query_params, 7132 header_params, 7133 body=body_params, 7134 post_params=form_params, 7135 files=local_var_files, 7136 response_type='EmailSettings', 7137 auth_settings=auth_settings, 7138 callback=params.get('callback'), 7139 _return_http_data_only=params.get('_return_http_data_only'), 7140 _preload_content=params.get('_preload_content', True), 7141 _request_timeout=params.get('_request_timeout'), 7142 collection_formats=collection_formats) 7143 7144 def get_envelope(self, account_id, envelope_id, **kwargs): 7145 """ 7146 Gets the status of a envelope. 7147 Retrieves the overall status for the specified envelope. 7148 This method makes a synchronous HTTP request by default. To make an 7149 asynchronous HTTP request, please define a `callback` function 7150 to be invoked when receiving the response. 7151 >>> def callback_function(response): 7152 >>> pprint(response) 7153 >>> 7154 >>> thread = api.get_envelope(account_id, envelope_id, callback=callback_function) 7155 7156 :param callback function: The callback function 7157 for asynchronous request. (optional) 7158 :param str account_id: The external account number (int) or account ID Guid. (required) 7159 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7160 :param str advanced_update: When true, envelope information can be added or modified. 7161 :param str include: 7162 :return: Envelope 7163 If the method is called asynchronously, 7164 returns the request thread. 7165 """ 7166 kwargs['_return_http_data_only'] = True 7167 if kwargs.get('callback'): 7168 return self.get_envelope_with_http_info(account_id, envelope_id, **kwargs) 7169 else: 7170 (data) = self.get_envelope_with_http_info(account_id, envelope_id, **kwargs) 7171 return data 7172 7173 def get_envelope_with_http_info(self, account_id, envelope_id, **kwargs): 7174 """ 7175 Gets the status of a envelope. 7176 Retrieves the overall status for the specified envelope. 7177 This method makes a synchronous HTTP request by default. To make an 7178 asynchronous HTTP request, please define a `callback` function 7179 to be invoked when receiving the response. 7180 >>> def callback_function(response): 7181 >>> pprint(response) 7182 >>> 7183 >>> thread = api.get_envelope_with_http_info(account_id, envelope_id, callback=callback_function) 7184 7185 :param callback function: The callback function 7186 for asynchronous request. (optional) 7187 :param str account_id: The external account number (int) or account ID Guid. (required) 7188 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7189 :param str advanced_update: When true, envelope information can be added or modified. 7190 :param str include: 7191 :return: Envelope 7192 If the method is called asynchronously, 7193 returns the request thread. 7194 """ 7195 7196 all_params = ['account_id', 'envelope_id', 'advanced_update', 'include'] 7197 all_params.append('callback') 7198 all_params.append('_return_http_data_only') 7199 all_params.append('_preload_content') 7200 all_params.append('_request_timeout') 7201 7202 params = locals() 7203 for key, val in iteritems(params['kwargs']): 7204 if key not in all_params: 7205 raise TypeError( 7206 "Got an unexpected keyword argument '%s'" 7207 " to method get_envelope" % key 7208 ) 7209 params[key] = val 7210 del params['kwargs'] 7211 # verify the required parameter 'account_id' is set 7212 if ('account_id' not in params) or (params['account_id'] is None): 7213 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope`") 7214 # verify the required parameter 'envelope_id' is set 7215 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7216 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope`") 7217 7218 7219 collection_formats = {} 7220 7221 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}'.replace('{format}', 'json') 7222 path_params = {} 7223 if 'account_id' in params: 7224 path_params['accountId'] = params['account_id'] 7225 if 'envelope_id' in params: 7226 path_params['envelopeId'] = params['envelope_id'] 7227 7228 query_params = {} 7229 if 'advanced_update' in params: 7230 query_params['advanced_update'] = params['advanced_update'] 7231 if 'include' in params: 7232 query_params['include'] = params['include'] 7233 7234 header_params = {} 7235 7236 form_params = [] 7237 local_var_files = {} 7238 7239 body_params = None 7240 # HTTP header `Accept` 7241 header_params['Accept'] = self.api_client.\ 7242 select_header_accept(['application/json']) 7243 7244 # Authentication setting 7245 auth_settings = [] 7246 7247 return self.api_client.call_api(resource_path, 'GET', 7248 path_params, 7249 query_params, 7250 header_params, 7251 body=body_params, 7252 post_params=form_params, 7253 files=local_var_files, 7254 response_type='Envelope', 7255 auth_settings=auth_settings, 7256 callback=params.get('callback'), 7257 _return_http_data_only=params.get('_return_http_data_only'), 7258 _preload_content=params.get('_preload_content', True), 7259 _request_timeout=params.get('_request_timeout'), 7260 collection_formats=collection_formats) 7261 7262 def get_envelope_delayed_routing_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 7263 """ 7264 Returns the delayed routing rules for an envelope's workflow step definition. 7265 This method makes a synchronous HTTP request by default. To make an 7266 asynchronous HTTP request, please define a `callback` function 7267 to be invoked when receiving the response. 7268 >>> def callback_function(response): 7269 >>> pprint(response) 7270 >>> 7271 >>> thread = api.get_envelope_delayed_routing_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 7272 7273 :param callback function: The callback function 7274 for asynchronous request. (optional) 7275 :param str account_id: The external account number (int) or account ID Guid. (required) 7276 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7277 :param str workflow_step_id: (required) 7278 :return: DelayedRouting 7279 If the method is called asynchronously, 7280 returns the request thread. 7281 """ 7282 kwargs['_return_http_data_only'] = True 7283 if kwargs.get('callback'): 7284 return self.get_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 7285 else: 7286 (data) = self.get_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 7287 return data 7288 7289 def get_envelope_delayed_routing_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 7290 """ 7291 Returns the delayed routing rules for an envelope's workflow step definition. 7292 This method makes a synchronous HTTP request by default. To make an 7293 asynchronous HTTP request, please define a `callback` function 7294 to be invoked when receiving the response. 7295 >>> def callback_function(response): 7296 >>> pprint(response) 7297 >>> 7298 >>> thread = api.get_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 7299 7300 :param callback function: The callback function 7301 for asynchronous request. (optional) 7302 :param str account_id: The external account number (int) or account ID Guid. (required) 7303 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7304 :param str workflow_step_id: (required) 7305 :return: DelayedRouting 7306 If the method is called asynchronously, 7307 returns the request thread. 7308 """ 7309 7310 all_params = ['account_id', 'envelope_id', 'workflow_step_id'] 7311 all_params.append('callback') 7312 all_params.append('_return_http_data_only') 7313 all_params.append('_preload_content') 7314 all_params.append('_request_timeout') 7315 7316 params = locals() 7317 for key, val in iteritems(params['kwargs']): 7318 if key not in all_params: 7319 raise TypeError( 7320 "Got an unexpected keyword argument '%s'" 7321 " to method get_envelope_delayed_routing_definition" % key 7322 ) 7323 params[key] = val 7324 del params['kwargs'] 7325 # verify the required parameter 'account_id' is set 7326 if ('account_id' not in params) or (params['account_id'] is None): 7327 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_delayed_routing_definition`") 7328 # verify the required parameter 'envelope_id' is set 7329 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7330 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_delayed_routing_definition`") 7331 # verify the required parameter 'workflow_step_id' is set 7332 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 7333 raise ValueError("Missing the required parameter `workflow_step_id` when calling `get_envelope_delayed_routing_definition`") 7334 7335 7336 collection_formats = {} 7337 7338 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 7339 path_params = {} 7340 if 'account_id' in params: 7341 path_params['accountId'] = params['account_id'] 7342 if 'envelope_id' in params: 7343 path_params['envelopeId'] = params['envelope_id'] 7344 if 'workflow_step_id' in params: 7345 path_params['workflowStepId'] = params['workflow_step_id'] 7346 7347 query_params = {} 7348 7349 header_params = {} 7350 7351 form_params = [] 7352 local_var_files = {} 7353 7354 body_params = None 7355 # HTTP header `Accept` 7356 header_params['Accept'] = self.api_client.\ 7357 select_header_accept(['application/json']) 7358 7359 # Authentication setting 7360 auth_settings = [] 7361 7362 return self.api_client.call_api(resource_path, 'GET', 7363 path_params, 7364 query_params, 7365 header_params, 7366 body=body_params, 7367 post_params=form_params, 7368 files=local_var_files, 7369 response_type='DelayedRouting', 7370 auth_settings=auth_settings, 7371 callback=params.get('callback'), 7372 _return_http_data_only=params.get('_return_http_data_only'), 7373 _preload_content=params.get('_preload_content', True), 7374 _request_timeout=params.get('_request_timeout'), 7375 collection_formats=collection_formats) 7376 7377 def get_envelope_doc_gen_form_fields(self, account_id, envelope_id, **kwargs): 7378 """ 7379 Returns formfields for an envelope 7380 This method makes a synchronous HTTP request by default. To make an 7381 asynchronous HTTP request, please define a `callback` function 7382 to be invoked when receiving the response. 7383 >>> def callback_function(response): 7384 >>> pprint(response) 7385 >>> 7386 >>> thread = api.get_envelope_doc_gen_form_fields(account_id, envelope_id, callback=callback_function) 7387 7388 :param callback function: The callback function 7389 for asynchronous request. (optional) 7390 :param str account_id: The external account number (int) or account ID Guid. (required) 7391 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7392 :return: DocGenFormFieldResponse 7393 If the method is called asynchronously, 7394 returns the request thread. 7395 """ 7396 kwargs['_return_http_data_only'] = True 7397 if kwargs.get('callback'): 7398 return self.get_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, **kwargs) 7399 else: 7400 (data) = self.get_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, **kwargs) 7401 return data 7402 7403 def get_envelope_doc_gen_form_fields_with_http_info(self, account_id, envelope_id, **kwargs): 7404 """ 7405 Returns formfields for an envelope 7406 This method makes a synchronous HTTP request by default. To make an 7407 asynchronous HTTP request, please define a `callback` function 7408 to be invoked when receiving the response. 7409 >>> def callback_function(response): 7410 >>> pprint(response) 7411 >>> 7412 >>> thread = api.get_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, callback=callback_function) 7413 7414 :param callback function: The callback function 7415 for asynchronous request. (optional) 7416 :param str account_id: The external account number (int) or account ID Guid. (required) 7417 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7418 :return: DocGenFormFieldResponse 7419 If the method is called asynchronously, 7420 returns the request thread. 7421 """ 7422 7423 all_params = ['account_id', 'envelope_id'] 7424 all_params.append('callback') 7425 all_params.append('_return_http_data_only') 7426 all_params.append('_preload_content') 7427 all_params.append('_request_timeout') 7428 7429 params = locals() 7430 for key, val in iteritems(params['kwargs']): 7431 if key not in all_params: 7432 raise TypeError( 7433 "Got an unexpected keyword argument '%s'" 7434 " to method get_envelope_doc_gen_form_fields" % key 7435 ) 7436 params[key] = val 7437 del params['kwargs'] 7438 # verify the required parameter 'account_id' is set 7439 if ('account_id' not in params) or (params['account_id'] is None): 7440 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_doc_gen_form_fields`") 7441 # verify the required parameter 'envelope_id' is set 7442 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7443 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_doc_gen_form_fields`") 7444 7445 7446 collection_formats = {} 7447 7448 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/docGenFormFields'.replace('{format}', 'json') 7449 path_params = {} 7450 if 'account_id' in params: 7451 path_params['accountId'] = params['account_id'] 7452 if 'envelope_id' in params: 7453 path_params['envelopeId'] = params['envelope_id'] 7454 7455 query_params = {} 7456 7457 header_params = {} 7458 7459 form_params = [] 7460 local_var_files = {} 7461 7462 body_params = None 7463 # HTTP header `Accept` 7464 header_params['Accept'] = self.api_client.\ 7465 select_header_accept(['application/json']) 7466 7467 # Authentication setting 7468 auth_settings = [] 7469 7470 return self.api_client.call_api(resource_path, 'GET', 7471 path_params, 7472 query_params, 7473 header_params, 7474 body=body_params, 7475 post_params=form_params, 7476 files=local_var_files, 7477 response_type='DocGenFormFieldResponse', 7478 auth_settings=auth_settings, 7479 callback=params.get('callback'), 7480 _return_http_data_only=params.get('_return_http_data_only'), 7481 _preload_content=params.get('_preload_content', True), 7482 _request_timeout=params.get('_request_timeout'), 7483 collection_formats=collection_formats) 7484 7485 def get_envelope_document_html_definitions(self, account_id, document_id, envelope_id, **kwargs): 7486 """ 7487 Get the Original HTML Definition used to generate the Responsive HTML for a given document. 7488 7489 This method makes a synchronous HTTP request by default. To make an 7490 asynchronous HTTP request, please define a `callback` function 7491 to be invoked when receiving the response. 7492 >>> def callback_function(response): 7493 >>> pprint(response) 7494 >>> 7495 >>> thread = api.get_envelope_document_html_definitions(account_id, document_id, envelope_id, callback=callback_function) 7496 7497 :param callback function: The callback function 7498 for asynchronous request. (optional) 7499 :param str account_id: The external account number (int) or account ID Guid. (required) 7500 :param str document_id: The ID of the document being accessed. (required) 7501 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7502 :return: DocumentHtmlDefinitionOriginals 7503 If the method is called asynchronously, 7504 returns the request thread. 7505 """ 7506 kwargs['_return_http_data_only'] = True 7507 if kwargs.get('callback'): 7508 return self.get_envelope_document_html_definitions_with_http_info(account_id, document_id, envelope_id, **kwargs) 7509 else: 7510 (data) = self.get_envelope_document_html_definitions_with_http_info(account_id, document_id, envelope_id, **kwargs) 7511 return data 7512 7513 def get_envelope_document_html_definitions_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 7514 """ 7515 Get the Original HTML Definition used to generate the Responsive HTML for a given document. 7516 7517 This method makes a synchronous HTTP request by default. To make an 7518 asynchronous HTTP request, please define a `callback` function 7519 to be invoked when receiving the response. 7520 >>> def callback_function(response): 7521 >>> pprint(response) 7522 >>> 7523 >>> thread = api.get_envelope_document_html_definitions_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 7524 7525 :param callback function: The callback function 7526 for asynchronous request. (optional) 7527 :param str account_id: The external account number (int) or account ID Guid. (required) 7528 :param str document_id: The ID of the document being accessed. (required) 7529 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7530 :return: DocumentHtmlDefinitionOriginals 7531 If the method is called asynchronously, 7532 returns the request thread. 7533 """ 7534 7535 all_params = ['account_id', 'document_id', 'envelope_id'] 7536 all_params.append('callback') 7537 all_params.append('_return_http_data_only') 7538 all_params.append('_preload_content') 7539 all_params.append('_request_timeout') 7540 7541 params = locals() 7542 for key, val in iteritems(params['kwargs']): 7543 if key not in all_params: 7544 raise TypeError( 7545 "Got an unexpected keyword argument '%s'" 7546 " to method get_envelope_document_html_definitions" % key 7547 ) 7548 params[key] = val 7549 del params['kwargs'] 7550 # verify the required parameter 'account_id' is set 7551 if ('account_id' not in params) or (params['account_id'] is None): 7552 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_document_html_definitions`") 7553 # verify the required parameter 'document_id' is set 7554 if ('document_id' not in params) or (params['document_id'] is None): 7555 raise ValueError("Missing the required parameter `document_id` when calling `get_envelope_document_html_definitions`") 7556 # verify the required parameter 'envelope_id' is set 7557 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7558 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_document_html_definitions`") 7559 7560 7561 collection_formats = {} 7562 7563 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/html_definitions'.replace('{format}', 'json') 7564 path_params = {} 7565 if 'account_id' in params: 7566 path_params['accountId'] = params['account_id'] 7567 if 'document_id' in params: 7568 path_params['documentId'] = params['document_id'] 7569 if 'envelope_id' in params: 7570 path_params['envelopeId'] = params['envelope_id'] 7571 7572 query_params = {} 7573 7574 header_params = {} 7575 7576 form_params = [] 7577 local_var_files = {} 7578 7579 body_params = None 7580 # HTTP header `Accept` 7581 header_params['Accept'] = self.api_client.\ 7582 select_header_accept(['application/json']) 7583 7584 # Authentication setting 7585 auth_settings = [] 7586 7587 return self.api_client.call_api(resource_path, 'GET', 7588 path_params, 7589 query_params, 7590 header_params, 7591 body=body_params, 7592 post_params=form_params, 7593 files=local_var_files, 7594 response_type='DocumentHtmlDefinitionOriginals', 7595 auth_settings=auth_settings, 7596 callback=params.get('callback'), 7597 _return_http_data_only=params.get('_return_http_data_only'), 7598 _preload_content=params.get('_preload_content', True), 7599 _request_timeout=params.get('_request_timeout'), 7600 collection_formats=collection_formats) 7601 7602 def get_envelope_html_definitions(self, account_id, envelope_id, **kwargs): 7603 """ 7604 Get the Original HTML Definition used to generate the Responsive HTML for the envelope. 7605 7606 This method makes a synchronous HTTP request by default. To make an 7607 asynchronous HTTP request, please define a `callback` function 7608 to be invoked when receiving the response. 7609 >>> def callback_function(response): 7610 >>> pprint(response) 7611 >>> 7612 >>> thread = api.get_envelope_html_definitions(account_id, envelope_id, callback=callback_function) 7613 7614 :param callback function: The callback function 7615 for asynchronous request. (optional) 7616 :param str account_id: The external account number (int) or account ID Guid. (required) 7617 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7618 :return: DocumentHtmlDefinitionOriginals 7619 If the method is called asynchronously, 7620 returns the request thread. 7621 """ 7622 kwargs['_return_http_data_only'] = True 7623 if kwargs.get('callback'): 7624 return self.get_envelope_html_definitions_with_http_info(account_id, envelope_id, **kwargs) 7625 else: 7626 (data) = self.get_envelope_html_definitions_with_http_info(account_id, envelope_id, **kwargs) 7627 return data 7628 7629 def get_envelope_html_definitions_with_http_info(self, account_id, envelope_id, **kwargs): 7630 """ 7631 Get the Original HTML Definition used to generate the Responsive HTML for the envelope. 7632 7633 This method makes a synchronous HTTP request by default. To make an 7634 asynchronous HTTP request, please define a `callback` function 7635 to be invoked when receiving the response. 7636 >>> def callback_function(response): 7637 >>> pprint(response) 7638 >>> 7639 >>> thread = api.get_envelope_html_definitions_with_http_info(account_id, envelope_id, callback=callback_function) 7640 7641 :param callback function: The callback function 7642 for asynchronous request. (optional) 7643 :param str account_id: The external account number (int) or account ID Guid. (required) 7644 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7645 :return: DocumentHtmlDefinitionOriginals 7646 If the method is called asynchronously, 7647 returns the request thread. 7648 """ 7649 7650 all_params = ['account_id', 'envelope_id'] 7651 all_params.append('callback') 7652 all_params.append('_return_http_data_only') 7653 all_params.append('_preload_content') 7654 all_params.append('_request_timeout') 7655 7656 params = locals() 7657 for key, val in iteritems(params['kwargs']): 7658 if key not in all_params: 7659 raise TypeError( 7660 "Got an unexpected keyword argument '%s'" 7661 " to method get_envelope_html_definitions" % key 7662 ) 7663 params[key] = val 7664 del params['kwargs'] 7665 # verify the required parameter 'account_id' is set 7666 if ('account_id' not in params) or (params['account_id'] is None): 7667 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_html_definitions`") 7668 # verify the required parameter 'envelope_id' is set 7669 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7670 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_html_definitions`") 7671 7672 7673 collection_formats = {} 7674 7675 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/html_definitions'.replace('{format}', 'json') 7676 path_params = {} 7677 if 'account_id' in params: 7678 path_params['accountId'] = params['account_id'] 7679 if 'envelope_id' in params: 7680 path_params['envelopeId'] = params['envelope_id'] 7681 7682 query_params = {} 7683 7684 header_params = {} 7685 7686 form_params = [] 7687 local_var_files = {} 7688 7689 body_params = None 7690 # HTTP header `Accept` 7691 header_params['Accept'] = self.api_client.\ 7692 select_header_accept(['application/json']) 7693 7694 # Authentication setting 7695 auth_settings = [] 7696 7697 return self.api_client.call_api(resource_path, 'GET', 7698 path_params, 7699 query_params, 7700 header_params, 7701 body=body_params, 7702 post_params=form_params, 7703 files=local_var_files, 7704 response_type='DocumentHtmlDefinitionOriginals', 7705 auth_settings=auth_settings, 7706 callback=params.get('callback'), 7707 _return_http_data_only=params.get('_return_http_data_only'), 7708 _preload_content=params.get('_preload_content', True), 7709 _request_timeout=params.get('_request_timeout'), 7710 collection_formats=collection_formats) 7711 7712 def get_envelope_scheduled_sending_definition(self, account_id, envelope_id, **kwargs): 7713 """ 7714 Returns the scheduled sending rules for an envelope's workflow definition. 7715 This method makes a synchronous HTTP request by default. To make an 7716 asynchronous HTTP request, please define a `callback` function 7717 to be invoked when receiving the response. 7718 >>> def callback_function(response): 7719 >>> pprint(response) 7720 >>> 7721 >>> thread = api.get_envelope_scheduled_sending_definition(account_id, envelope_id, callback=callback_function) 7722 7723 :param callback function: The callback function 7724 for asynchronous request. (optional) 7725 :param str account_id: The external account number (int) or account ID Guid. (required) 7726 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7727 :return: ScheduledSending 7728 If the method is called asynchronously, 7729 returns the request thread. 7730 """ 7731 kwargs['_return_http_data_only'] = True 7732 if kwargs.get('callback'): 7733 return self.get_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 7734 else: 7735 (data) = self.get_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 7736 return data 7737 7738 def get_envelope_scheduled_sending_definition_with_http_info(self, account_id, envelope_id, **kwargs): 7739 """ 7740 Returns the scheduled sending rules for an envelope's workflow definition. 7741 This method makes a synchronous HTTP request by default. To make an 7742 asynchronous HTTP request, please define a `callback` function 7743 to be invoked when receiving the response. 7744 >>> def callback_function(response): 7745 >>> pprint(response) 7746 >>> 7747 >>> thread = api.get_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, callback=callback_function) 7748 7749 :param callback function: The callback function 7750 for asynchronous request. (optional) 7751 :param str account_id: The external account number (int) or account ID Guid. (required) 7752 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7753 :return: ScheduledSending 7754 If the method is called asynchronously, 7755 returns the request thread. 7756 """ 7757 7758 all_params = ['account_id', 'envelope_id'] 7759 all_params.append('callback') 7760 all_params.append('_return_http_data_only') 7761 all_params.append('_preload_content') 7762 all_params.append('_request_timeout') 7763 7764 params = locals() 7765 for key, val in iteritems(params['kwargs']): 7766 if key not in all_params: 7767 raise TypeError( 7768 "Got an unexpected keyword argument '%s'" 7769 " to method get_envelope_scheduled_sending_definition" % key 7770 ) 7771 params[key] = val 7772 del params['kwargs'] 7773 # verify the required parameter 'account_id' is set 7774 if ('account_id' not in params) or (params['account_id'] is None): 7775 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_scheduled_sending_definition`") 7776 # verify the required parameter 'envelope_id' is set 7777 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7778 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_scheduled_sending_definition`") 7779 7780 7781 collection_formats = {} 7782 7783 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/scheduledSending'.replace('{format}', 'json') 7784 path_params = {} 7785 if 'account_id' in params: 7786 path_params['accountId'] = params['account_id'] 7787 if 'envelope_id' in params: 7788 path_params['envelopeId'] = params['envelope_id'] 7789 7790 query_params = {} 7791 7792 header_params = {} 7793 7794 form_params = [] 7795 local_var_files = {} 7796 7797 body_params = None 7798 # HTTP header `Accept` 7799 header_params['Accept'] = self.api_client.\ 7800 select_header_accept(['application/json']) 7801 7802 # Authentication setting 7803 auth_settings = [] 7804 7805 return self.api_client.call_api(resource_path, 'GET', 7806 path_params, 7807 query_params, 7808 header_params, 7809 body=body_params, 7810 post_params=form_params, 7811 files=local_var_files, 7812 response_type='ScheduledSending', 7813 auth_settings=auth_settings, 7814 callback=params.get('callback'), 7815 _return_http_data_only=params.get('_return_http_data_only'), 7816 _preload_content=params.get('_preload_content', True), 7817 _request_timeout=params.get('_request_timeout'), 7818 collection_formats=collection_formats) 7819 7820 def get_envelope_transfer_rules(self, account_id, **kwargs): 7821 """ 7822 Returns a list of envelope transfer rules in the specified account. 7823 This method retrieves a list of envelope transfer rules associated with an account. **Note:** Only Administrators can create and use envelope transfer rules. In addition, to use envelope transfer rules, the **Transfer Custody** feature must be enabled for your account. 7824 This method makes a synchronous HTTP request by default. To make an 7825 asynchronous HTTP request, please define a `callback` function 7826 to be invoked when receiving the response. 7827 >>> def callback_function(response): 7828 >>> pprint(response) 7829 >>> 7830 >>> thread = api.get_envelope_transfer_rules(account_id, callback=callback_function) 7831 7832 :param callback function: The callback function 7833 for asynchronous request. (optional) 7834 :param str account_id: The external account number (int) or account ID Guid. (required) 7835 :param str count: 7836 :param str start_position: 7837 :return: EnvelopeTransferRuleInformation 7838 If the method is called asynchronously, 7839 returns the request thread. 7840 """ 7841 kwargs['_return_http_data_only'] = True 7842 if kwargs.get('callback'): 7843 return self.get_envelope_transfer_rules_with_http_info(account_id, **kwargs) 7844 else: 7845 (data) = self.get_envelope_transfer_rules_with_http_info(account_id, **kwargs) 7846 return data 7847 7848 def get_envelope_transfer_rules_with_http_info(self, account_id, **kwargs): 7849 """ 7850 Returns a list of envelope transfer rules in the specified account. 7851 This method retrieves a list of envelope transfer rules associated with an account. **Note:** Only Administrators can create and use envelope transfer rules. In addition, to use envelope transfer rules, the **Transfer Custody** feature must be enabled for your account. 7852 This method makes a synchronous HTTP request by default. To make an 7853 asynchronous HTTP request, please define a `callback` function 7854 to be invoked when receiving the response. 7855 >>> def callback_function(response): 7856 >>> pprint(response) 7857 >>> 7858 >>> thread = api.get_envelope_transfer_rules_with_http_info(account_id, callback=callback_function) 7859 7860 :param callback function: The callback function 7861 for asynchronous request. (optional) 7862 :param str account_id: The external account number (int) or account ID Guid. (required) 7863 :param str count: 7864 :param str start_position: 7865 :return: EnvelopeTransferRuleInformation 7866 If the method is called asynchronously, 7867 returns the request thread. 7868 """ 7869 7870 all_params = ['account_id', 'count', 'start_position'] 7871 all_params.append('callback') 7872 all_params.append('_return_http_data_only') 7873 all_params.append('_preload_content') 7874 all_params.append('_request_timeout') 7875 7876 params = locals() 7877 for key, val in iteritems(params['kwargs']): 7878 if key not in all_params: 7879 raise TypeError( 7880 "Got an unexpected keyword argument '%s'" 7881 " to method get_envelope_transfer_rules" % key 7882 ) 7883 params[key] = val 7884 del params['kwargs'] 7885 # verify the required parameter 'account_id' is set 7886 if ('account_id' not in params) or (params['account_id'] is None): 7887 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_transfer_rules`") 7888 7889 7890 collection_formats = {} 7891 7892 resource_path = '/v2.1/accounts/{accountId}/envelopes/transfer_rules'.replace('{format}', 'json') 7893 path_params = {} 7894 if 'account_id' in params: 7895 path_params['accountId'] = params['account_id'] 7896 7897 query_params = {} 7898 if 'count' in params: 7899 query_params['count'] = params['count'] 7900 if 'start_position' in params: 7901 query_params['start_position'] = params['start_position'] 7902 7903 header_params = {} 7904 7905 form_params = [] 7906 local_var_files = {} 7907 7908 body_params = None 7909 # HTTP header `Accept` 7910 header_params['Accept'] = self.api_client.\ 7911 select_header_accept(['application/json']) 7912 7913 # Authentication setting 7914 auth_settings = [] 7915 7916 return self.api_client.call_api(resource_path, 'GET', 7917 path_params, 7918 query_params, 7919 header_params, 7920 body=body_params, 7921 post_params=form_params, 7922 files=local_var_files, 7923 response_type='EnvelopeTransferRuleInformation', 7924 auth_settings=auth_settings, 7925 callback=params.get('callback'), 7926 _return_http_data_only=params.get('_return_http_data_only'), 7927 _preload_content=params.get('_preload_content', True), 7928 _request_timeout=params.get('_request_timeout'), 7929 collection_formats=collection_formats) 7930 7931 def get_envelope_workflow_definition(self, account_id, envelope_id, **kwargs): 7932 """ 7933 Returns the workflow definition for an envelope. 7934 Returns an envelope's workflow definition if the envelope specified by `envelopeId` has one. 7935 This method makes a synchronous HTTP request by default. To make an 7936 asynchronous HTTP request, please define a `callback` function 7937 to be invoked when receiving the response. 7938 >>> def callback_function(response): 7939 >>> pprint(response) 7940 >>> 7941 >>> thread = api.get_envelope_workflow_definition(account_id, envelope_id, callback=callback_function) 7942 7943 :param callback function: The callback function 7944 for asynchronous request. (optional) 7945 :param str account_id: The external account number (int) or account ID Guid. (required) 7946 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7947 :return: Workflow 7948 If the method is called asynchronously, 7949 returns the request thread. 7950 """ 7951 kwargs['_return_http_data_only'] = True 7952 if kwargs.get('callback'): 7953 return self.get_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 7954 else: 7955 (data) = self.get_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 7956 return data 7957 7958 def get_envelope_workflow_definition_with_http_info(self, account_id, envelope_id, **kwargs): 7959 """ 7960 Returns the workflow definition for an envelope. 7961 Returns an envelope's workflow definition if the envelope specified by `envelopeId` has one. 7962 This method makes a synchronous HTTP request by default. To make an 7963 asynchronous HTTP request, please define a `callback` function 7964 to be invoked when receiving the response. 7965 >>> def callback_function(response): 7966 >>> pprint(response) 7967 >>> 7968 >>> thread = api.get_envelope_workflow_definition_with_http_info(account_id, envelope_id, callback=callback_function) 7969 7970 :param callback function: The callback function 7971 for asynchronous request. (optional) 7972 :param str account_id: The external account number (int) or account ID Guid. (required) 7973 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7974 :return: Workflow 7975 If the method is called asynchronously, 7976 returns the request thread. 7977 """ 7978 7979 all_params = ['account_id', 'envelope_id'] 7980 all_params.append('callback') 7981 all_params.append('_return_http_data_only') 7982 all_params.append('_preload_content') 7983 all_params.append('_request_timeout') 7984 7985 params = locals() 7986 for key, val in iteritems(params['kwargs']): 7987 if key not in all_params: 7988 raise TypeError( 7989 "Got an unexpected keyword argument '%s'" 7990 " to method get_envelope_workflow_definition" % key 7991 ) 7992 params[key] = val 7993 del params['kwargs'] 7994 # verify the required parameter 'account_id' is set 7995 if ('account_id' not in params) or (params['account_id'] is None): 7996 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_workflow_definition`") 7997 # verify the required parameter 'envelope_id' is set 7998 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7999 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_workflow_definition`") 8000 8001 8002 collection_formats = {} 8003 8004 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow'.replace('{format}', 'json') 8005 path_params = {} 8006 if 'account_id' in params: 8007 path_params['accountId'] = params['account_id'] 8008 if 'envelope_id' in params: 8009 path_params['envelopeId'] = params['envelope_id'] 8010 8011 query_params = {} 8012 8013 header_params = {} 8014 8015 form_params = [] 8016 local_var_files = {} 8017 8018 body_params = None 8019 # HTTP header `Accept` 8020 header_params['Accept'] = self.api_client.\ 8021 select_header_accept(['application/json']) 8022 8023 # Authentication setting 8024 auth_settings = [] 8025 8026 return self.api_client.call_api(resource_path, 'GET', 8027 path_params, 8028 query_params, 8029 header_params, 8030 body=body_params, 8031 post_params=form_params, 8032 files=local_var_files, 8033 response_type='Workflow', 8034 auth_settings=auth_settings, 8035 callback=params.get('callback'), 8036 _return_http_data_only=params.get('_return_http_data_only'), 8037 _preload_content=params.get('_preload_content', True), 8038 _request_timeout=params.get('_request_timeout'), 8039 collection_formats=collection_formats) 8040 8041 def get_envelope_workflow_step_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 8042 """ 8043 Returns the workflow step definition for an envelope by step id. 8044 This method makes a synchronous HTTP request by default. To make an 8045 asynchronous HTTP request, please define a `callback` function 8046 to be invoked when receiving the response. 8047 >>> def callback_function(response): 8048 >>> pprint(response) 8049 >>> 8050 >>> thread = api.get_envelope_workflow_step_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 8051 8052 :param callback function: The callback function 8053 for asynchronous request. (optional) 8054 :param str account_id: The external account number (int) or account ID Guid. (required) 8055 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8056 :param str workflow_step_id: (required) 8057 :return: WorkflowStep 8058 If the method is called asynchronously, 8059 returns the request thread. 8060 """ 8061 kwargs['_return_http_data_only'] = True 8062 if kwargs.get('callback'): 8063 return self.get_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 8064 else: 8065 (data) = self.get_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 8066 return data 8067 8068 def get_envelope_workflow_step_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 8069 """ 8070 Returns the workflow step definition for an envelope by step id. 8071 This method makes a synchronous HTTP request by default. To make an 8072 asynchronous HTTP request, please define a `callback` function 8073 to be invoked when receiving the response. 8074 >>> def callback_function(response): 8075 >>> pprint(response) 8076 >>> 8077 >>> thread = api.get_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 8078 8079 :param callback function: The callback function 8080 for asynchronous request. (optional) 8081 :param str account_id: The external account number (int) or account ID Guid. (required) 8082 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8083 :param str workflow_step_id: (required) 8084 :return: WorkflowStep 8085 If the method is called asynchronously, 8086 returns the request thread. 8087 """ 8088 8089 all_params = ['account_id', 'envelope_id', 'workflow_step_id'] 8090 all_params.append('callback') 8091 all_params.append('_return_http_data_only') 8092 all_params.append('_preload_content') 8093 all_params.append('_request_timeout') 8094 8095 params = locals() 8096 for key, val in iteritems(params['kwargs']): 8097 if key not in all_params: 8098 raise TypeError( 8099 "Got an unexpected keyword argument '%s'" 8100 " to method get_envelope_workflow_step_definition" % key 8101 ) 8102 params[key] = val 8103 del params['kwargs'] 8104 # verify the required parameter 'account_id' is set 8105 if ('account_id' not in params) or (params['account_id'] is None): 8106 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_workflow_step_definition`") 8107 # verify the required parameter 'envelope_id' is set 8108 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8109 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope_workflow_step_definition`") 8110 # verify the required parameter 'workflow_step_id' is set 8111 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 8112 raise ValueError("Missing the required parameter `workflow_step_id` when calling `get_envelope_workflow_step_definition`") 8113 8114 8115 collection_formats = {} 8116 8117 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 8118 path_params = {} 8119 if 'account_id' in params: 8120 path_params['accountId'] = params['account_id'] 8121 if 'envelope_id' in params: 8122 path_params['envelopeId'] = params['envelope_id'] 8123 if 'workflow_step_id' in params: 8124 path_params['workflowStepId'] = params['workflow_step_id'] 8125 8126 query_params = {} 8127 8128 header_params = {} 8129 8130 form_params = [] 8131 local_var_files = {} 8132 8133 body_params = None 8134 # HTTP header `Accept` 8135 header_params['Accept'] = self.api_client.\ 8136 select_header_accept(['application/json']) 8137 8138 # Authentication setting 8139 auth_settings = [] 8140 8141 return self.api_client.call_api(resource_path, 'GET', 8142 path_params, 8143 query_params, 8144 header_params, 8145 body=body_params, 8146 post_params=form_params, 8147 files=local_var_files, 8148 response_type='WorkflowStep', 8149 auth_settings=auth_settings, 8150 callback=params.get('callback'), 8151 _return_http_data_only=params.get('_return_http_data_only'), 8152 _preload_content=params.get('_preload_content', True), 8153 _request_timeout=params.get('_request_timeout'), 8154 collection_formats=collection_formats) 8155 8156 def get_form_data(self, account_id, envelope_id, **kwargs): 8157 """ 8158 Returns envelope form data for an existing envelope. 8159 This method downloads the envelope and tab data (also called form data) from any in-process, completed, or canceled envelope that you sent or that is shared with you. Recipients who are also full administrators on an account can view form data for any envelopes that another user on the account has sent to them. **Note:** To use this feature, the Sending Setting \"Allow sender to download form data\" must be enabled for the account. ### Related topics - [How to get envelope tab values](/docs/esign-rest-api/how-to/get-envelope-tab-values/) 8160 This method makes a synchronous HTTP request by default. To make an 8161 asynchronous HTTP request, please define a `callback` function 8162 to be invoked when receiving the response. 8163 >>> def callback_function(response): 8164 >>> pprint(response) 8165 >>> 8166 >>> thread = api.get_form_data(account_id, envelope_id, callback=callback_function) 8167 8168 :param callback function: The callback function 8169 for asynchronous request. (optional) 8170 :param str account_id: The external account number (int) or account ID Guid. (required) 8171 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8172 :return: EnvelopeFormData 8173 If the method is called asynchronously, 8174 returns the request thread. 8175 """ 8176 kwargs['_return_http_data_only'] = True 8177 if kwargs.get('callback'): 8178 return self.get_form_data_with_http_info(account_id, envelope_id, **kwargs) 8179 else: 8180 (data) = self.get_form_data_with_http_info(account_id, envelope_id, **kwargs) 8181 return data 8182 8183 def get_form_data_with_http_info(self, account_id, envelope_id, **kwargs): 8184 """ 8185 Returns envelope form data for an existing envelope. 8186 This method downloads the envelope and tab data (also called form data) from any in-process, completed, or canceled envelope that you sent or that is shared with you. Recipients who are also full administrators on an account can view form data for any envelopes that another user on the account has sent to them. **Note:** To use this feature, the Sending Setting \"Allow sender to download form data\" must be enabled for the account. ### Related topics - [How to get envelope tab values](/docs/esign-rest-api/how-to/get-envelope-tab-values/) 8187 This method makes a synchronous HTTP request by default. To make an 8188 asynchronous HTTP request, please define a `callback` function 8189 to be invoked when receiving the response. 8190 >>> def callback_function(response): 8191 >>> pprint(response) 8192 >>> 8193 >>> thread = api.get_form_data_with_http_info(account_id, envelope_id, callback=callback_function) 8194 8195 :param callback function: The callback function 8196 for asynchronous request. (optional) 8197 :param str account_id: The external account number (int) or account ID Guid. (required) 8198 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8199 :return: EnvelopeFormData 8200 If the method is called asynchronously, 8201 returns the request thread. 8202 """ 8203 8204 all_params = ['account_id', 'envelope_id'] 8205 all_params.append('callback') 8206 all_params.append('_return_http_data_only') 8207 all_params.append('_preload_content') 8208 all_params.append('_request_timeout') 8209 8210 params = locals() 8211 for key, val in iteritems(params['kwargs']): 8212 if key not in all_params: 8213 raise TypeError( 8214 "Got an unexpected keyword argument '%s'" 8215 " to method get_form_data" % key 8216 ) 8217 params[key] = val 8218 del params['kwargs'] 8219 # verify the required parameter 'account_id' is set 8220 if ('account_id' not in params) or (params['account_id'] is None): 8221 raise ValueError("Missing the required parameter `account_id` when calling `get_form_data`") 8222 # verify the required parameter 'envelope_id' is set 8223 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8224 raise ValueError("Missing the required parameter `envelope_id` when calling `get_form_data`") 8225 8226 8227 collection_formats = {} 8228 8229 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/form_data'.replace('{format}', 'json') 8230 path_params = {} 8231 if 'account_id' in params: 8232 path_params['accountId'] = params['account_id'] 8233 if 'envelope_id' in params: 8234 path_params['envelopeId'] = params['envelope_id'] 8235 8236 query_params = {} 8237 8238 header_params = {} 8239 8240 form_params = [] 8241 local_var_files = {} 8242 8243 body_params = None 8244 # HTTP header `Accept` 8245 header_params['Accept'] = self.api_client.\ 8246 select_header_accept(['application/json']) 8247 8248 # Authentication setting 8249 auth_settings = [] 8250 8251 return self.api_client.call_api(resource_path, 'GET', 8252 path_params, 8253 query_params, 8254 header_params, 8255 body=body_params, 8256 post_params=form_params, 8257 files=local_var_files, 8258 response_type='EnvelopeFormData', 8259 auth_settings=auth_settings, 8260 callback=params.get('callback'), 8261 _return_http_data_only=params.get('_return_http_data_only'), 8262 _preload_content=params.get('_preload_content', True), 8263 _request_timeout=params.get('_request_timeout'), 8264 collection_formats=collection_formats) 8265 8266 def get_lock(self, account_id, envelope_id, **kwargs): 8267 """ 8268 Gets envelope lock information. 8269 Retrieves general information about the envelope lock. If the call is made by the locked by user and the request has the same integrator key as original, then the `X-DocuSign-Edit` header and additional lock information is included in the response. This allows users to recover a lost editing session token and the `X-DocuSign-Edit` header. 8270 This method makes a synchronous HTTP request by default. To make an 8271 asynchronous HTTP request, please define a `callback` function 8272 to be invoked when receiving the response. 8273 >>> def callback_function(response): 8274 >>> pprint(response) 8275 >>> 8276 >>> thread = api.get_lock(account_id, envelope_id, callback=callback_function) 8277 8278 :param callback function: The callback function 8279 for asynchronous request. (optional) 8280 :param str account_id: The external account number (int) or account ID Guid. (required) 8281 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8282 :return: LockInformation 8283 If the method is called asynchronously, 8284 returns the request thread. 8285 """ 8286 kwargs['_return_http_data_only'] = True 8287 if kwargs.get('callback'): 8288 return self.get_lock_with_http_info(account_id, envelope_id, **kwargs) 8289 else: 8290 (data) = self.get_lock_with_http_info(account_id, envelope_id, **kwargs) 8291 return data 8292 8293 def get_lock_with_http_info(self, account_id, envelope_id, **kwargs): 8294 """ 8295 Gets envelope lock information. 8296 Retrieves general information about the envelope lock. If the call is made by the locked by user and the request has the same integrator key as original, then the `X-DocuSign-Edit` header and additional lock information is included in the response. This allows users to recover a lost editing session token and the `X-DocuSign-Edit` header. 8297 This method makes a synchronous HTTP request by default. To make an 8298 asynchronous HTTP request, please define a `callback` function 8299 to be invoked when receiving the response. 8300 >>> def callback_function(response): 8301 >>> pprint(response) 8302 >>> 8303 >>> thread = api.get_lock_with_http_info(account_id, envelope_id, callback=callback_function) 8304 8305 :param callback function: The callback function 8306 for asynchronous request. (optional) 8307 :param str account_id: The external account number (int) or account ID Guid. (required) 8308 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8309 :return: LockInformation 8310 If the method is called asynchronously, 8311 returns the request thread. 8312 """ 8313 8314 all_params = ['account_id', 'envelope_id'] 8315 all_params.append('callback') 8316 all_params.append('_return_http_data_only') 8317 all_params.append('_preload_content') 8318 all_params.append('_request_timeout') 8319 8320 params = locals() 8321 for key, val in iteritems(params['kwargs']): 8322 if key not in all_params: 8323 raise TypeError( 8324 "Got an unexpected keyword argument '%s'" 8325 " to method get_lock" % key 8326 ) 8327 params[key] = val 8328 del params['kwargs'] 8329 # verify the required parameter 'account_id' is set 8330 if ('account_id' not in params) or (params['account_id'] is None): 8331 raise ValueError("Missing the required parameter `account_id` when calling `get_lock`") 8332 # verify the required parameter 'envelope_id' is set 8333 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8334 raise ValueError("Missing the required parameter `envelope_id` when calling `get_lock`") 8335 8336 8337 collection_formats = {} 8338 8339 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/lock'.replace('{format}', 'json') 8340 path_params = {} 8341 if 'account_id' in params: 8342 path_params['accountId'] = params['account_id'] 8343 if 'envelope_id' in params: 8344 path_params['envelopeId'] = params['envelope_id'] 8345 8346 query_params = {} 8347 8348 header_params = {} 8349 8350 form_params = [] 8351 local_var_files = {} 8352 8353 body_params = None 8354 # HTTP header `Accept` 8355 header_params['Accept'] = self.api_client.\ 8356 select_header_accept(['application/json']) 8357 8358 # Authentication setting 8359 auth_settings = [] 8360 8361 return self.api_client.call_api(resource_path, 'GET', 8362 path_params, 8363 query_params, 8364 header_params, 8365 body=body_params, 8366 post_params=form_params, 8367 files=local_var_files, 8368 response_type='LockInformation', 8369 auth_settings=auth_settings, 8370 callback=params.get('callback'), 8371 _return_http_data_only=params.get('_return_http_data_only'), 8372 _preload_content=params.get('_preload_content', True), 8373 _request_timeout=params.get('_request_timeout'), 8374 collection_formats=collection_formats) 8375 8376 def get_notification_settings(self, account_id, envelope_id, **kwargs): 8377 """ 8378 Gets envelope notification information. 8379 Retrieves the envelope notification, reminders and expirations, information for an existing envelope. 8380 This method makes a synchronous HTTP request by default. To make an 8381 asynchronous HTTP request, please define a `callback` function 8382 to be invoked when receiving the response. 8383 >>> def callback_function(response): 8384 >>> pprint(response) 8385 >>> 8386 >>> thread = api.get_notification_settings(account_id, envelope_id, callback=callback_function) 8387 8388 :param callback function: The callback function 8389 for asynchronous request. (optional) 8390 :param str account_id: The external account number (int) or account ID Guid. (required) 8391 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8392 :return: Notification 8393 If the method is called asynchronously, 8394 returns the request thread. 8395 """ 8396 kwargs['_return_http_data_only'] = True 8397 if kwargs.get('callback'): 8398 return self.get_notification_settings_with_http_info(account_id, envelope_id, **kwargs) 8399 else: 8400 (data) = self.get_notification_settings_with_http_info(account_id, envelope_id, **kwargs) 8401 return data 8402 8403 def get_notification_settings_with_http_info(self, account_id, envelope_id, **kwargs): 8404 """ 8405 Gets envelope notification information. 8406 Retrieves the envelope notification, reminders and expirations, information for an existing envelope. 8407 This method makes a synchronous HTTP request by default. To make an 8408 asynchronous HTTP request, please define a `callback` function 8409 to be invoked when receiving the response. 8410 >>> def callback_function(response): 8411 >>> pprint(response) 8412 >>> 8413 >>> thread = api.get_notification_settings_with_http_info(account_id, envelope_id, callback=callback_function) 8414 8415 :param callback function: The callback function 8416 for asynchronous request. (optional) 8417 :param str account_id: The external account number (int) or account ID Guid. (required) 8418 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8419 :return: Notification 8420 If the method is called asynchronously, 8421 returns the request thread. 8422 """ 8423 8424 all_params = ['account_id', 'envelope_id'] 8425 all_params.append('callback') 8426 all_params.append('_return_http_data_only') 8427 all_params.append('_preload_content') 8428 all_params.append('_request_timeout') 8429 8430 params = locals() 8431 for key, val in iteritems(params['kwargs']): 8432 if key not in all_params: 8433 raise TypeError( 8434 "Got an unexpected keyword argument '%s'" 8435 " to method get_notification_settings" % key 8436 ) 8437 params[key] = val 8438 del params['kwargs'] 8439 # verify the required parameter 'account_id' is set 8440 if ('account_id' not in params) or (params['account_id'] is None): 8441 raise ValueError("Missing the required parameter `account_id` when calling `get_notification_settings`") 8442 # verify the required parameter 'envelope_id' is set 8443 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8444 raise ValueError("Missing the required parameter `envelope_id` when calling `get_notification_settings`") 8445 8446 8447 collection_formats = {} 8448 8449 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/notification'.replace('{format}', 'json') 8450 path_params = {} 8451 if 'account_id' in params: 8452 path_params['accountId'] = params['account_id'] 8453 if 'envelope_id' in params: 8454 path_params['envelopeId'] = params['envelope_id'] 8455 8456 query_params = {} 8457 8458 header_params = {} 8459 8460 form_params = [] 8461 local_var_files = {} 8462 8463 body_params = None 8464 # HTTP header `Accept` 8465 header_params['Accept'] = self.api_client.\ 8466 select_header_accept(['application/json']) 8467 8468 # Authentication setting 8469 auth_settings = [] 8470 8471 return self.api_client.call_api(resource_path, 'GET', 8472 path_params, 8473 query_params, 8474 header_params, 8475 body=body_params, 8476 post_params=form_params, 8477 files=local_var_files, 8478 response_type='Notification', 8479 auth_settings=auth_settings, 8480 callback=params.get('callback'), 8481 _return_http_data_only=params.get('_return_http_data_only'), 8482 _preload_content=params.get('_preload_content', True), 8483 _request_timeout=params.get('_request_timeout'), 8484 collection_formats=collection_formats) 8485 8486 def get_page_tabs(self, account_id, document_id, envelope_id, page_number, **kwargs): 8487 """ 8488 Returns tabs on the specified page. 8489 Returns the tabs from the page specified by `pageNumber` of the document specified by `documentId` in the envelope specified by `envelopeId`. 8490 This method makes a synchronous HTTP request by default. To make an 8491 asynchronous HTTP request, please define a `callback` function 8492 to be invoked when receiving the response. 8493 >>> def callback_function(response): 8494 >>> pprint(response) 8495 >>> 8496 >>> thread = api.get_page_tabs(account_id, document_id, envelope_id, page_number, callback=callback_function) 8497 8498 :param callback function: The callback function 8499 for asynchronous request. (optional) 8500 :param str account_id: The external account number (int) or account ID Guid. (required) 8501 :param str document_id: The ID of the document being accessed. (required) 8502 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8503 :param str page_number: The page number being accessed. (required) 8504 :return: Tabs 8505 If the method is called asynchronously, 8506 returns the request thread. 8507 """ 8508 kwargs['_return_http_data_only'] = True 8509 if kwargs.get('callback'): 8510 return self.get_page_tabs_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 8511 else: 8512 (data) = self.get_page_tabs_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 8513 return data 8514 8515 def get_page_tabs_with_http_info(self, account_id, document_id, envelope_id, page_number, **kwargs): 8516 """ 8517 Returns tabs on the specified page. 8518 Returns the tabs from the page specified by `pageNumber` of the document specified by `documentId` in the envelope specified by `envelopeId`. 8519 This method makes a synchronous HTTP request by default. To make an 8520 asynchronous HTTP request, please define a `callback` function 8521 to be invoked when receiving the response. 8522 >>> def callback_function(response): 8523 >>> pprint(response) 8524 >>> 8525 >>> thread = api.get_page_tabs_with_http_info(account_id, document_id, envelope_id, page_number, callback=callback_function) 8526 8527 :param callback function: The callback function 8528 for asynchronous request. (optional) 8529 :param str account_id: The external account number (int) or account ID Guid. (required) 8530 :param str document_id: The ID of the document being accessed. (required) 8531 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8532 :param str page_number: The page number being accessed. (required) 8533 :return: Tabs 8534 If the method is called asynchronously, 8535 returns the request thread. 8536 """ 8537 8538 all_params = ['account_id', 'document_id', 'envelope_id', 'page_number'] 8539 all_params.append('callback') 8540 all_params.append('_return_http_data_only') 8541 all_params.append('_preload_content') 8542 all_params.append('_request_timeout') 8543 8544 params = locals() 8545 for key, val in iteritems(params['kwargs']): 8546 if key not in all_params: 8547 raise TypeError( 8548 "Got an unexpected keyword argument '%s'" 8549 " to method get_page_tabs" % key 8550 ) 8551 params[key] = val 8552 del params['kwargs'] 8553 # verify the required parameter 'account_id' is set 8554 if ('account_id' not in params) or (params['account_id'] is None): 8555 raise ValueError("Missing the required parameter `account_id` when calling `get_page_tabs`") 8556 # verify the required parameter 'document_id' is set 8557 if ('document_id' not in params) or (params['document_id'] is None): 8558 raise ValueError("Missing the required parameter `document_id` when calling `get_page_tabs`") 8559 # verify the required parameter 'envelope_id' is set 8560 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8561 raise ValueError("Missing the required parameter `envelope_id` when calling `get_page_tabs`") 8562 # verify the required parameter 'page_number' is set 8563 if ('page_number' not in params) or (params['page_number'] is None): 8564 raise ValueError("Missing the required parameter `page_number` when calling `get_page_tabs`") 8565 8566 8567 collection_formats = {} 8568 8569 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/pages/{pageNumber}/tabs'.replace('{format}', 'json') 8570 path_params = {} 8571 if 'account_id' in params: 8572 path_params['accountId'] = params['account_id'] 8573 if 'document_id' in params: 8574 path_params['documentId'] = params['document_id'] 8575 if 'envelope_id' in params: 8576 path_params['envelopeId'] = params['envelope_id'] 8577 if 'page_number' in params: 8578 path_params['pageNumber'] = params['page_number'] 8579 8580 query_params = {} 8581 8582 header_params = {} 8583 8584 form_params = [] 8585 local_var_files = {} 8586 8587 body_params = None 8588 # HTTP header `Accept` 8589 header_params['Accept'] = self.api_client.\ 8590 select_header_accept(['application/json']) 8591 8592 # Authentication setting 8593 auth_settings = [] 8594 8595 return self.api_client.call_api(resource_path, 'GET', 8596 path_params, 8597 query_params, 8598 header_params, 8599 body=body_params, 8600 post_params=form_params, 8601 files=local_var_files, 8602 response_type='Tabs', 8603 auth_settings=auth_settings, 8604 callback=params.get('callback'), 8605 _return_http_data_only=params.get('_return_http_data_only'), 8606 _preload_content=params.get('_preload_content', True), 8607 _request_timeout=params.get('_request_timeout'), 8608 collection_formats=collection_formats) 8609 8610 def get_pages(self, account_id, document_id, envelope_id, **kwargs): 8611 """ 8612 Returns document page image(s) based on input. 8613 Returns images of the pages in a document for display based on the parameters that you specify. 8614 This method makes a synchronous HTTP request by default. To make an 8615 asynchronous HTTP request, please define a `callback` function 8616 to be invoked when receiving the response. 8617 >>> def callback_function(response): 8618 >>> pprint(response) 8619 >>> 8620 >>> thread = api.get_pages(account_id, document_id, envelope_id, callback=callback_function) 8621 8622 :param callback function: The callback function 8623 for asynchronous request. (optional) 8624 :param str account_id: The external account number (int) or account ID Guid. (required) 8625 :param str document_id: The ID of the document being accessed. (required) 8626 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8627 :param str count: 8628 :param str dpi: 8629 :param str max_height: 8630 :param str max_width: 8631 :param str nocache: 8632 :param str show_changes: 8633 :param str start_position: 8634 :return: PageImages 8635 If the method is called asynchronously, 8636 returns the request thread. 8637 """ 8638 kwargs['_return_http_data_only'] = True 8639 if kwargs.get('callback'): 8640 return self.get_pages_with_http_info(account_id, document_id, envelope_id, **kwargs) 8641 else: 8642 (data) = self.get_pages_with_http_info(account_id, document_id, envelope_id, **kwargs) 8643 return data 8644 8645 def get_pages_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 8646 """ 8647 Returns document page image(s) based on input. 8648 Returns images of the pages in a document for display based on the parameters that you specify. 8649 This method makes a synchronous HTTP request by default. To make an 8650 asynchronous HTTP request, please define a `callback` function 8651 to be invoked when receiving the response. 8652 >>> def callback_function(response): 8653 >>> pprint(response) 8654 >>> 8655 >>> thread = api.get_pages_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 8656 8657 :param callback function: The callback function 8658 for asynchronous request. (optional) 8659 :param str account_id: The external account number (int) or account ID Guid. (required) 8660 :param str document_id: The ID of the document being accessed. (required) 8661 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8662 :param str count: 8663 :param str dpi: 8664 :param str max_height: 8665 :param str max_width: 8666 :param str nocache: 8667 :param str show_changes: 8668 :param str start_position: 8669 :return: PageImages 8670 If the method is called asynchronously, 8671 returns the request thread. 8672 """ 8673 8674 all_params = ['account_id', 'document_id', 'envelope_id', 'count', 'dpi', 'max_height', 'max_width', 'nocache', 'show_changes', 'start_position'] 8675 all_params.append('callback') 8676 all_params.append('_return_http_data_only') 8677 all_params.append('_preload_content') 8678 all_params.append('_request_timeout') 8679 8680 params = locals() 8681 for key, val in iteritems(params['kwargs']): 8682 if key not in all_params: 8683 raise TypeError( 8684 "Got an unexpected keyword argument '%s'" 8685 " to method get_pages" % key 8686 ) 8687 params[key] = val 8688 del params['kwargs'] 8689 # verify the required parameter 'account_id' is set 8690 if ('account_id' not in params) or (params['account_id'] is None): 8691 raise ValueError("Missing the required parameter `account_id` when calling `get_pages`") 8692 # verify the required parameter 'document_id' is set 8693 if ('document_id' not in params) or (params['document_id'] is None): 8694 raise ValueError("Missing the required parameter `document_id` when calling `get_pages`") 8695 # verify the required parameter 'envelope_id' is set 8696 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8697 raise ValueError("Missing the required parameter `envelope_id` when calling `get_pages`") 8698 8699 8700 collection_formats = {} 8701 8702 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/pages'.replace('{format}', 'json') 8703 path_params = {} 8704 if 'account_id' in params: 8705 path_params['accountId'] = params['account_id'] 8706 if 'document_id' in params: 8707 path_params['documentId'] = params['document_id'] 8708 if 'envelope_id' in params: 8709 path_params['envelopeId'] = params['envelope_id'] 8710 8711 query_params = {} 8712 if 'count' in params: 8713 query_params['count'] = params['count'] 8714 if 'dpi' in params: 8715 query_params['dpi'] = params['dpi'] 8716 if 'max_height' in params: 8717 query_params['max_height'] = params['max_height'] 8718 if 'max_width' in params: 8719 query_params['max_width'] = params['max_width'] 8720 if 'nocache' in params: 8721 query_params['nocache'] = params['nocache'] 8722 if 'show_changes' in params: 8723 query_params['show_changes'] = params['show_changes'] 8724 if 'start_position' in params: 8725 query_params['start_position'] = params['start_position'] 8726 8727 header_params = {} 8728 8729 form_params = [] 8730 local_var_files = {} 8731 8732 body_params = None 8733 # HTTP header `Accept` 8734 header_params['Accept'] = self.api_client.\ 8735 select_header_accept(['application/json']) 8736 8737 # Authentication setting 8738 auth_settings = [] 8739 8740 return self.api_client.call_api(resource_path, 'GET', 8741 path_params, 8742 query_params, 8743 header_params, 8744 body=body_params, 8745 post_params=form_params, 8746 files=local_var_files, 8747 response_type='PageImages', 8748 auth_settings=auth_settings, 8749 callback=params.get('callback'), 8750 _return_http_data_only=params.get('_return_http_data_only'), 8751 _preload_content=params.get('_preload_content', True), 8752 _request_timeout=params.get('_request_timeout'), 8753 collection_formats=collection_formats) 8754 8755 def get_recipient_document_visibility(self, account_id, envelope_id, recipient_id, **kwargs): 8756 """ 8757 Returns document visibility for the recipients 8758 This method returns information about document visibility for a recipient. 8759 This method makes a synchronous HTTP request by default. To make an 8760 asynchronous HTTP request, please define a `callback` function 8761 to be invoked when receiving the response. 8762 >>> def callback_function(response): 8763 >>> pprint(response) 8764 >>> 8765 >>> thread = api.get_recipient_document_visibility(account_id, envelope_id, recipient_id, callback=callback_function) 8766 8767 :param callback function: The callback function 8768 for asynchronous request. (optional) 8769 :param str account_id: The external account number (int) or account ID Guid. (required) 8770 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8771 :param str recipient_id: The ID of the recipient being accessed. (required) 8772 :return: DocumentVisibilityList 8773 If the method is called asynchronously, 8774 returns the request thread. 8775 """ 8776 kwargs['_return_http_data_only'] = True 8777 if kwargs.get('callback'): 8778 return self.get_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 8779 else: 8780 (data) = self.get_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 8781 return data 8782 8783 def get_recipient_document_visibility_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 8784 """ 8785 Returns document visibility for the recipients 8786 This method returns information about document visibility for a recipient. 8787 This method makes a synchronous HTTP request by default. To make an 8788 asynchronous HTTP request, please define a `callback` function 8789 to be invoked when receiving the response. 8790 >>> def callback_function(response): 8791 >>> pprint(response) 8792 >>> 8793 >>> thread = api.get_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 8794 8795 :param callback function: The callback function 8796 for asynchronous request. (optional) 8797 :param str account_id: The external account number (int) or account ID Guid. (required) 8798 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8799 :param str recipient_id: The ID of the recipient being accessed. (required) 8800 :return: DocumentVisibilityList 8801 If the method is called asynchronously, 8802 returns the request thread. 8803 """ 8804 8805 all_params = ['account_id', 'envelope_id', 'recipient_id'] 8806 all_params.append('callback') 8807 all_params.append('_return_http_data_only') 8808 all_params.append('_preload_content') 8809 all_params.append('_request_timeout') 8810 8811 params = locals() 8812 for key, val in iteritems(params['kwargs']): 8813 if key not in all_params: 8814 raise TypeError( 8815 "Got an unexpected keyword argument '%s'" 8816 " to method get_recipient_document_visibility" % key 8817 ) 8818 params[key] = val 8819 del params['kwargs'] 8820 # verify the required parameter 'account_id' is set 8821 if ('account_id' not in params) or (params['account_id'] is None): 8822 raise ValueError("Missing the required parameter `account_id` when calling `get_recipient_document_visibility`") 8823 # verify the required parameter 'envelope_id' is set 8824 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8825 raise ValueError("Missing the required parameter `envelope_id` when calling `get_recipient_document_visibility`") 8826 # verify the required parameter 'recipient_id' is set 8827 if ('recipient_id' not in params) or (params['recipient_id'] is None): 8828 raise ValueError("Missing the required parameter `recipient_id` when calling `get_recipient_document_visibility`") 8829 8830 8831 collection_formats = {} 8832 8833 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/document_visibility'.replace('{format}', 'json') 8834 path_params = {} 8835 if 'account_id' in params: 8836 path_params['accountId'] = params['account_id'] 8837 if 'envelope_id' in params: 8838 path_params['envelopeId'] = params['envelope_id'] 8839 if 'recipient_id' in params: 8840 path_params['recipientId'] = params['recipient_id'] 8841 8842 query_params = {} 8843 8844 header_params = {} 8845 8846 form_params = [] 8847 local_var_files = {} 8848 8849 body_params = None 8850 # HTTP header `Accept` 8851 header_params['Accept'] = self.api_client.\ 8852 select_header_accept(['application/json']) 8853 8854 # Authentication setting 8855 auth_settings = [] 8856 8857 return self.api_client.call_api(resource_path, 'GET', 8858 path_params, 8859 query_params, 8860 header_params, 8861 body=body_params, 8862 post_params=form_params, 8863 files=local_var_files, 8864 response_type='DocumentVisibilityList', 8865 auth_settings=auth_settings, 8866 callback=params.get('callback'), 8867 _return_http_data_only=params.get('_return_http_data_only'), 8868 _preload_content=params.get('_preload_content', True), 8869 _request_timeout=params.get('_request_timeout'), 8870 collection_formats=collection_formats) 8871 8872 def get_recipient_initials_image(self, account_id, envelope_id, recipient_id, **kwargs): 8873 """ 8874 Gets the initials image for a user. 8875 Retrieves the initials image for the specified user. The image is returned in the same format as it was uploaded. In the request you can specify if the chrome (the added line and identifier around the initial image) is returned with the image. The userId specified in the endpoint must match the authenticated user's user id and the user must be a member of the account. The `signatureIdOrName` paramter accepts signature ID or signature name. DocuSign recommends you use signature ID (`signatureId`), since some names contain characters that do not properly URL encode. If you use the user name, it is likely that the name includes spaces and you might need to URL encode the name before using it in the endpoint. For example: \"Bob Smith\" to \"Bob%20Smith\" Older envelopes might only contain chromed images. If getting the non-chromed image fails, try getting the chromed image. 8876 This method makes a synchronous HTTP request by default. To make an 8877 asynchronous HTTP request, please define a `callback` function 8878 to be invoked when receiving the response. 8879 >>> def callback_function(response): 8880 >>> pprint(response) 8881 >>> 8882 >>> thread = api.get_recipient_initials_image(account_id, envelope_id, recipient_id, callback=callback_function) 8883 8884 :param callback function: The callback function 8885 for asynchronous request. (optional) 8886 :param str account_id: The external account number (int) or account ID Guid. (required) 8887 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8888 :param str recipient_id: The ID of the recipient being accessed. (required) 8889 :param str include_chrome: The added line and identifier around the initial image. Note: Older envelopes might only have chromed images. If getting the non-chromed image fails, try getting the chromed image. 8890 :return: file 8891 If the method is called asynchronously, 8892 returns the request thread. 8893 """ 8894 kwargs['_return_http_data_only'] = True 8895 if kwargs.get('callback'): 8896 return self.get_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 8897 else: 8898 (data) = self.get_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 8899 return data 8900 8901 def get_recipient_initials_image_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 8902 """ 8903 Gets the initials image for a user. 8904 Retrieves the initials image for the specified user. The image is returned in the same format as it was uploaded. In the request you can specify if the chrome (the added line and identifier around the initial image) is returned with the image. The userId specified in the endpoint must match the authenticated user's user id and the user must be a member of the account. The `signatureIdOrName` paramter accepts signature ID or signature name. DocuSign recommends you use signature ID (`signatureId`), since some names contain characters that do not properly URL encode. If you use the user name, it is likely that the name includes spaces and you might need to URL encode the name before using it in the endpoint. For example: \"Bob Smith\" to \"Bob%20Smith\" Older envelopes might only contain chromed images. If getting the non-chromed image fails, try getting the chromed image. 8905 This method makes a synchronous HTTP request by default. To make an 8906 asynchronous HTTP request, please define a `callback` function 8907 to be invoked when receiving the response. 8908 >>> def callback_function(response): 8909 >>> pprint(response) 8910 >>> 8911 >>> thread = api.get_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 8912 8913 :param callback function: The callback function 8914 for asynchronous request. (optional) 8915 :param str account_id: The external account number (int) or account ID Guid. (required) 8916 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 8917 :param str recipient_id: The ID of the recipient being accessed. (required) 8918 :param str include_chrome: The added line and identifier around the initial image. Note: Older envelopes might only have chromed images. If getting the non-chromed image fails, try getting the chromed image. 8919 :return: file 8920 If the method is called asynchronously, 8921 returns the request thread. 8922 """ 8923 8924 all_params = ['account_id', 'envelope_id', 'recipient_id', 'include_chrome'] 8925 all_params.append('callback') 8926 all_params.append('_return_http_data_only') 8927 all_params.append('_preload_content') 8928 all_params.append('_request_timeout') 8929 8930 params = locals() 8931 for key, val in iteritems(params['kwargs']): 8932 if key not in all_params: 8933 raise TypeError( 8934 "Got an unexpected keyword argument '%s'" 8935 " to method get_recipient_initials_image" % key 8936 ) 8937 params[key] = val 8938 del params['kwargs'] 8939 # verify the required parameter 'account_id' is set 8940 if ('account_id' not in params) or (params['account_id'] is None): 8941 raise ValueError("Missing the required parameter `account_id` when calling `get_recipient_initials_image`") 8942 # verify the required parameter 'envelope_id' is set 8943 if ('envelope_id' not in params) or (params['envelope_id'] is None): 8944 raise ValueError("Missing the required parameter `envelope_id` when calling `get_recipient_initials_image`") 8945 # verify the required parameter 'recipient_id' is set 8946 if ('recipient_id' not in params) or (params['recipient_id'] is None): 8947 raise ValueError("Missing the required parameter `recipient_id` when calling `get_recipient_initials_image`") 8948 8949 8950 collection_formats = {} 8951 8952 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/initials_image'.replace('{format}', 'json') 8953 path_params = {} 8954 if 'account_id' in params: 8955 path_params['accountId'] = params['account_id'] 8956 if 'envelope_id' in params: 8957 path_params['envelopeId'] = params['envelope_id'] 8958 if 'recipient_id' in params: 8959 path_params['recipientId'] = params['recipient_id'] 8960 8961 query_params = {} 8962 if 'include_chrome' in params: 8963 query_params['include_chrome'] = params['include_chrome'] 8964 8965 header_params = {} 8966 8967 form_params = [] 8968 local_var_files = {} 8969 8970 body_params = None 8971 # HTTP header `Accept` 8972 header_params['Accept'] = self.api_client.\ 8973 select_header_accept(['image/gif']) 8974 8975 # Authentication setting 8976 auth_settings = [] 8977 8978 return self.api_client.call_api(resource_path, 'GET', 8979 path_params, 8980 query_params, 8981 header_params, 8982 body=body_params, 8983 post_params=form_params, 8984 files=local_var_files, 8985 response_type='file', 8986 auth_settings=auth_settings, 8987 callback=params.get('callback'), 8988 _return_http_data_only=params.get('_return_http_data_only'), 8989 _preload_content=params.get('_preload_content', True), 8990 _request_timeout=params.get('_request_timeout'), 8991 collection_formats=collection_formats) 8992 8993 def get_recipient_signature(self, account_id, envelope_id, recipient_id, **kwargs): 8994 """ 8995 Gets signature information for a signer or sign-in-person recipient. 8996 Retrieves signature information for a signer or sign-in-person recipient. 8997 This method makes a synchronous HTTP request by default. To make an 8998 asynchronous HTTP request, please define a `callback` function 8999 to be invoked when receiving the response. 9000 >>> def callback_function(response): 9001 >>> pprint(response) 9002 >>> 9003 >>> thread = api.get_recipient_signature(account_id, envelope_id, recipient_id, callback=callback_function) 9004 9005 :param callback function: The callback function 9006 for asynchronous request. (optional) 9007 :param str account_id: The external account number (int) or account ID Guid. (required) 9008 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9009 :param str recipient_id: The ID of the recipient being accessed. (required) 9010 :return: UserSignature 9011 If the method is called asynchronously, 9012 returns the request thread. 9013 """ 9014 kwargs['_return_http_data_only'] = True 9015 if kwargs.get('callback'): 9016 return self.get_recipient_signature_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 9017 else: 9018 (data) = self.get_recipient_signature_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 9019 return data 9020 9021 def get_recipient_signature_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 9022 """ 9023 Gets signature information for a signer or sign-in-person recipient. 9024 Retrieves signature information for a signer or sign-in-person recipient. 9025 This method makes a synchronous HTTP request by default. To make an 9026 asynchronous HTTP request, please define a `callback` function 9027 to be invoked when receiving the response. 9028 >>> def callback_function(response): 9029 >>> pprint(response) 9030 >>> 9031 >>> thread = api.get_recipient_signature_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 9032 9033 :param callback function: The callback function 9034 for asynchronous request. (optional) 9035 :param str account_id: The external account number (int) or account ID Guid. (required) 9036 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9037 :param str recipient_id: The ID of the recipient being accessed. (required) 9038 :return: UserSignature 9039 If the method is called asynchronously, 9040 returns the request thread. 9041 """ 9042 9043 all_params = ['account_id', 'envelope_id', 'recipient_id'] 9044 all_params.append('callback') 9045 all_params.append('_return_http_data_only') 9046 all_params.append('_preload_content') 9047 all_params.append('_request_timeout') 9048 9049 params = locals() 9050 for key, val in iteritems(params['kwargs']): 9051 if key not in all_params: 9052 raise TypeError( 9053 "Got an unexpected keyword argument '%s'" 9054 " to method get_recipient_signature" % key 9055 ) 9056 params[key] = val 9057 del params['kwargs'] 9058 # verify the required parameter 'account_id' is set 9059 if ('account_id' not in params) or (params['account_id'] is None): 9060 raise ValueError("Missing the required parameter `account_id` when calling `get_recipient_signature`") 9061 # verify the required parameter 'envelope_id' is set 9062 if ('envelope_id' not in params) or (params['envelope_id'] is None): 9063 raise ValueError("Missing the required parameter `envelope_id` when calling `get_recipient_signature`") 9064 # verify the required parameter 'recipient_id' is set 9065 if ('recipient_id' not in params) or (params['recipient_id'] is None): 9066 raise ValueError("Missing the required parameter `recipient_id` when calling `get_recipient_signature`") 9067 9068 9069 collection_formats = {} 9070 9071 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/signature'.replace('{format}', 'json') 9072 path_params = {} 9073 if 'account_id' in params: 9074 path_params['accountId'] = params['account_id'] 9075 if 'envelope_id' in params: 9076 path_params['envelopeId'] = params['envelope_id'] 9077 if 'recipient_id' in params: 9078 path_params['recipientId'] = params['recipient_id'] 9079 9080 query_params = {} 9081 9082 header_params = {} 9083 9084 form_params = [] 9085 local_var_files = {} 9086 9087 body_params = None 9088 # HTTP header `Accept` 9089 header_params['Accept'] = self.api_client.\ 9090 select_header_accept(['application/json']) 9091 9092 # Authentication setting 9093 auth_settings = [] 9094 9095 return self.api_client.call_api(resource_path, 'GET', 9096 path_params, 9097 query_params, 9098 header_params, 9099 body=body_params, 9100 post_params=form_params, 9101 files=local_var_files, 9102 response_type='UserSignature', 9103 auth_settings=auth_settings, 9104 callback=params.get('callback'), 9105 _return_http_data_only=params.get('_return_http_data_only'), 9106 _preload_content=params.get('_preload_content', True), 9107 _request_timeout=params.get('_request_timeout'), 9108 collection_formats=collection_formats) 9109 9110 def get_recipient_signature_image(self, account_id, envelope_id, recipient_id, **kwargs): 9111 """ 9112 Retrieve signature image information for a signer/sign-in-person recipient. 9113 Retrieves the specified user signature image. The image is returned in the same format as uploaded. In the request you can specify if the chrome (the added line and identifier around the initial image) is returned with the image. The userId specified in the endpoint must match the authenticated user's user ID and the user must be a member of the account. The `signatureIdOrName` parameter accepts signature ID or signature name. DocuSign recommends you use signature ID (`signatureId`), since some names contain characters that don't properly URL encode. If you use the user name, it is likely that the name includes spaces and you might need to URL encode the name before using it in the endpoint. For example: \"Bob Smith\" to \"Bob%20Smith\" Older envelopes might only have chromed images. If getting the non-chromed image fails, try getting the chromed image. 9114 This method makes a synchronous HTTP request by default. To make an 9115 asynchronous HTTP request, please define a `callback` function 9116 to be invoked when receiving the response. 9117 >>> def callback_function(response): 9118 >>> pprint(response) 9119 >>> 9120 >>> thread = api.get_recipient_signature_image(account_id, envelope_id, recipient_id, callback=callback_function) 9121 9122 :param callback function: The callback function 9123 for asynchronous request. (optional) 9124 :param str account_id: The external account number (int) or account ID Guid. (required) 9125 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9126 :param str recipient_id: The ID of the recipient being accessed. (required) 9127 :param str include_chrome: When set to **true**, indicates the chromed version of the signature image should be retrieved. 9128 :return: file 9129 If the method is called asynchronously, 9130 returns the request thread. 9131 """ 9132 kwargs['_return_http_data_only'] = True 9133 if kwargs.get('callback'): 9134 return self.get_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 9135 else: 9136 (data) = self.get_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 9137 return data 9138 9139 def get_recipient_signature_image_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 9140 """ 9141 Retrieve signature image information for a signer/sign-in-person recipient. 9142 Retrieves the specified user signature image. The image is returned in the same format as uploaded. In the request you can specify if the chrome (the added line and identifier around the initial image) is returned with the image. The userId specified in the endpoint must match the authenticated user's user ID and the user must be a member of the account. The `signatureIdOrName` parameter accepts signature ID or signature name. DocuSign recommends you use signature ID (`signatureId`), since some names contain characters that don't properly URL encode. If you use the user name, it is likely that the name includes spaces and you might need to URL encode the name before using it in the endpoint. For example: \"Bob Smith\" to \"Bob%20Smith\" Older envelopes might only have chromed images. If getting the non-chromed image fails, try getting the chromed image. 9143 This method makes a synchronous HTTP request by default. To make an 9144 asynchronous HTTP request, please define a `callback` function 9145 to be invoked when receiving the response. 9146 >>> def callback_function(response): 9147 >>> pprint(response) 9148 >>> 9149 >>> thread = api.get_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 9150 9151 :param callback function: The callback function 9152 for asynchronous request. (optional) 9153 :param str account_id: The external account number (int) or account ID Guid. (required) 9154 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9155 :param str recipient_id: The ID of the recipient being accessed. (required) 9156 :param str include_chrome: When set to **true**, indicates the chromed version of the signature image should be retrieved. 9157 :return: file 9158 If the method is called asynchronously, 9159 returns the request thread. 9160 """ 9161 9162 all_params = ['account_id', 'envelope_id', 'recipient_id', 'include_chrome'] 9163 all_params.append('callback') 9164 all_params.append('_return_http_data_only') 9165 all_params.append('_preload_content') 9166 all_params.append('_request_timeout') 9167 9168 params = locals() 9169 for key, val in iteritems(params['kwargs']): 9170 if key not in all_params: 9171 raise TypeError( 9172 "Got an unexpected keyword argument '%s'" 9173 " to method get_recipient_signature_image" % key 9174 ) 9175 params[key] = val 9176 del params['kwargs'] 9177 # verify the required parameter 'account_id' is set 9178 if ('account_id' not in params) or (params['account_id'] is None): 9179 raise ValueError("Missing the required parameter `account_id` when calling `get_recipient_signature_image`") 9180 # verify the required parameter 'envelope_id' is set 9181 if ('envelope_id' not in params) or (params['envelope_id'] is None): 9182 raise ValueError("Missing the required parameter `envelope_id` when calling `get_recipient_signature_image`") 9183 # verify the required parameter 'recipient_id' is set 9184 if ('recipient_id' not in params) or (params['recipient_id'] is None): 9185 raise ValueError("Missing the required parameter `recipient_id` when calling `get_recipient_signature_image`") 9186 9187 9188 collection_formats = {} 9189 9190 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/signature_image'.replace('{format}', 'json') 9191 path_params = {} 9192 if 'account_id' in params: 9193 path_params['accountId'] = params['account_id'] 9194 if 'envelope_id' in params: 9195 path_params['envelopeId'] = params['envelope_id'] 9196 if 'recipient_id' in params: 9197 path_params['recipientId'] = params['recipient_id'] 9198 9199 query_params = {} 9200 if 'include_chrome' in params: 9201 query_params['include_chrome'] = params['include_chrome'] 9202 9203 header_params = {} 9204 9205 form_params = [] 9206 local_var_files = {} 9207 9208 body_params = None 9209 # HTTP header `Accept` 9210 header_params['Accept'] = self.api_client.\ 9211 select_header_accept(['image/gif']) 9212 9213 # Authentication setting 9214 auth_settings = [] 9215 9216 return self.api_client.call_api(resource_path, 'GET', 9217 path_params, 9218 query_params, 9219 header_params, 9220 body=body_params, 9221 post_params=form_params, 9222 files=local_var_files, 9223 response_type='file', 9224 auth_settings=auth_settings, 9225 callback=params.get('callback'), 9226 _return_http_data_only=params.get('_return_http_data_only'), 9227 _preload_content=params.get('_preload_content', True), 9228 _request_timeout=params.get('_request_timeout'), 9229 collection_formats=collection_formats) 9230 9231 def get_tabs_blob(self, account_id, envelope_id, **kwargs): 9232 """ 9233 Get encrypted tabs for envelope. 9234 9235 This method makes a synchronous HTTP request by default. To make an 9236 asynchronous HTTP request, please define a `callback` function 9237 to be invoked when receiving the response. 9238 >>> def callback_function(response): 9239 >>> pprint(response) 9240 >>> 9241 >>> thread = api.get_tabs_blob(account_id, envelope_id, callback=callback_function) 9242 9243 :param callback function: The callback function 9244 for asynchronous request. (optional) 9245 :param str account_id: The external account number (int) or account ID Guid. (required) 9246 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9247 :return: None 9248 If the method is called asynchronously, 9249 returns the request thread. 9250 """ 9251 kwargs['_return_http_data_only'] = True 9252 if kwargs.get('callback'): 9253 return self.get_tabs_blob_with_http_info(account_id, envelope_id, **kwargs) 9254 else: 9255 (data) = self.get_tabs_blob_with_http_info(account_id, envelope_id, **kwargs) 9256 return data 9257 9258 def get_tabs_blob_with_http_info(self, account_id, envelope_id, **kwargs): 9259 """ 9260 Get encrypted tabs for envelope. 9261 9262 This method makes a synchronous HTTP request by default. To make an 9263 asynchronous HTTP request, please define a `callback` function 9264 to be invoked when receiving the response. 9265 >>> def callback_function(response): 9266 >>> pprint(response) 9267 >>> 9268 >>> thread = api.get_tabs_blob_with_http_info(account_id, envelope_id, callback=callback_function) 9269 9270 :param callback function: The callback function 9271 for asynchronous request. (optional) 9272 :param str account_id: The external account number (int) or account ID Guid. (required) 9273 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9274 :return: None 9275 If the method is called asynchronously, 9276 returns the request thread. 9277 """ 9278 9279 all_params = ['account_id', 'envelope_id'] 9280 all_params.append('callback') 9281 all_params.append('_return_http_data_only') 9282 all_params.append('_preload_content') 9283 all_params.append('_request_timeout') 9284 9285 params = locals() 9286 for key, val in iteritems(params['kwargs']): 9287 if key not in all_params: 9288 raise TypeError( 9289 "Got an unexpected keyword argument '%s'" 9290 " to method get_tabs_blob" % key 9291 ) 9292 params[key] = val 9293 del params['kwargs'] 9294 # verify the required parameter 'account_id' is set 9295 if ('account_id' not in params) or (params['account_id'] is None): 9296 raise ValueError("Missing the required parameter `account_id` when calling `get_tabs_blob`") 9297 # verify the required parameter 'envelope_id' is set 9298 if ('envelope_id' not in params) or (params['envelope_id'] is None): 9299 raise ValueError("Missing the required parameter `envelope_id` when calling `get_tabs_blob`") 9300 9301 9302 collection_formats = {} 9303 9304 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/tabs_blob'.replace('{format}', 'json') 9305 path_params = {} 9306 if 'account_id' in params: 9307 path_params['accountId'] = params['account_id'] 9308 if 'envelope_id' in params: 9309 path_params['envelopeId'] = params['envelope_id'] 9310 9311 query_params = {} 9312 9313 header_params = {} 9314 9315 form_params = [] 9316 local_var_files = {} 9317 9318 body_params = None 9319 # HTTP header `Accept` 9320 header_params['Accept'] = self.api_client.\ 9321 select_header_accept(['application/json']) 9322 9323 # Authentication setting 9324 auth_settings = [] 9325 9326 return self.api_client.call_api(resource_path, 'GET', 9327 path_params, 9328 query_params, 9329 header_params, 9330 body=body_params, 9331 post_params=form_params, 9332 files=local_var_files, 9333 response_type=None, 9334 auth_settings=auth_settings, 9335 callback=params.get('callback'), 9336 _return_http_data_only=params.get('_return_http_data_only'), 9337 _preload_content=params.get('_preload_content', True), 9338 _request_timeout=params.get('_request_timeout'), 9339 collection_formats=collection_formats) 9340 9341 def get_template_delayed_routing_definition(self, account_id, template_id, workflow_step_id, **kwargs): 9342 """ 9343 Returns the delayed routing rules for a template's workflow step definition. 9344 This method makes a synchronous HTTP request by default. To make an 9345 asynchronous HTTP request, please define a `callback` function 9346 to be invoked when receiving the response. 9347 >>> def callback_function(response): 9348 >>> pprint(response) 9349 >>> 9350 >>> thread = api.get_template_delayed_routing_definition(account_id, template_id, workflow_step_id, callback=callback_function) 9351 9352 :param callback function: The callback function 9353 for asynchronous request. (optional) 9354 :param str account_id: The external account number (int) or account ID Guid. (required) 9355 :param str template_id: The ID of the template being accessed. (required) 9356 :param str workflow_step_id: (required) 9357 :return: DelayedRouting 9358 If the method is called asynchronously, 9359 returns the request thread. 9360 """ 9361 kwargs['_return_http_data_only'] = True 9362 if kwargs.get('callback'): 9363 return self.get_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 9364 else: 9365 (data) = self.get_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 9366 return data 9367 9368 def get_template_delayed_routing_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 9369 """ 9370 Returns the delayed routing rules for a template's workflow step definition. 9371 This method makes a synchronous HTTP request by default. To make an 9372 asynchronous HTTP request, please define a `callback` function 9373 to be invoked when receiving the response. 9374 >>> def callback_function(response): 9375 >>> pprint(response) 9376 >>> 9377 >>> thread = api.get_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 9378 9379 :param callback function: The callback function 9380 for asynchronous request. (optional) 9381 :param str account_id: The external account number (int) or account ID Guid. (required) 9382 :param str template_id: The ID of the template being accessed. (required) 9383 :param str workflow_step_id: (required) 9384 :return: DelayedRouting 9385 If the method is called asynchronously, 9386 returns the request thread. 9387 """ 9388 9389 all_params = ['account_id', 'template_id', 'workflow_step_id'] 9390 all_params.append('callback') 9391 all_params.append('_return_http_data_only') 9392 all_params.append('_preload_content') 9393 all_params.append('_request_timeout') 9394 9395 params = locals() 9396 for key, val in iteritems(params['kwargs']): 9397 if key not in all_params: 9398 raise TypeError( 9399 "Got an unexpected keyword argument '%s'" 9400 " to method get_template_delayed_routing_definition" % key 9401 ) 9402 params[key] = val 9403 del params['kwargs'] 9404 # verify the required parameter 'account_id' is set 9405 if ('account_id' not in params) or (params['account_id'] is None): 9406 raise ValueError("Missing the required parameter `account_id` when calling `get_template_delayed_routing_definition`") 9407 # verify the required parameter 'template_id' is set 9408 if ('template_id' not in params) or (params['template_id'] is None): 9409 raise ValueError("Missing the required parameter `template_id` when calling `get_template_delayed_routing_definition`") 9410 # verify the required parameter 'workflow_step_id' is set 9411 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 9412 raise ValueError("Missing the required parameter `workflow_step_id` when calling `get_template_delayed_routing_definition`") 9413 9414 9415 collection_formats = {} 9416 9417 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 9418 path_params = {} 9419 if 'account_id' in params: 9420 path_params['accountId'] = params['account_id'] 9421 if 'template_id' in params: 9422 path_params['templateId'] = params['template_id'] 9423 if 'workflow_step_id' in params: 9424 path_params['workflowStepId'] = params['workflow_step_id'] 9425 9426 query_params = {} 9427 9428 header_params = {} 9429 9430 form_params = [] 9431 local_var_files = {} 9432 9433 body_params = None 9434 # HTTP header `Accept` 9435 header_params['Accept'] = self.api_client.\ 9436 select_header_accept(['application/json']) 9437 9438 # Authentication setting 9439 auth_settings = [] 9440 9441 return self.api_client.call_api(resource_path, 'GET', 9442 path_params, 9443 query_params, 9444 header_params, 9445 body=body_params, 9446 post_params=form_params, 9447 files=local_var_files, 9448 response_type='DelayedRouting', 9449 auth_settings=auth_settings, 9450 callback=params.get('callback'), 9451 _return_http_data_only=params.get('_return_http_data_only'), 9452 _preload_content=params.get('_preload_content', True), 9453 _request_timeout=params.get('_request_timeout'), 9454 collection_formats=collection_formats) 9455 9456 def get_template_recipient_document_visibility(self, account_id, recipient_id, template_id, **kwargs): 9457 """ 9458 Returns document visibility for the recipients 9459 This method returns information about document visibility for a template recipient. 9460 This method makes a synchronous HTTP request by default. To make an 9461 asynchronous HTTP request, please define a `callback` function 9462 to be invoked when receiving the response. 9463 >>> def callback_function(response): 9464 >>> pprint(response) 9465 >>> 9466 >>> thread = api.get_template_recipient_document_visibility(account_id, recipient_id, template_id, callback=callback_function) 9467 9468 :param callback function: The callback function 9469 for asynchronous request. (optional) 9470 :param str account_id: The external account number (int) or account ID Guid. (required) 9471 :param str recipient_id: The ID of the recipient being accessed. (required) 9472 :param str template_id: The ID of the template being accessed. (required) 9473 :return: DocumentVisibilityList 9474 If the method is called asynchronously, 9475 returns the request thread. 9476 """ 9477 kwargs['_return_http_data_only'] = True 9478 if kwargs.get('callback'): 9479 return self.get_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, **kwargs) 9480 else: 9481 (data) = self.get_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, **kwargs) 9482 return data 9483 9484 def get_template_recipient_document_visibility_with_http_info(self, account_id, recipient_id, template_id, **kwargs): 9485 """ 9486 Returns document visibility for the recipients 9487 This method returns information about document visibility for a template recipient. 9488 This method makes a synchronous HTTP request by default. To make an 9489 asynchronous HTTP request, please define a `callback` function 9490 to be invoked when receiving the response. 9491 >>> def callback_function(response): 9492 >>> pprint(response) 9493 >>> 9494 >>> thread = api.get_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, callback=callback_function) 9495 9496 :param callback function: The callback function 9497 for asynchronous request. (optional) 9498 :param str account_id: The external account number (int) or account ID Guid. (required) 9499 :param str recipient_id: The ID of the recipient being accessed. (required) 9500 :param str template_id: The ID of the template being accessed. (required) 9501 :return: DocumentVisibilityList 9502 If the method is called asynchronously, 9503 returns the request thread. 9504 """ 9505 9506 all_params = ['account_id', 'recipient_id', 'template_id'] 9507 all_params.append('callback') 9508 all_params.append('_return_http_data_only') 9509 all_params.append('_preload_content') 9510 all_params.append('_request_timeout') 9511 9512 params = locals() 9513 for key, val in iteritems(params['kwargs']): 9514 if key not in all_params: 9515 raise TypeError( 9516 "Got an unexpected keyword argument '%s'" 9517 " to method get_template_recipient_document_visibility" % key 9518 ) 9519 params[key] = val 9520 del params['kwargs'] 9521 # verify the required parameter 'account_id' is set 9522 if ('account_id' not in params) or (params['account_id'] is None): 9523 raise ValueError("Missing the required parameter `account_id` when calling `get_template_recipient_document_visibility`") 9524 # verify the required parameter 'recipient_id' is set 9525 if ('recipient_id' not in params) or (params['recipient_id'] is None): 9526 raise ValueError("Missing the required parameter `recipient_id` when calling `get_template_recipient_document_visibility`") 9527 # verify the required parameter 'template_id' is set 9528 if ('template_id' not in params) or (params['template_id'] is None): 9529 raise ValueError("Missing the required parameter `template_id` when calling `get_template_recipient_document_visibility`") 9530 9531 9532 collection_formats = {} 9533 9534 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/recipients/{recipientId}/document_visibility'.replace('{format}', 'json') 9535 path_params = {} 9536 if 'account_id' in params: 9537 path_params['accountId'] = params['account_id'] 9538 if 'recipient_id' in params: 9539 path_params['recipientId'] = params['recipient_id'] 9540 if 'template_id' in params: 9541 path_params['templateId'] = params['template_id'] 9542 9543 query_params = {} 9544 9545 header_params = {} 9546 9547 form_params = [] 9548 local_var_files = {} 9549 9550 body_params = None 9551 # HTTP header `Accept` 9552 header_params['Accept'] = self.api_client.\ 9553 select_header_accept(['application/json']) 9554 9555 # Authentication setting 9556 auth_settings = [] 9557 9558 return self.api_client.call_api(resource_path, 'GET', 9559 path_params, 9560 query_params, 9561 header_params, 9562 body=body_params, 9563 post_params=form_params, 9564 files=local_var_files, 9565 response_type='DocumentVisibilityList', 9566 auth_settings=auth_settings, 9567 callback=params.get('callback'), 9568 _return_http_data_only=params.get('_return_http_data_only'), 9569 _preload_content=params.get('_preload_content', True), 9570 _request_timeout=params.get('_request_timeout'), 9571 collection_formats=collection_formats) 9572 9573 def get_template_scheduled_sending_definition(self, account_id, template_id, **kwargs): 9574 """ 9575 Returns the scheduled sending rules for a template's workflow definition. 9576 This method makes a synchronous HTTP request by default. To make an 9577 asynchronous HTTP request, please define a `callback` function 9578 to be invoked when receiving the response. 9579 >>> def callback_function(response): 9580 >>> pprint(response) 9581 >>> 9582 >>> thread = api.get_template_scheduled_sending_definition(account_id, template_id, callback=callback_function) 9583 9584 :param callback function: The callback function 9585 for asynchronous request. (optional) 9586 :param str account_id: The external account number (int) or account ID Guid. (required) 9587 :param str template_id: The ID of the template being accessed. (required) 9588 :return: ScheduledSending 9589 If the method is called asynchronously, 9590 returns the request thread. 9591 """ 9592 kwargs['_return_http_data_only'] = True 9593 if kwargs.get('callback'): 9594 return self.get_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 9595 else: 9596 (data) = self.get_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 9597 return data 9598 9599 def get_template_scheduled_sending_definition_with_http_info(self, account_id, template_id, **kwargs): 9600 """ 9601 Returns the scheduled sending rules for a template's workflow definition. 9602 This method makes a synchronous HTTP request by default. To make an 9603 asynchronous HTTP request, please define a `callback` function 9604 to be invoked when receiving the response. 9605 >>> def callback_function(response): 9606 >>> pprint(response) 9607 >>> 9608 >>> thread = api.get_template_scheduled_sending_definition_with_http_info(account_id, template_id, callback=callback_function) 9609 9610 :param callback function: The callback function 9611 for asynchronous request. (optional) 9612 :param str account_id: The external account number (int) or account ID Guid. (required) 9613 :param str template_id: The ID of the template being accessed. (required) 9614 :return: ScheduledSending 9615 If the method is called asynchronously, 9616 returns the request thread. 9617 """ 9618 9619 all_params = ['account_id', 'template_id'] 9620 all_params.append('callback') 9621 all_params.append('_return_http_data_only') 9622 all_params.append('_preload_content') 9623 all_params.append('_request_timeout') 9624 9625 params = locals() 9626 for key, val in iteritems(params['kwargs']): 9627 if key not in all_params: 9628 raise TypeError( 9629 "Got an unexpected keyword argument '%s'" 9630 " to method get_template_scheduled_sending_definition" % key 9631 ) 9632 params[key] = val 9633 del params['kwargs'] 9634 # verify the required parameter 'account_id' is set 9635 if ('account_id' not in params) or (params['account_id'] is None): 9636 raise ValueError("Missing the required parameter `account_id` when calling `get_template_scheduled_sending_definition`") 9637 # verify the required parameter 'template_id' is set 9638 if ('template_id' not in params) or (params['template_id'] is None): 9639 raise ValueError("Missing the required parameter `template_id` when calling `get_template_scheduled_sending_definition`") 9640 9641 9642 collection_formats = {} 9643 9644 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/scheduledSending'.replace('{format}', 'json') 9645 path_params = {} 9646 if 'account_id' in params: 9647 path_params['accountId'] = params['account_id'] 9648 if 'template_id' in params: 9649 path_params['templateId'] = params['template_id'] 9650 9651 query_params = {} 9652 9653 header_params = {} 9654 9655 form_params = [] 9656 local_var_files = {} 9657 9658 body_params = None 9659 # HTTP header `Accept` 9660 header_params['Accept'] = self.api_client.\ 9661 select_header_accept(['application/json']) 9662 9663 # Authentication setting 9664 auth_settings = [] 9665 9666 return self.api_client.call_api(resource_path, 'GET', 9667 path_params, 9668 query_params, 9669 header_params, 9670 body=body_params, 9671 post_params=form_params, 9672 files=local_var_files, 9673 response_type='ScheduledSending', 9674 auth_settings=auth_settings, 9675 callback=params.get('callback'), 9676 _return_http_data_only=params.get('_return_http_data_only'), 9677 _preload_content=params.get('_preload_content', True), 9678 _request_timeout=params.get('_request_timeout'), 9679 collection_formats=collection_formats) 9680 9681 def get_template_workflow_definition(self, account_id, template_id, **kwargs): 9682 """ 9683 Returns the workflow definition for a template. 9684 Returns template's workflow definition if the template specified by `templateId` has one. 9685 This method makes a synchronous HTTP request by default. To make an 9686 asynchronous HTTP request, please define a `callback` function 9687 to be invoked when receiving the response. 9688 >>> def callback_function(response): 9689 >>> pprint(response) 9690 >>> 9691 >>> thread = api.get_template_workflow_definition(account_id, template_id, callback=callback_function) 9692 9693 :param callback function: The callback function 9694 for asynchronous request. (optional) 9695 :param str account_id: The external account number (int) or account ID Guid. (required) 9696 :param str template_id: The ID of the template being accessed. (required) 9697 :return: Workflow 9698 If the method is called asynchronously, 9699 returns the request thread. 9700 """ 9701 kwargs['_return_http_data_only'] = True 9702 if kwargs.get('callback'): 9703 return self.get_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 9704 else: 9705 (data) = self.get_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 9706 return data 9707 9708 def get_template_workflow_definition_with_http_info(self, account_id, template_id, **kwargs): 9709 """ 9710 Returns the workflow definition for a template. 9711 Returns template's workflow definition if the template specified by `templateId` has one. 9712 This method makes a synchronous HTTP request by default. To make an 9713 asynchronous HTTP request, please define a `callback` function 9714 to be invoked when receiving the response. 9715 >>> def callback_function(response): 9716 >>> pprint(response) 9717 >>> 9718 >>> thread = api.get_template_workflow_definition_with_http_info(account_id, template_id, callback=callback_function) 9719 9720 :param callback function: The callback function 9721 for asynchronous request. (optional) 9722 :param str account_id: The external account number (int) or account ID Guid. (required) 9723 :param str template_id: The ID of the template being accessed. (required) 9724 :return: Workflow 9725 If the method is called asynchronously, 9726 returns the request thread. 9727 """ 9728 9729 all_params = ['account_id', 'template_id'] 9730 all_params.append('callback') 9731 all_params.append('_return_http_data_only') 9732 all_params.append('_preload_content') 9733 all_params.append('_request_timeout') 9734 9735 params = locals() 9736 for key, val in iteritems(params['kwargs']): 9737 if key not in all_params: 9738 raise TypeError( 9739 "Got an unexpected keyword argument '%s'" 9740 " to method get_template_workflow_definition" % key 9741 ) 9742 params[key] = val 9743 del params['kwargs'] 9744 # verify the required parameter 'account_id' is set 9745 if ('account_id' not in params) or (params['account_id'] is None): 9746 raise ValueError("Missing the required parameter `account_id` when calling `get_template_workflow_definition`") 9747 # verify the required parameter 'template_id' is set 9748 if ('template_id' not in params) or (params['template_id'] is None): 9749 raise ValueError("Missing the required parameter `template_id` when calling `get_template_workflow_definition`") 9750 9751 9752 collection_formats = {} 9753 9754 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow'.replace('{format}', 'json') 9755 path_params = {} 9756 if 'account_id' in params: 9757 path_params['accountId'] = params['account_id'] 9758 if 'template_id' in params: 9759 path_params['templateId'] = params['template_id'] 9760 9761 query_params = {} 9762 9763 header_params = {} 9764 9765 form_params = [] 9766 local_var_files = {} 9767 9768 body_params = None 9769 # HTTP header `Accept` 9770 header_params['Accept'] = self.api_client.\ 9771 select_header_accept(['application/json']) 9772 9773 # Authentication setting 9774 auth_settings = [] 9775 9776 return self.api_client.call_api(resource_path, 'GET', 9777 path_params, 9778 query_params, 9779 header_params, 9780 body=body_params, 9781 post_params=form_params, 9782 files=local_var_files, 9783 response_type='Workflow', 9784 auth_settings=auth_settings, 9785 callback=params.get('callback'), 9786 _return_http_data_only=params.get('_return_http_data_only'), 9787 _preload_content=params.get('_preload_content', True), 9788 _request_timeout=params.get('_request_timeout'), 9789 collection_formats=collection_formats) 9790 9791 def get_template_workflow_step_definition(self, account_id, template_id, workflow_step_id, **kwargs): 9792 """ 9793 Returns the workflow step definition for a template by step id. 9794 This method makes a synchronous HTTP request by default. To make an 9795 asynchronous HTTP request, please define a `callback` function 9796 to be invoked when receiving the response. 9797 >>> def callback_function(response): 9798 >>> pprint(response) 9799 >>> 9800 >>> thread = api.get_template_workflow_step_definition(account_id, template_id, workflow_step_id, callback=callback_function) 9801 9802 :param callback function: The callback function 9803 for asynchronous request. (optional) 9804 :param str account_id: The external account number (int) or account ID Guid. (required) 9805 :param str template_id: The ID of the template being accessed. (required) 9806 :param str workflow_step_id: (required) 9807 :return: WorkflowStep 9808 If the method is called asynchronously, 9809 returns the request thread. 9810 """ 9811 kwargs['_return_http_data_only'] = True 9812 if kwargs.get('callback'): 9813 return self.get_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 9814 else: 9815 (data) = self.get_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 9816 return data 9817 9818 def get_template_workflow_step_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 9819 """ 9820 Returns the workflow step definition for a template by step id. 9821 This method makes a synchronous HTTP request by default. To make an 9822 asynchronous HTTP request, please define a `callback` function 9823 to be invoked when receiving the response. 9824 >>> def callback_function(response): 9825 >>> pprint(response) 9826 >>> 9827 >>> thread = api.get_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 9828 9829 :param callback function: The callback function 9830 for asynchronous request. (optional) 9831 :param str account_id: The external account number (int) or account ID Guid. (required) 9832 :param str template_id: The ID of the template being accessed. (required) 9833 :param str workflow_step_id: (required) 9834 :return: WorkflowStep 9835 If the method is called asynchronously, 9836 returns the request thread. 9837 """ 9838 9839 all_params = ['account_id', 'template_id', 'workflow_step_id'] 9840 all_params.append('callback') 9841 all_params.append('_return_http_data_only') 9842 all_params.append('_preload_content') 9843 all_params.append('_request_timeout') 9844 9845 params = locals() 9846 for key, val in iteritems(params['kwargs']): 9847 if key not in all_params: 9848 raise TypeError( 9849 "Got an unexpected keyword argument '%s'" 9850 " to method get_template_workflow_step_definition" % key 9851 ) 9852 params[key] = val 9853 del params['kwargs'] 9854 # verify the required parameter 'account_id' is set 9855 if ('account_id' not in params) or (params['account_id'] is None): 9856 raise ValueError("Missing the required parameter `account_id` when calling `get_template_workflow_step_definition`") 9857 # verify the required parameter 'template_id' is set 9858 if ('template_id' not in params) or (params['template_id'] is None): 9859 raise ValueError("Missing the required parameter `template_id` when calling `get_template_workflow_step_definition`") 9860 # verify the required parameter 'workflow_step_id' is set 9861 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 9862 raise ValueError("Missing the required parameter `workflow_step_id` when calling `get_template_workflow_step_definition`") 9863 9864 9865 collection_formats = {} 9866 9867 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 9868 path_params = {} 9869 if 'account_id' in params: 9870 path_params['accountId'] = params['account_id'] 9871 if 'template_id' in params: 9872 path_params['templateId'] = params['template_id'] 9873 if 'workflow_step_id' in params: 9874 path_params['workflowStepId'] = params['workflow_step_id'] 9875 9876 query_params = {} 9877 9878 header_params = {} 9879 9880 form_params = [] 9881 local_var_files = {} 9882 9883 body_params = None 9884 # HTTP header `Accept` 9885 header_params['Accept'] = self.api_client.\ 9886 select_header_accept(['application/json']) 9887 9888 # Authentication setting 9889 auth_settings = [] 9890 9891 return self.api_client.call_api(resource_path, 'GET', 9892 path_params, 9893 query_params, 9894 header_params, 9895 body=body_params, 9896 post_params=form_params, 9897 files=local_var_files, 9898 response_type='WorkflowStep', 9899 auth_settings=auth_settings, 9900 callback=params.get('callback'), 9901 _return_http_data_only=params.get('_return_http_data_only'), 9902 _preload_content=params.get('_preload_content', True), 9903 _request_timeout=params.get('_request_timeout'), 9904 collection_formats=collection_formats) 9905 9906 def list_audit_events(self, account_id, envelope_id, **kwargs): 9907 """ 9908 Gets the envelope audit events for an envelope. 9909 Gets the envelope audit events for the specified envelope. 9910 This method makes a synchronous HTTP request by default. To make an 9911 asynchronous HTTP request, please define a `callback` function 9912 to be invoked when receiving the response. 9913 >>> def callback_function(response): 9914 >>> pprint(response) 9915 >>> 9916 >>> thread = api.list_audit_events(account_id, envelope_id, callback=callback_function) 9917 9918 :param callback function: The callback function 9919 for asynchronous request. (optional) 9920 :param str account_id: The external account number (int) or account ID Guid. (required) 9921 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9922 :return: EnvelopeAuditEventResponse 9923 If the method is called asynchronously, 9924 returns the request thread. 9925 """ 9926 kwargs['_return_http_data_only'] = True 9927 if kwargs.get('callback'): 9928 return self.list_audit_events_with_http_info(account_id, envelope_id, **kwargs) 9929 else: 9930 (data) = self.list_audit_events_with_http_info(account_id, envelope_id, **kwargs) 9931 return data 9932 9933 def list_audit_events_with_http_info(self, account_id, envelope_id, **kwargs): 9934 """ 9935 Gets the envelope audit events for an envelope. 9936 Gets the envelope audit events for the specified envelope. 9937 This method makes a synchronous HTTP request by default. To make an 9938 asynchronous HTTP request, please define a `callback` function 9939 to be invoked when receiving the response. 9940 >>> def callback_function(response): 9941 >>> pprint(response) 9942 >>> 9943 >>> thread = api.list_audit_events_with_http_info(account_id, envelope_id, callback=callback_function) 9944 9945 :param callback function: The callback function 9946 for asynchronous request. (optional) 9947 :param str account_id: The external account number (int) or account ID Guid. (required) 9948 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9949 :return: EnvelopeAuditEventResponse 9950 If the method is called asynchronously, 9951 returns the request thread. 9952 """ 9953 9954 all_params = ['account_id', 'envelope_id'] 9955 all_params.append('callback') 9956 all_params.append('_return_http_data_only') 9957 all_params.append('_preload_content') 9958 all_params.append('_request_timeout') 9959 9960 params = locals() 9961 for key, val in iteritems(params['kwargs']): 9962 if key not in all_params: 9963 raise TypeError( 9964 "Got an unexpected keyword argument '%s'" 9965 " to method list_audit_events" % key 9966 ) 9967 params[key] = val 9968 del params['kwargs'] 9969 # verify the required parameter 'account_id' is set 9970 if ('account_id' not in params) or (params['account_id'] is None): 9971 raise ValueError("Missing the required parameter `account_id` when calling `list_audit_events`") 9972 # verify the required parameter 'envelope_id' is set 9973 if ('envelope_id' not in params) or (params['envelope_id'] is None): 9974 raise ValueError("Missing the required parameter `envelope_id` when calling `list_audit_events`") 9975 9976 9977 collection_formats = {} 9978 9979 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/audit_events'.replace('{format}', 'json') 9980 path_params = {} 9981 if 'account_id' in params: 9982 path_params['accountId'] = params['account_id'] 9983 if 'envelope_id' in params: 9984 path_params['envelopeId'] = params['envelope_id'] 9985 9986 query_params = {} 9987 9988 header_params = {} 9989 9990 form_params = [] 9991 local_var_files = {} 9992 9993 body_params = None 9994 # HTTP header `Accept` 9995 header_params['Accept'] = self.api_client.\ 9996 select_header_accept(['application/json']) 9997 9998 # Authentication setting 9999 auth_settings = [] 10000 10001 return self.api_client.call_api(resource_path, 'GET', 10002 path_params, 10003 query_params, 10004 header_params, 10005 body=body_params, 10006 post_params=form_params, 10007 files=local_var_files, 10008 response_type='EnvelopeAuditEventResponse', 10009 auth_settings=auth_settings, 10010 callback=params.get('callback'), 10011 _return_http_data_only=params.get('_return_http_data_only'), 10012 _preload_content=params.get('_preload_content', True), 10013 _request_timeout=params.get('_request_timeout'), 10014 collection_formats=collection_formats) 10015 10016 def list_custom_fields(self, account_id, envelope_id, **kwargs): 10017 """ 10018 Gets the custom field information for the specified envelope. 10019 Retrieves the custom field information for the specified envelope. You can use these fields in the envelopes for your account to record information about the envelope, help search for envelopes, and track information. The envelope custom fields are shown in the Envelope Settings section when a user is creating an envelope in the DocuSign member console. The envelope custom fields are not seen by the envelope recipients. There are two types of envelope custom fields, text, and list. A text custom field lets the sender enter the value for the field. With a list custom field, the sender selects the value of the field from a pre-made list. 10020 This method makes a synchronous HTTP request by default. To make an 10021 asynchronous HTTP request, please define a `callback` function 10022 to be invoked when receiving the response. 10023 >>> def callback_function(response): 10024 >>> pprint(response) 10025 >>> 10026 >>> thread = api.list_custom_fields(account_id, envelope_id, callback=callback_function) 10027 10028 :param callback function: The callback function 10029 for asynchronous request. (optional) 10030 :param str account_id: The external account number (int) or account ID Guid. (required) 10031 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10032 :return: CustomFieldsEnvelope 10033 If the method is called asynchronously, 10034 returns the request thread. 10035 """ 10036 kwargs['_return_http_data_only'] = True 10037 if kwargs.get('callback'): 10038 return self.list_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 10039 else: 10040 (data) = self.list_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 10041 return data 10042 10043 def list_custom_fields_with_http_info(self, account_id, envelope_id, **kwargs): 10044 """ 10045 Gets the custom field information for the specified envelope. 10046 Retrieves the custom field information for the specified envelope. You can use these fields in the envelopes for your account to record information about the envelope, help search for envelopes, and track information. The envelope custom fields are shown in the Envelope Settings section when a user is creating an envelope in the DocuSign member console. The envelope custom fields are not seen by the envelope recipients. There are two types of envelope custom fields, text, and list. A text custom field lets the sender enter the value for the field. With a list custom field, the sender selects the value of the field from a pre-made list. 10047 This method makes a synchronous HTTP request by default. To make an 10048 asynchronous HTTP request, please define a `callback` function 10049 to be invoked when receiving the response. 10050 >>> def callback_function(response): 10051 >>> pprint(response) 10052 >>> 10053 >>> thread = api.list_custom_fields_with_http_info(account_id, envelope_id, callback=callback_function) 10054 10055 :param callback function: The callback function 10056 for asynchronous request. (optional) 10057 :param str account_id: The external account number (int) or account ID Guid. (required) 10058 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10059 :return: CustomFieldsEnvelope 10060 If the method is called asynchronously, 10061 returns the request thread. 10062 """ 10063 10064 all_params = ['account_id', 'envelope_id'] 10065 all_params.append('callback') 10066 all_params.append('_return_http_data_only') 10067 all_params.append('_preload_content') 10068 all_params.append('_request_timeout') 10069 10070 params = locals() 10071 for key, val in iteritems(params['kwargs']): 10072 if key not in all_params: 10073 raise TypeError( 10074 "Got an unexpected keyword argument '%s'" 10075 " to method list_custom_fields" % key 10076 ) 10077 params[key] = val 10078 del params['kwargs'] 10079 # verify the required parameter 'account_id' is set 10080 if ('account_id' not in params) or (params['account_id'] is None): 10081 raise ValueError("Missing the required parameter `account_id` when calling `list_custom_fields`") 10082 # verify the required parameter 'envelope_id' is set 10083 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10084 raise ValueError("Missing the required parameter `envelope_id` when calling `list_custom_fields`") 10085 10086 10087 collection_formats = {} 10088 10089 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/custom_fields'.replace('{format}', 'json') 10090 path_params = {} 10091 if 'account_id' in params: 10092 path_params['accountId'] = params['account_id'] 10093 if 'envelope_id' in params: 10094 path_params['envelopeId'] = params['envelope_id'] 10095 10096 query_params = {} 10097 10098 header_params = {} 10099 10100 form_params = [] 10101 local_var_files = {} 10102 10103 body_params = None 10104 # HTTP header `Accept` 10105 header_params['Accept'] = self.api_client.\ 10106 select_header_accept(['application/json']) 10107 10108 # Authentication setting 10109 auth_settings = [] 10110 10111 return self.api_client.call_api(resource_path, 'GET', 10112 path_params, 10113 query_params, 10114 header_params, 10115 body=body_params, 10116 post_params=form_params, 10117 files=local_var_files, 10118 response_type='CustomFieldsEnvelope', 10119 auth_settings=auth_settings, 10120 callback=params.get('callback'), 10121 _return_http_data_only=params.get('_return_http_data_only'), 10122 _preload_content=params.get('_preload_content', True), 10123 _request_timeout=params.get('_request_timeout'), 10124 collection_formats=collection_formats) 10125 10126 def list_document_fields(self, account_id, document_id, envelope_id, **kwargs): 10127 """ 10128 Gets the custom document fields from an existing envelope document. 10129 Retrieves the custom document field information from an existing envelope document. 10130 This method makes a synchronous HTTP request by default. To make an 10131 asynchronous HTTP request, please define a `callback` function 10132 to be invoked when receiving the response. 10133 >>> def callback_function(response): 10134 >>> pprint(response) 10135 >>> 10136 >>> thread = api.list_document_fields(account_id, document_id, envelope_id, callback=callback_function) 10137 10138 :param callback function: The callback function 10139 for asynchronous request. (optional) 10140 :param str account_id: The external account number (int) or account ID Guid. (required) 10141 :param str document_id: The ID of the document being accessed. (required) 10142 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10143 :return: DocumentFieldsInformation 10144 If the method is called asynchronously, 10145 returns the request thread. 10146 """ 10147 kwargs['_return_http_data_only'] = True 10148 if kwargs.get('callback'): 10149 return self.list_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 10150 else: 10151 (data) = self.list_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 10152 return data 10153 10154 def list_document_fields_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 10155 """ 10156 Gets the custom document fields from an existing envelope document. 10157 Retrieves the custom document field information from an existing envelope document. 10158 This method makes a synchronous HTTP request by default. To make an 10159 asynchronous HTTP request, please define a `callback` function 10160 to be invoked when receiving the response. 10161 >>> def callback_function(response): 10162 >>> pprint(response) 10163 >>> 10164 >>> thread = api.list_document_fields_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 10165 10166 :param callback function: The callback function 10167 for asynchronous request. (optional) 10168 :param str account_id: The external account number (int) or account ID Guid. (required) 10169 :param str document_id: The ID of the document being accessed. (required) 10170 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10171 :return: DocumentFieldsInformation 10172 If the method is called asynchronously, 10173 returns the request thread. 10174 """ 10175 10176 all_params = ['account_id', 'document_id', 'envelope_id'] 10177 all_params.append('callback') 10178 all_params.append('_return_http_data_only') 10179 all_params.append('_preload_content') 10180 all_params.append('_request_timeout') 10181 10182 params = locals() 10183 for key, val in iteritems(params['kwargs']): 10184 if key not in all_params: 10185 raise TypeError( 10186 "Got an unexpected keyword argument '%s'" 10187 " to method list_document_fields" % key 10188 ) 10189 params[key] = val 10190 del params['kwargs'] 10191 # verify the required parameter 'account_id' is set 10192 if ('account_id' not in params) or (params['account_id'] is None): 10193 raise ValueError("Missing the required parameter `account_id` when calling `list_document_fields`") 10194 # verify the required parameter 'document_id' is set 10195 if ('document_id' not in params) or (params['document_id'] is None): 10196 raise ValueError("Missing the required parameter `document_id` when calling `list_document_fields`") 10197 # verify the required parameter 'envelope_id' is set 10198 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10199 raise ValueError("Missing the required parameter `envelope_id` when calling `list_document_fields`") 10200 10201 10202 collection_formats = {} 10203 10204 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/fields'.replace('{format}', 'json') 10205 path_params = {} 10206 if 'account_id' in params: 10207 path_params['accountId'] = params['account_id'] 10208 if 'document_id' in params: 10209 path_params['documentId'] = params['document_id'] 10210 if 'envelope_id' in params: 10211 path_params['envelopeId'] = params['envelope_id'] 10212 10213 query_params = {} 10214 10215 header_params = {} 10216 10217 form_params = [] 10218 local_var_files = {} 10219 10220 body_params = None 10221 # HTTP header `Accept` 10222 header_params['Accept'] = self.api_client.\ 10223 select_header_accept(['application/json']) 10224 10225 # Authentication setting 10226 auth_settings = [] 10227 10228 return self.api_client.call_api(resource_path, 'GET', 10229 path_params, 10230 query_params, 10231 header_params, 10232 body=body_params, 10233 post_params=form_params, 10234 files=local_var_files, 10235 response_type='DocumentFieldsInformation', 10236 auth_settings=auth_settings, 10237 callback=params.get('callback'), 10238 _return_http_data_only=params.get('_return_http_data_only'), 10239 _preload_content=params.get('_preload_content', True), 10240 _request_timeout=params.get('_request_timeout'), 10241 collection_formats=collection_formats) 10242 10243 def list_documents(self, account_id, envelope_id, **kwargs): 10244 """ 10245 Gets a list of envelope documents. 10246 Retrieves a list of documents associated with the specified envelope. 10247 This method makes a synchronous HTTP request by default. To make an 10248 asynchronous HTTP request, please define a `callback` function 10249 to be invoked when receiving the response. 10250 >>> def callback_function(response): 10251 >>> pprint(response) 10252 >>> 10253 >>> thread = api.list_documents(account_id, envelope_id, callback=callback_function) 10254 10255 :param callback function: The callback function 10256 for asynchronous request. (optional) 10257 :param str account_id: The external account number (int) or account ID Guid. (required) 10258 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10259 :param str documents_by_userid: 10260 :param str include_docgen_formfields: 10261 :param str include_document_size: 10262 :param str include_metadata: 10263 :param str include_tabs: 10264 :param str recipient_id: 10265 :param str shared_user_id: 10266 :return: EnvelopeDocumentsResult 10267 If the method is called asynchronously, 10268 returns the request thread. 10269 """ 10270 kwargs['_return_http_data_only'] = True 10271 if kwargs.get('callback'): 10272 return self.list_documents_with_http_info(account_id, envelope_id, **kwargs) 10273 else: 10274 (data) = self.list_documents_with_http_info(account_id, envelope_id, **kwargs) 10275 return data 10276 10277 def list_documents_with_http_info(self, account_id, envelope_id, **kwargs): 10278 """ 10279 Gets a list of envelope documents. 10280 Retrieves a list of documents associated with the specified envelope. 10281 This method makes a synchronous HTTP request by default. To make an 10282 asynchronous HTTP request, please define a `callback` function 10283 to be invoked when receiving the response. 10284 >>> def callback_function(response): 10285 >>> pprint(response) 10286 >>> 10287 >>> thread = api.list_documents_with_http_info(account_id, envelope_id, callback=callback_function) 10288 10289 :param callback function: The callback function 10290 for asynchronous request. (optional) 10291 :param str account_id: The external account number (int) or account ID Guid. (required) 10292 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10293 :param str documents_by_userid: 10294 :param str include_docgen_formfields: 10295 :param str include_document_size: 10296 :param str include_metadata: 10297 :param str include_tabs: 10298 :param str recipient_id: 10299 :param str shared_user_id: 10300 :return: EnvelopeDocumentsResult 10301 If the method is called asynchronously, 10302 returns the request thread. 10303 """ 10304 10305 all_params = ['account_id', 'envelope_id', 'documents_by_userid', 'include_docgen_formfields', 'include_document_size', 'include_metadata', 'include_tabs', 'recipient_id', 'shared_user_id'] 10306 all_params.append('callback') 10307 all_params.append('_return_http_data_only') 10308 all_params.append('_preload_content') 10309 all_params.append('_request_timeout') 10310 10311 params = locals() 10312 for key, val in iteritems(params['kwargs']): 10313 if key not in all_params: 10314 raise TypeError( 10315 "Got an unexpected keyword argument '%s'" 10316 " to method list_documents" % key 10317 ) 10318 params[key] = val 10319 del params['kwargs'] 10320 # verify the required parameter 'account_id' is set 10321 if ('account_id' not in params) or (params['account_id'] is None): 10322 raise ValueError("Missing the required parameter `account_id` when calling `list_documents`") 10323 # verify the required parameter 'envelope_id' is set 10324 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10325 raise ValueError("Missing the required parameter `envelope_id` when calling `list_documents`") 10326 10327 10328 collection_formats = {} 10329 10330 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents'.replace('{format}', 'json') 10331 path_params = {} 10332 if 'account_id' in params: 10333 path_params['accountId'] = params['account_id'] 10334 if 'envelope_id' in params: 10335 path_params['envelopeId'] = params['envelope_id'] 10336 10337 query_params = {} 10338 if 'documents_by_userid' in params: 10339 query_params['documents_by_userid'] = params['documents_by_userid'] 10340 if 'include_docgen_formfields' in params: 10341 query_params['include_docgen_formfields'] = params['include_docgen_formfields'] 10342 if 'include_document_size' in params: 10343 query_params['include_document_size'] = params['include_document_size'] 10344 if 'include_metadata' in params: 10345 query_params['include_metadata'] = params['include_metadata'] 10346 if 'include_tabs' in params: 10347 query_params['include_tabs'] = params['include_tabs'] 10348 if 'recipient_id' in params: 10349 query_params['recipient_id'] = params['recipient_id'] 10350 if 'shared_user_id' in params: 10351 query_params['shared_user_id'] = params['shared_user_id'] 10352 10353 header_params = {} 10354 10355 form_params = [] 10356 local_var_files = {} 10357 10358 body_params = None 10359 # HTTP header `Accept` 10360 header_params['Accept'] = self.api_client.\ 10361 select_header_accept(['application/json']) 10362 10363 # Authentication setting 10364 auth_settings = [] 10365 10366 return self.api_client.call_api(resource_path, 'GET', 10367 path_params, 10368 query_params, 10369 header_params, 10370 body=body_params, 10371 post_params=form_params, 10372 files=local_var_files, 10373 response_type='EnvelopeDocumentsResult', 10374 auth_settings=auth_settings, 10375 callback=params.get('callback'), 10376 _return_http_data_only=params.get('_return_http_data_only'), 10377 _preload_content=params.get('_preload_content', True), 10378 _request_timeout=params.get('_request_timeout'), 10379 collection_formats=collection_formats) 10380 10381 def list_recipients(self, account_id, envelope_id, **kwargs): 10382 """ 10383 Gets the status of recipients for an envelope. 10384 Retrieves the status of all recipients in a single envelope and identifies the current recipient in the routing list. The `currentRoutingOrder` property of the response contains the `routingOrder` value of the current recipient indicating that the envelope has been sent to the recipient, but the recipient has not completed their actions. 10385 This method makes a synchronous HTTP request by default. To make an 10386 asynchronous HTTP request, please define a `callback` function 10387 to be invoked when receiving the response. 10388 >>> def callback_function(response): 10389 >>> pprint(response) 10390 >>> 10391 >>> thread = api.list_recipients(account_id, envelope_id, callback=callback_function) 10392 10393 :param callback function: The callback function 10394 for asynchronous request. (optional) 10395 :param str account_id: The external account number (int) or account ID Guid. (required) 10396 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10397 :param str include_anchor_tab_locations: When set to **true** and `include_tabs` is set to **true**, all tabs with anchor tab properties are included in the response. 10398 :param str include_extended: When set to **true**, the extended properties are included in the response. 10399 :param str include_metadata: 10400 :param str include_tabs: When set to **true**, the tab information associated with the recipient is included in the response. 10401 :return: Recipients 10402 If the method is called asynchronously, 10403 returns the request thread. 10404 """ 10405 kwargs['_return_http_data_only'] = True 10406 if kwargs.get('callback'): 10407 return self.list_recipients_with_http_info(account_id, envelope_id, **kwargs) 10408 else: 10409 (data) = self.list_recipients_with_http_info(account_id, envelope_id, **kwargs) 10410 return data 10411 10412 def list_recipients_with_http_info(self, account_id, envelope_id, **kwargs): 10413 """ 10414 Gets the status of recipients for an envelope. 10415 Retrieves the status of all recipients in a single envelope and identifies the current recipient in the routing list. The `currentRoutingOrder` property of the response contains the `routingOrder` value of the current recipient indicating that the envelope has been sent to the recipient, but the recipient has not completed their actions. 10416 This method makes a synchronous HTTP request by default. To make an 10417 asynchronous HTTP request, please define a `callback` function 10418 to be invoked when receiving the response. 10419 >>> def callback_function(response): 10420 >>> pprint(response) 10421 >>> 10422 >>> thread = api.list_recipients_with_http_info(account_id, envelope_id, callback=callback_function) 10423 10424 :param callback function: The callback function 10425 for asynchronous request. (optional) 10426 :param str account_id: The external account number (int) or account ID Guid. (required) 10427 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10428 :param str include_anchor_tab_locations: When set to **true** and `include_tabs` is set to **true**, all tabs with anchor tab properties are included in the response. 10429 :param str include_extended: When set to **true**, the extended properties are included in the response. 10430 :param str include_metadata: 10431 :param str include_tabs: When set to **true**, the tab information associated with the recipient is included in the response. 10432 :return: Recipients 10433 If the method is called asynchronously, 10434 returns the request thread. 10435 """ 10436 10437 all_params = ['account_id', 'envelope_id', 'include_anchor_tab_locations', 'include_extended', 'include_metadata', 'include_tabs'] 10438 all_params.append('callback') 10439 all_params.append('_return_http_data_only') 10440 all_params.append('_preload_content') 10441 all_params.append('_request_timeout') 10442 10443 params = locals() 10444 for key, val in iteritems(params['kwargs']): 10445 if key not in all_params: 10446 raise TypeError( 10447 "Got an unexpected keyword argument '%s'" 10448 " to method list_recipients" % key 10449 ) 10450 params[key] = val 10451 del params['kwargs'] 10452 # verify the required parameter 'account_id' is set 10453 if ('account_id' not in params) or (params['account_id'] is None): 10454 raise ValueError("Missing the required parameter `account_id` when calling `list_recipients`") 10455 # verify the required parameter 'envelope_id' is set 10456 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10457 raise ValueError("Missing the required parameter `envelope_id` when calling `list_recipients`") 10458 10459 10460 collection_formats = {} 10461 10462 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients'.replace('{format}', 'json') 10463 path_params = {} 10464 if 'account_id' in params: 10465 path_params['accountId'] = params['account_id'] 10466 if 'envelope_id' in params: 10467 path_params['envelopeId'] = params['envelope_id'] 10468 10469 query_params = {} 10470 if 'include_anchor_tab_locations' in params: 10471 query_params['include_anchor_tab_locations'] = params['include_anchor_tab_locations'] 10472 if 'include_extended' in params: 10473 query_params['include_extended'] = params['include_extended'] 10474 if 'include_metadata' in params: 10475 query_params['include_metadata'] = params['include_metadata'] 10476 if 'include_tabs' in params: 10477 query_params['include_tabs'] = params['include_tabs'] 10478 10479 header_params = {} 10480 10481 form_params = [] 10482 local_var_files = {} 10483 10484 body_params = None 10485 # HTTP header `Accept` 10486 header_params['Accept'] = self.api_client.\ 10487 select_header_accept(['application/json']) 10488 10489 # Authentication setting 10490 auth_settings = [] 10491 10492 return self.api_client.call_api(resource_path, 'GET', 10493 path_params, 10494 query_params, 10495 header_params, 10496 body=body_params, 10497 post_params=form_params, 10498 files=local_var_files, 10499 response_type='Recipients', 10500 auth_settings=auth_settings, 10501 callback=params.get('callback'), 10502 _return_http_data_only=params.get('_return_http_data_only'), 10503 _preload_content=params.get('_preload_content', True), 10504 _request_timeout=params.get('_request_timeout'), 10505 collection_formats=collection_formats) 10506 10507 def list_status(self, account_id, **kwargs): 10508 """ 10509 Gets the envelope status for the specified envelopes. 10510 Retrieves the envelope status for the specified envelopes. 10511 This method makes a synchronous HTTP request by default. To make an 10512 asynchronous HTTP request, please define a `callback` function 10513 to be invoked when receiving the response. 10514 >>> def callback_function(response): 10515 >>> pprint(response) 10516 >>> 10517 >>> thread = api.list_status(account_id, callback=callback_function) 10518 10519 :param callback function: The callback function 10520 for asynchronous request. (optional) 10521 :param str account_id: The external account number (int) or account ID Guid. (required) 10522 :param str ac_status: 10523 :param str block: 10524 :param str count: 10525 :param str email: 10526 :param str envelope_ids: 10527 :param str from_date: 10528 :param str from_to_status: 10529 :param str start_position: 10530 :param str status: 10531 :param str to_date: 10532 :param str transaction_ids: 10533 :param str user_name: 10534 :param EnvelopeIdsRequest envelope_ids_request: 10535 :return: EnvelopesInformation 10536 If the method is called asynchronously, 10537 returns the request thread. 10538 """ 10539 kwargs['_return_http_data_only'] = True 10540 if kwargs.get('callback'): 10541 return self.list_status_with_http_info(account_id, **kwargs) 10542 else: 10543 (data) = self.list_status_with_http_info(account_id, **kwargs) 10544 return data 10545 10546 def list_status_with_http_info(self, account_id, **kwargs): 10547 """ 10548 Gets the envelope status for the specified envelopes. 10549 Retrieves the envelope status for the specified envelopes. 10550 This method makes a synchronous HTTP request by default. To make an 10551 asynchronous HTTP request, please define a `callback` function 10552 to be invoked when receiving the response. 10553 >>> def callback_function(response): 10554 >>> pprint(response) 10555 >>> 10556 >>> thread = api.list_status_with_http_info(account_id, callback=callback_function) 10557 10558 :param callback function: The callback function 10559 for asynchronous request. (optional) 10560 :param str account_id: The external account number (int) or account ID Guid. (required) 10561 :param str ac_status: 10562 :param str block: 10563 :param str count: 10564 :param str email: 10565 :param str envelope_ids: 10566 :param str from_date: 10567 :param str from_to_status: 10568 :param str start_position: 10569 :param str status: 10570 :param str to_date: 10571 :param str transaction_ids: 10572 :param str user_name: 10573 :param EnvelopeIdsRequest envelope_ids_request: 10574 :return: EnvelopesInformation 10575 If the method is called asynchronously, 10576 returns the request thread. 10577 """ 10578 10579 all_params = ['account_id', 'ac_status', 'block', 'count', 'email', 'envelope_ids', 'from_date', 'from_to_status', 'start_position', 'status', 'to_date', 'transaction_ids', 'user_name', 'envelope_ids_request'] 10580 all_params.append('callback') 10581 all_params.append('_return_http_data_only') 10582 all_params.append('_preload_content') 10583 all_params.append('_request_timeout') 10584 10585 params = locals() 10586 for key, val in iteritems(params['kwargs']): 10587 if key not in all_params: 10588 raise TypeError( 10589 "Got an unexpected keyword argument '%s'" 10590 " to method list_status" % key 10591 ) 10592 params[key] = val 10593 del params['kwargs'] 10594 # verify the required parameter 'account_id' is set 10595 if ('account_id' not in params) or (params['account_id'] is None): 10596 raise ValueError("Missing the required parameter `account_id` when calling `list_status`") 10597 10598 10599 collection_formats = {} 10600 10601 resource_path = '/v2.1/accounts/{accountId}/envelopes/status'.replace('{format}', 'json') 10602 path_params = {} 10603 if 'account_id' in params: 10604 path_params['accountId'] = params['account_id'] 10605 10606 query_params = {} 10607 if 'ac_status' in params: 10608 query_params['ac_status'] = params['ac_status'] 10609 if 'block' in params: 10610 query_params['block'] = params['block'] 10611 if 'count' in params: 10612 query_params['count'] = params['count'] 10613 if 'email' in params: 10614 query_params['email'] = params['email'] 10615 if 'envelope_ids' in params: 10616 query_params['envelope_ids'] = params['envelope_ids'] 10617 if 'from_date' in params: 10618 query_params['from_date'] = params['from_date'] 10619 if 'from_to_status' in params: 10620 query_params['from_to_status'] = params['from_to_status'] 10621 if 'start_position' in params: 10622 query_params['start_position'] = params['start_position'] 10623 if 'status' in params: 10624 query_params['status'] = params['status'] 10625 if 'to_date' in params: 10626 query_params['to_date'] = params['to_date'] 10627 if 'transaction_ids' in params: 10628 query_params['transaction_ids'] = params['transaction_ids'] 10629 if 'user_name' in params: 10630 query_params['user_name'] = params['user_name'] 10631 10632 header_params = {} 10633 10634 form_params = [] 10635 local_var_files = {} 10636 10637 body_params = None 10638 if 'envelope_ids_request' in params: 10639 body_params = params['envelope_ids_request'] 10640 # HTTP header `Accept` 10641 header_params['Accept'] = self.api_client.\ 10642 select_header_accept(['application/json']) 10643 10644 # Authentication setting 10645 auth_settings = [] 10646 10647 return self.api_client.call_api(resource_path, 'PUT', 10648 path_params, 10649 query_params, 10650 header_params, 10651 body=body_params, 10652 post_params=form_params, 10653 files=local_var_files, 10654 response_type='EnvelopesInformation', 10655 auth_settings=auth_settings, 10656 callback=params.get('callback'), 10657 _return_http_data_only=params.get('_return_http_data_only'), 10658 _preload_content=params.get('_preload_content', True), 10659 _request_timeout=params.get('_request_timeout'), 10660 collection_formats=collection_formats) 10661 10662 def list_status_changes(self, account_id, **kwargs): 10663 """ 10664 Gets status changes for one or more envelopes. 10665 Retrieves envelope status changes for all envelopes. You can modify the information returned by adding query strings to limit the request to check between certain dates and times, or for certain envelopes, or for certain status codes. It is recommended that you use one or more of the query strings in order to limit the size of the response. ### Important: Unless you are requesting the status for specific envelopes (using the `envelopeIds` or `transactionIds` properties), you must add a set the `from_date` property in the request. Getting envelope status using `transactionIds` is useful for offline signing situations where it can be used determine if an envelope was created or not, for the cases where a network connection was lost, before the envelope status could be returned. ### Request Envelope Status Notes ### The REST API GET /envelopes call uses certain filters to find results. In some cases requests are check for \"any status change\" instead of the just the single status requested. In these cases, more envelopes might be returned by the request than otherwise would be. For example, for a request with the begin date is set to Jan 1st, an end date set to Jan 7th and the status qualifier (`from_to_status`) set to `Delivered` — the response set might contain envelopes that were created during that time period, but not delivered during the time period. To avoid unnecessary database queries, the DocuSign system checks requests to ensure that the added filters will not result in a zero-size response before acting on the request. The following table shows the valid envelope statuses (in the Valid Current Statuses column) for the status qualifiers in the request. If the status and status qualifiers in the API request do not contain any of the values shown in the valid current statuses column, then an empty list is returned. For example, a request with a status qualifier (from_to_status) of `Delivered` and a status of \"`Created`,`Sent`\", DocuSign will always return an empty list. This is because the request essentially translates to: find the envelopes that were delivered between the begin and end dates that have a current status of `Created` or `Sent`, and since an envelope that has been delivered can never have a status of `Created` or `Sent`, a zero-size response would be generated. In this case, DocuSign does not run the request, but just returns the empty list. Client applications should check that the statuses they are requesting make sense for a given status qualifier. 10666 This method makes a synchronous HTTP request by default. To make an 10667 asynchronous HTTP request, please define a `callback` function 10668 to be invoked when receiving the response. 10669 >>> def callback_function(response): 10670 >>> pprint(response) 10671 >>> 10672 >>> thread = api.list_status_changes(account_id, callback=callback_function) 10673 10674 :param callback function: The callback function 10675 for asynchronous request. (optional) 10676 :param str account_id: The external account number (int) or account ID Guid. (required) 10677 :param str ac_status: Specifies the Authoritative Copy Status for the envelopes. The possible values are: Unknown, Original, Transferred, AuthoritativeCopy, AuthoritativeCopyExportPending, AuthoritativeCopyExported, DepositPending, Deposited, DepositedEO, or DepositFailed. 10678 :param str block: 10679 :param str cdse_mode: 10680 :param str continuation_token: 10681 :param str count: 10682 :param str custom_field: This specifies the envelope custom field name and value searched for in the envelope information. The value portion of the query can use partial strings by adding '%' (percent sign) around the custom field query value. Example 1: If you have an envelope custom field called \"Region\" and you want to search for all envelopes where the value is \"West\" you would use the query: `?custom_field=Region=West`. Example 2: To search for envelopes where the `ApplicationID` custom field has the value or partial value of \"DocuSign\" in field, the query would be: `?custom_field=ApplicationId=%DocuSign%` This would find envelopes where the custom field value is \"DocuSign for Salesforce\" or \"DocuSign envelope.\" 10683 :param str email: 10684 :param str envelope_ids: 10685 :param str exclude: 10686 :param str folder_ids: 10687 :param str folder_types: 10688 :param str from_date: The date/time setting that specifies the date/time when the request begins checking for status changes for envelopes in the account. This is required unless 'envelopeId's are used. 10689 :param str from_to_status: This is the status type checked for in the `from_date`/`to_date` period. If `changed` is specified, then envelopes that changed status during the period are found. If for example, `created` is specified, then envelopes created during the period are found. Default is `changed`. Possible values are: Voided, Changed, Created, Deleted, Sent, Delivered, Signed, Completed, Declined, TimedOut and Processing. 10690 :param str include: 10691 :param str include_purge_information: 10692 :param str intersecting_folder_ids: 10693 :param str last_queried_date: 10694 :param str order: 10695 :param str order_by: 10696 :param str powerformids: 10697 :param str query_budget: 10698 :param str requester_date_format: 10699 :param str search_text: 10700 :param str start_position: 10701 :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. 10702 :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`. 10703 :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. 10704 :param str user_filter: 10705 :param str user_id: 10706 :param str user_name: 10707 :return: EnvelopesInformation 10708 If the method is called asynchronously, 10709 returns the request thread. 10710 """ 10711 kwargs['_return_http_data_only'] = True 10712 if kwargs.get('callback'): 10713 return self.list_status_changes_with_http_info(account_id, **kwargs) 10714 else: 10715 (data) = self.list_status_changes_with_http_info(account_id, **kwargs) 10716 return data 10717 10718 def list_status_changes_with_http_info(self, account_id, **kwargs): 10719 """ 10720 Gets status changes for one or more envelopes. 10721 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. 10722 This method makes a synchronous HTTP request by default. To make an 10723 asynchronous HTTP request, please define a `callback` function 10724 to be invoked when receiving the response. 10725 >>> def callback_function(response): 10726 >>> pprint(response) 10727 >>> 10728 >>> thread = api.list_status_changes_with_http_info(account_id, callback=callback_function) 10729 10730 :param callback function: The callback function 10731 for asynchronous request. (optional) 10732 :param str account_id: The external account number (int) or account ID Guid. (required) 10733 :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. 10734 :param str block: 10735 :param str cdse_mode: 10736 :param str continuation_token: 10737 :param str count: 10738 :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.\" 10739 :param str email: 10740 :param str envelope_ids: 10741 :param str exclude: 10742 :param str folder_ids: 10743 :param str folder_types: 10744 :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. 10745 :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. 10746 :param str include: 10747 :param str include_purge_information: 10748 :param str intersecting_folder_ids: 10749 :param str last_queried_date: 10750 :param str order: 10751 :param str order_by: 10752 :param str powerformids: 10753 :param str query_budget: 10754 :param str requester_date_format: 10755 :param str search_text: 10756 :param str start_position: 10757 :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. 10758 :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`. 10759 :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. 10760 :param str user_filter: 10761 :param str user_id: 10762 :param str user_name: 10763 :return: EnvelopesInformation 10764 If the method is called asynchronously, 10765 returns the request thread. 10766 """ 10767 10768 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_text', 'start_position', 'status', 'to_date', 'transaction_ids', 'user_filter', 'user_id', 'user_name'] 10769 all_params.append('callback') 10770 all_params.append('_return_http_data_only') 10771 all_params.append('_preload_content') 10772 all_params.append('_request_timeout') 10773 10774 params = locals() 10775 for key, val in iteritems(params['kwargs']): 10776 if key not in all_params: 10777 raise TypeError( 10778 "Got an unexpected keyword argument '%s'" 10779 " to method list_status_changes" % key 10780 ) 10781 params[key] = val 10782 del params['kwargs'] 10783 # verify the required parameter 'account_id' is set 10784 if ('account_id' not in params) or (params['account_id'] is None): 10785 raise ValueError("Missing the required parameter `account_id` when calling `list_status_changes`") 10786 10787 10788 collection_formats = {} 10789 10790 resource_path = '/v2.1/accounts/{accountId}/envelopes'.replace('{format}', 'json') 10791 path_params = {} 10792 if 'account_id' in params: 10793 path_params['accountId'] = params['account_id'] 10794 10795 query_params = {} 10796 if 'ac_status' in params: 10797 query_params['ac_status'] = params['ac_status'] 10798 if 'block' in params: 10799 query_params['block'] = params['block'] 10800 if 'cdse_mode' in params: 10801 query_params['cdse_mode'] = params['cdse_mode'] 10802 if 'continuation_token' in params: 10803 query_params['continuation_token'] = params['continuation_token'] 10804 if 'count' in params: 10805 query_params['count'] = params['count'] 10806 if 'custom_field' in params: 10807 query_params['custom_field'] = params['custom_field'] 10808 if 'email' in params: 10809 query_params['email'] = params['email'] 10810 if 'envelope_ids' in params: 10811 query_params['envelope_ids'] = params['envelope_ids'] 10812 if 'exclude' in params: 10813 query_params['exclude'] = params['exclude'] 10814 if 'folder_ids' in params: 10815 query_params['folder_ids'] = params['folder_ids'] 10816 if 'folder_types' in params: 10817 query_params['folder_types'] = params['folder_types'] 10818 if 'from_date' in params: 10819 query_params['from_date'] = params['from_date'] 10820 if 'from_to_status' in params: 10821 query_params['from_to_status'] = params['from_to_status'] 10822 if 'include' in params: 10823 query_params['include'] = params['include'] 10824 if 'include_purge_information' in params: 10825 query_params['include_purge_information'] = params['include_purge_information'] 10826 if 'intersecting_folder_ids' in params: 10827 query_params['intersecting_folder_ids'] = params['intersecting_folder_ids'] 10828 if 'last_queried_date' in params: 10829 query_params['last_queried_date'] = params['last_queried_date'] 10830 if 'order' in params: 10831 query_params['order'] = params['order'] 10832 if 'order_by' in params: 10833 query_params['order_by'] = params['order_by'] 10834 if 'powerformids' in params: 10835 query_params['powerformids'] = params['powerformids'] 10836 if 'query_budget' in params: 10837 query_params['query_budget'] = params['query_budget'] 10838 if 'requester_date_format' in params: 10839 query_params['requester_date_format'] = params['requester_date_format'] 10840 if 'search_text' in params: 10841 query_params['search_text'] = params['search_text'] 10842 if 'start_position' in params: 10843 query_params['start_position'] = params['start_position'] 10844 if 'status' in params: 10845 query_params['status'] = params['status'] 10846 if 'to_date' in params: 10847 query_params['to_date'] = params['to_date'] 10848 if 'transaction_ids' in params: 10849 query_params['transaction_ids'] = params['transaction_ids'] 10850 if 'user_filter' in params: 10851 query_params['user_filter'] = params['user_filter'] 10852 if 'user_id' in params: 10853 query_params['user_id'] = params['user_id'] 10854 if 'user_name' in params: 10855 query_params['user_name'] = params['user_name'] 10856 10857 header_params = {} 10858 10859 form_params = [] 10860 local_var_files = {} 10861 10862 body_params = None 10863 # HTTP header `Accept` 10864 header_params['Accept'] = self.api_client.\ 10865 select_header_accept(['application/json']) 10866 10867 # Authentication setting 10868 auth_settings = [] 10869 10870 return self.api_client.call_api(resource_path, 'GET', 10871 path_params, 10872 query_params, 10873 header_params, 10874 body=body_params, 10875 post_params=form_params, 10876 files=local_var_files, 10877 response_type='EnvelopesInformation', 10878 auth_settings=auth_settings, 10879 callback=params.get('callback'), 10880 _return_http_data_only=params.get('_return_http_data_only'), 10881 _preload_content=params.get('_preload_content', True), 10882 _request_timeout=params.get('_request_timeout'), 10883 collection_formats=collection_formats) 10884 10885 def list_tabs(self, account_id, envelope_id, recipient_id, **kwargs): 10886 """ 10887 Gets the tabs information for a signer or sign-in-person recipient in an envelope. 10888 Retrieves information about the tabs associated with a recipient in a draft envelope. 10889 This method makes a synchronous HTTP request by default. To make an 10890 asynchronous HTTP request, please define a `callback` function 10891 to be invoked when receiving the response. 10892 >>> def callback_function(response): 10893 >>> pprint(response) 10894 >>> 10895 >>> thread = api.list_tabs(account_id, envelope_id, recipient_id, callback=callback_function) 10896 10897 :param callback function: The callback function 10898 for asynchronous request. (optional) 10899 :param str account_id: The external account number (int) or account ID Guid. (required) 10900 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10901 :param str recipient_id: The ID of the recipient being accessed. (required) 10902 :param str include_anchor_tab_locations: When set to **true**, all tabs with anchor tab properties are included in the response. 10903 :param str include_metadata: 10904 :return: Tabs 10905 If the method is called asynchronously, 10906 returns the request thread. 10907 """ 10908 kwargs['_return_http_data_only'] = True 10909 if kwargs.get('callback'): 10910 return self.list_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 10911 else: 10912 (data) = self.list_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 10913 return data 10914 10915 def list_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 10916 """ 10917 Gets the tabs information for a signer or sign-in-person recipient in an envelope. 10918 Retrieves information about the tabs associated with a recipient in a draft envelope. 10919 This method makes a synchronous HTTP request by default. To make an 10920 asynchronous HTTP request, please define a `callback` function 10921 to be invoked when receiving the response. 10922 >>> def callback_function(response): 10923 >>> pprint(response) 10924 >>> 10925 >>> thread = api.list_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 10926 10927 :param callback function: The callback function 10928 for asynchronous request. (optional) 10929 :param str account_id: The external account number (int) or account ID Guid. (required) 10930 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10931 :param str recipient_id: The ID of the recipient being accessed. (required) 10932 :param str include_anchor_tab_locations: When set to **true**, all tabs with anchor tab properties are included in the response. 10933 :param str include_metadata: 10934 :return: Tabs 10935 If the method is called asynchronously, 10936 returns the request thread. 10937 """ 10938 10939 all_params = ['account_id', 'envelope_id', 'recipient_id', 'include_anchor_tab_locations', 'include_metadata'] 10940 all_params.append('callback') 10941 all_params.append('_return_http_data_only') 10942 all_params.append('_preload_content') 10943 all_params.append('_request_timeout') 10944 10945 params = locals() 10946 for key, val in iteritems(params['kwargs']): 10947 if key not in all_params: 10948 raise TypeError( 10949 "Got an unexpected keyword argument '%s'" 10950 " to method list_tabs" % key 10951 ) 10952 params[key] = val 10953 del params['kwargs'] 10954 # verify the required parameter 'account_id' is set 10955 if ('account_id' not in params) or (params['account_id'] is None): 10956 raise ValueError("Missing the required parameter `account_id` when calling `list_tabs`") 10957 # verify the required parameter 'envelope_id' is set 10958 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10959 raise ValueError("Missing the required parameter `envelope_id` when calling `list_tabs`") 10960 # verify the required parameter 'recipient_id' is set 10961 if ('recipient_id' not in params) or (params['recipient_id'] is None): 10962 raise ValueError("Missing the required parameter `recipient_id` when calling `list_tabs`") 10963 10964 10965 collection_formats = {} 10966 10967 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/tabs'.replace('{format}', 'json') 10968 path_params = {} 10969 if 'account_id' in params: 10970 path_params['accountId'] = params['account_id'] 10971 if 'envelope_id' in params: 10972 path_params['envelopeId'] = params['envelope_id'] 10973 if 'recipient_id' in params: 10974 path_params['recipientId'] = params['recipient_id'] 10975 10976 query_params = {} 10977 if 'include_anchor_tab_locations' in params: 10978 query_params['include_anchor_tab_locations'] = params['include_anchor_tab_locations'] 10979 if 'include_metadata' in params: 10980 query_params['include_metadata'] = params['include_metadata'] 10981 10982 header_params = {} 10983 10984 form_params = [] 10985 local_var_files = {} 10986 10987 body_params = None 10988 # HTTP header `Accept` 10989 header_params['Accept'] = self.api_client.\ 10990 select_header_accept(['application/json']) 10991 10992 # Authentication setting 10993 auth_settings = [] 10994 10995 return self.api_client.call_api(resource_path, 'GET', 10996 path_params, 10997 query_params, 10998 header_params, 10999 body=body_params, 11000 post_params=form_params, 11001 files=local_var_files, 11002 response_type='Tabs', 11003 auth_settings=auth_settings, 11004 callback=params.get('callback'), 11005 _return_http_data_only=params.get('_return_http_data_only'), 11006 _preload_content=params.get('_preload_content', True), 11007 _request_timeout=params.get('_request_timeout'), 11008 collection_formats=collection_formats) 11009 11010 def list_templates(self, account_id, envelope_id, **kwargs): 11011 """ 11012 Get List of Templates used in an Envelope 11013 This returns a list of the server-side templates, their name and ID, used in an envelope. 11014 This method makes a synchronous HTTP request by default. To make an 11015 asynchronous HTTP request, please define a `callback` function 11016 to be invoked when receiving the response. 11017 >>> def callback_function(response): 11018 >>> pprint(response) 11019 >>> 11020 >>> thread = api.list_templates(account_id, envelope_id, callback=callback_function) 11021 11022 :param callback function: The callback function 11023 for asynchronous request. (optional) 11024 :param str account_id: The external account number (int) or account ID Guid. (required) 11025 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11026 :param str include: The possible values are: matching_applied - This returns template matching information for the template. 11027 :return: TemplateInformation 11028 If the method is called asynchronously, 11029 returns the request thread. 11030 """ 11031 kwargs['_return_http_data_only'] = True 11032 if kwargs.get('callback'): 11033 return self.list_templates_with_http_info(account_id, envelope_id, **kwargs) 11034 else: 11035 (data) = self.list_templates_with_http_info(account_id, envelope_id, **kwargs) 11036 return data 11037 11038 def list_templates_with_http_info(self, account_id, envelope_id, **kwargs): 11039 """ 11040 Get List of Templates used in an Envelope 11041 This returns a list of the server-side templates, their name and ID, used in an envelope. 11042 This method makes a synchronous HTTP request by default. To make an 11043 asynchronous HTTP request, please define a `callback` function 11044 to be invoked when receiving the response. 11045 >>> def callback_function(response): 11046 >>> pprint(response) 11047 >>> 11048 >>> thread = api.list_templates_with_http_info(account_id, envelope_id, callback=callback_function) 11049 11050 :param callback function: The callback function 11051 for asynchronous request. (optional) 11052 :param str account_id: The external account number (int) or account ID Guid. (required) 11053 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11054 :param str include: The possible values are: matching_applied - This returns template matching information for the template. 11055 :return: TemplateInformation 11056 If the method is called asynchronously, 11057 returns the request thread. 11058 """ 11059 11060 all_params = ['account_id', 'envelope_id', 'include'] 11061 all_params.append('callback') 11062 all_params.append('_return_http_data_only') 11063 all_params.append('_preload_content') 11064 all_params.append('_request_timeout') 11065 11066 params = locals() 11067 for key, val in iteritems(params['kwargs']): 11068 if key not in all_params: 11069 raise TypeError( 11070 "Got an unexpected keyword argument '%s'" 11071 " to method list_templates" % key 11072 ) 11073 params[key] = val 11074 del params['kwargs'] 11075 # verify the required parameter 'account_id' is set 11076 if ('account_id' not in params) or (params['account_id'] is None): 11077 raise ValueError("Missing the required parameter `account_id` when calling `list_templates`") 11078 # verify the required parameter 'envelope_id' is set 11079 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11080 raise ValueError("Missing the required parameter `envelope_id` when calling `list_templates`") 11081 11082 11083 collection_formats = {} 11084 11085 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/templates'.replace('{format}', 'json') 11086 path_params = {} 11087 if 'account_id' in params: 11088 path_params['accountId'] = params['account_id'] 11089 if 'envelope_id' in params: 11090 path_params['envelopeId'] = params['envelope_id'] 11091 11092 query_params = {} 11093 if 'include' in params: 11094 query_params['include'] = params['include'] 11095 11096 header_params = {} 11097 11098 form_params = [] 11099 local_var_files = {} 11100 11101 body_params = None 11102 # HTTP header `Accept` 11103 header_params['Accept'] = self.api_client.\ 11104 select_header_accept(['application/json']) 11105 11106 # Authentication setting 11107 auth_settings = [] 11108 11109 return self.api_client.call_api(resource_path, 'GET', 11110 path_params, 11111 query_params, 11112 header_params, 11113 body=body_params, 11114 post_params=form_params, 11115 files=local_var_files, 11116 response_type='TemplateInformation', 11117 auth_settings=auth_settings, 11118 callback=params.get('callback'), 11119 _return_http_data_only=params.get('_return_http_data_only'), 11120 _preload_content=params.get('_preload_content', True), 11121 _request_timeout=params.get('_request_timeout'), 11122 collection_formats=collection_formats) 11123 11124 def list_templates_for_document(self, account_id, document_id, envelope_id, **kwargs): 11125 """ 11126 Gets the templates associated with a document in an existing envelope. 11127 Retrieves the templates associated with a document in the specified envelope. 11128 This method makes a synchronous HTTP request by default. To make an 11129 asynchronous HTTP request, please define a `callback` function 11130 to be invoked when receiving the response. 11131 >>> def callback_function(response): 11132 >>> pprint(response) 11133 >>> 11134 >>> thread = api.list_templates_for_document(account_id, document_id, envelope_id, callback=callback_function) 11135 11136 :param callback function: The callback function 11137 for asynchronous request. (optional) 11138 :param str account_id: The external account number (int) or account ID Guid. (required) 11139 :param str document_id: The ID of the document being accessed. (required) 11140 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11141 :param str include: 11142 :return: TemplateInformation 11143 If the method is called asynchronously, 11144 returns the request thread. 11145 """ 11146 kwargs['_return_http_data_only'] = True 11147 if kwargs.get('callback'): 11148 return self.list_templates_for_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 11149 else: 11150 (data) = self.list_templates_for_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 11151 return data 11152 11153 def list_templates_for_document_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 11154 """ 11155 Gets the templates associated with a document in an existing envelope. 11156 Retrieves the templates associated with a document in the specified envelope. 11157 This method makes a synchronous HTTP request by default. To make an 11158 asynchronous HTTP request, please define a `callback` function 11159 to be invoked when receiving the response. 11160 >>> def callback_function(response): 11161 >>> pprint(response) 11162 >>> 11163 >>> thread = api.list_templates_for_document_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 11164 11165 :param callback function: The callback function 11166 for asynchronous request. (optional) 11167 :param str account_id: The external account number (int) or account ID Guid. (required) 11168 :param str document_id: The ID of the document being accessed. (required) 11169 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11170 :param str include: 11171 :return: TemplateInformation 11172 If the method is called asynchronously, 11173 returns the request thread. 11174 """ 11175 11176 all_params = ['account_id', 'document_id', 'envelope_id', 'include'] 11177 all_params.append('callback') 11178 all_params.append('_return_http_data_only') 11179 all_params.append('_preload_content') 11180 all_params.append('_request_timeout') 11181 11182 params = locals() 11183 for key, val in iteritems(params['kwargs']): 11184 if key not in all_params: 11185 raise TypeError( 11186 "Got an unexpected keyword argument '%s'" 11187 " to method list_templates_for_document" % key 11188 ) 11189 params[key] = val 11190 del params['kwargs'] 11191 # verify the required parameter 'account_id' is set 11192 if ('account_id' not in params) or (params['account_id'] is None): 11193 raise ValueError("Missing the required parameter `account_id` when calling `list_templates_for_document`") 11194 # verify the required parameter 'document_id' is set 11195 if ('document_id' not in params) or (params['document_id'] is None): 11196 raise ValueError("Missing the required parameter `document_id` when calling `list_templates_for_document`") 11197 # verify the required parameter 'envelope_id' is set 11198 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11199 raise ValueError("Missing the required parameter `envelope_id` when calling `list_templates_for_document`") 11200 11201 11202 collection_formats = {} 11203 11204 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/templates'.replace('{format}', 'json') 11205 path_params = {} 11206 if 'account_id' in params: 11207 path_params['accountId'] = params['account_id'] 11208 if 'document_id' in params: 11209 path_params['documentId'] = params['document_id'] 11210 if 'envelope_id' in params: 11211 path_params['envelopeId'] = params['envelope_id'] 11212 11213 query_params = {} 11214 if 'include' in params: 11215 query_params['include'] = params['include'] 11216 11217 header_params = {} 11218 11219 form_params = [] 11220 local_var_files = {} 11221 11222 body_params = None 11223 # HTTP header `Accept` 11224 header_params['Accept'] = self.api_client.\ 11225 select_header_accept(['application/json']) 11226 11227 # Authentication setting 11228 auth_settings = [] 11229 11230 return self.api_client.call_api(resource_path, 'GET', 11231 path_params, 11232 query_params, 11233 header_params, 11234 body=body_params, 11235 post_params=form_params, 11236 files=local_var_files, 11237 response_type='TemplateInformation', 11238 auth_settings=auth_settings, 11239 callback=params.get('callback'), 11240 _return_http_data_only=params.get('_return_http_data_only'), 11241 _preload_content=params.get('_preload_content', True), 11242 _request_timeout=params.get('_request_timeout'), 11243 collection_formats=collection_formats) 11244 11245 def put_attachment(self, account_id, attachment_id, envelope_id, **kwargs): 11246 """ 11247 Add an attachment to a DRAFT or IN-PROCESS envelope. 11248 Adds an attachment to a draft or in-process envelope. 11249 This method makes a synchronous HTTP request by default. To make an 11250 asynchronous HTTP request, please define a `callback` function 11251 to be invoked when receiving the response. 11252 >>> def callback_function(response): 11253 >>> pprint(response) 11254 >>> 11255 >>> thread = api.put_attachment(account_id, attachment_id, envelope_id, callback=callback_function) 11256 11257 :param callback function: The callback function 11258 for asynchronous request. (optional) 11259 :param str account_id: The external account number (int) or account ID Guid. (required) 11260 :param str attachment_id: (required) 11261 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11262 :param Attachment attachment: 11263 :return: EnvelopeAttachmentsResult 11264 If the method is called asynchronously, 11265 returns the request thread. 11266 """ 11267 kwargs['_return_http_data_only'] = True 11268 if kwargs.get('callback'): 11269 return self.put_attachment_with_http_info(account_id, attachment_id, envelope_id, **kwargs) 11270 else: 11271 (data) = self.put_attachment_with_http_info(account_id, attachment_id, envelope_id, **kwargs) 11272 return data 11273 11274 def put_attachment_with_http_info(self, account_id, attachment_id, envelope_id, **kwargs): 11275 """ 11276 Add an attachment to a DRAFT or IN-PROCESS envelope. 11277 Adds an attachment to a draft or in-process envelope. 11278 This method makes a synchronous HTTP request by default. To make an 11279 asynchronous HTTP request, please define a `callback` function 11280 to be invoked when receiving the response. 11281 >>> def callback_function(response): 11282 >>> pprint(response) 11283 >>> 11284 >>> thread = api.put_attachment_with_http_info(account_id, attachment_id, envelope_id, callback=callback_function) 11285 11286 :param callback function: The callback function 11287 for asynchronous request. (optional) 11288 :param str account_id: The external account number (int) or account ID Guid. (required) 11289 :param str attachment_id: (required) 11290 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11291 :param Attachment attachment: 11292 :return: EnvelopeAttachmentsResult 11293 If the method is called asynchronously, 11294 returns the request thread. 11295 """ 11296 11297 all_params = ['account_id', 'attachment_id', 'envelope_id', 'attachment'] 11298 all_params.append('callback') 11299 all_params.append('_return_http_data_only') 11300 all_params.append('_preload_content') 11301 all_params.append('_request_timeout') 11302 11303 params = locals() 11304 for key, val in iteritems(params['kwargs']): 11305 if key not in all_params: 11306 raise TypeError( 11307 "Got an unexpected keyword argument '%s'" 11308 " to method put_attachment" % key 11309 ) 11310 params[key] = val 11311 del params['kwargs'] 11312 # verify the required parameter 'account_id' is set 11313 if ('account_id' not in params) or (params['account_id'] is None): 11314 raise ValueError("Missing the required parameter `account_id` when calling `put_attachment`") 11315 # verify the required parameter 'attachment_id' is set 11316 if ('attachment_id' not in params) or (params['attachment_id'] is None): 11317 raise ValueError("Missing the required parameter `attachment_id` when calling `put_attachment`") 11318 # verify the required parameter 'envelope_id' is set 11319 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11320 raise ValueError("Missing the required parameter `envelope_id` when calling `put_attachment`") 11321 11322 11323 collection_formats = {} 11324 11325 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments/{attachmentId}'.replace('{format}', 'json') 11326 path_params = {} 11327 if 'account_id' in params: 11328 path_params['accountId'] = params['account_id'] 11329 if 'attachment_id' in params: 11330 path_params['attachmentId'] = params['attachment_id'] 11331 if 'envelope_id' in params: 11332 path_params['envelopeId'] = params['envelope_id'] 11333 11334 query_params = {} 11335 11336 header_params = {} 11337 11338 form_params = [] 11339 local_var_files = {} 11340 11341 body_params = None 11342 if 'attachment' in params: 11343 body_params = params['attachment'] 11344 # HTTP header `Accept` 11345 header_params['Accept'] = self.api_client.\ 11346 select_header_accept(['application/json']) 11347 11348 # Authentication setting 11349 auth_settings = [] 11350 11351 return self.api_client.call_api(resource_path, 'PUT', 11352 path_params, 11353 query_params, 11354 header_params, 11355 body=body_params, 11356 post_params=form_params, 11357 files=local_var_files, 11358 response_type='EnvelopeAttachmentsResult', 11359 auth_settings=auth_settings, 11360 callback=params.get('callback'), 11361 _return_http_data_only=params.get('_return_http_data_only'), 11362 _preload_content=params.get('_preload_content', True), 11363 _request_timeout=params.get('_request_timeout'), 11364 collection_formats=collection_formats) 11365 11366 def put_attachments(self, account_id, envelope_id, **kwargs): 11367 """ 11368 Add one or more attachments to a DRAFT or IN-PROCESS envelope. 11369 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). 11370 This method makes a synchronous HTTP request by default. To make an 11371 asynchronous HTTP request, please define a `callback` function 11372 to be invoked when receiving the response. 11373 >>> def callback_function(response): 11374 >>> pprint(response) 11375 >>> 11376 >>> thread = api.put_attachments(account_id, envelope_id, callback=callback_function) 11377 11378 :param callback function: The callback function 11379 for asynchronous request. (optional) 11380 :param str account_id: The external account number (int) or account ID Guid. (required) 11381 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11382 :param EnvelopeAttachmentsRequest envelope_attachments_request: 11383 :return: EnvelopeAttachmentsResult 11384 If the method is called asynchronously, 11385 returns the request thread. 11386 """ 11387 kwargs['_return_http_data_only'] = True 11388 if kwargs.get('callback'): 11389 return self.put_attachments_with_http_info(account_id, envelope_id, **kwargs) 11390 else: 11391 (data) = self.put_attachments_with_http_info(account_id, envelope_id, **kwargs) 11392 return data 11393 11394 def put_attachments_with_http_info(self, account_id, envelope_id, **kwargs): 11395 """ 11396 Add one or more attachments to a DRAFT or IN-PROCESS envelope. 11397 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). 11398 This method makes a synchronous HTTP request by default. To make an 11399 asynchronous HTTP request, please define a `callback` function 11400 to be invoked when receiving the response. 11401 >>> def callback_function(response): 11402 >>> pprint(response) 11403 >>> 11404 >>> thread = api.put_attachments_with_http_info(account_id, envelope_id, callback=callback_function) 11405 11406 :param callback function: The callback function 11407 for asynchronous request. (optional) 11408 :param str account_id: The external account number (int) or account ID Guid. (required) 11409 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11410 :param EnvelopeAttachmentsRequest envelope_attachments_request: 11411 :return: EnvelopeAttachmentsResult 11412 If the method is called asynchronously, 11413 returns the request thread. 11414 """ 11415 11416 all_params = ['account_id', 'envelope_id', 'envelope_attachments_request'] 11417 all_params.append('callback') 11418 all_params.append('_return_http_data_only') 11419 all_params.append('_preload_content') 11420 all_params.append('_request_timeout') 11421 11422 params = locals() 11423 for key, val in iteritems(params['kwargs']): 11424 if key not in all_params: 11425 raise TypeError( 11426 "Got an unexpected keyword argument '%s'" 11427 " to method put_attachments" % key 11428 ) 11429 params[key] = val 11430 del params['kwargs'] 11431 # verify the required parameter 'account_id' is set 11432 if ('account_id' not in params) or (params['account_id'] is None): 11433 raise ValueError("Missing the required parameter `account_id` when calling `put_attachments`") 11434 # verify the required parameter 'envelope_id' is set 11435 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11436 raise ValueError("Missing the required parameter `envelope_id` when calling `put_attachments`") 11437 11438 11439 collection_formats = {} 11440 11441 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments'.replace('{format}', 'json') 11442 path_params = {} 11443 if 'account_id' in params: 11444 path_params['accountId'] = params['account_id'] 11445 if 'envelope_id' in params: 11446 path_params['envelopeId'] = params['envelope_id'] 11447 11448 query_params = {} 11449 11450 header_params = {} 11451 11452 form_params = [] 11453 local_var_files = {} 11454 11455 body_params = None 11456 if 'envelope_attachments_request' in params: 11457 body_params = params['envelope_attachments_request'] 11458 # HTTP header `Accept` 11459 header_params['Accept'] = self.api_client.\ 11460 select_header_accept(['application/json']) 11461 11462 # Authentication setting 11463 auth_settings = [] 11464 11465 return self.api_client.call_api(resource_path, 'PUT', 11466 path_params, 11467 query_params, 11468 header_params, 11469 body=body_params, 11470 post_params=form_params, 11471 files=local_var_files, 11472 response_type='EnvelopeAttachmentsResult', 11473 auth_settings=auth_settings, 11474 callback=params.get('callback'), 11475 _return_http_data_only=params.get('_return_http_data_only'), 11476 _preload_content=params.get('_preload_content', True), 11477 _request_timeout=params.get('_request_timeout'), 11478 collection_formats=collection_formats) 11479 11480 def rotate_document_page(self, account_id, document_id, envelope_id, page_number, **kwargs): 11481 """ 11482 Rotates page image from an envelope for display. 11483 Rotates page image from an envelope for display. The page image can be rotated to the left or right. 11484 This method makes a synchronous HTTP request by default. To make an 11485 asynchronous HTTP request, please define a `callback` function 11486 to be invoked when receiving the response. 11487 >>> def callback_function(response): 11488 >>> pprint(response) 11489 >>> 11490 >>> thread = api.rotate_document_page(account_id, document_id, envelope_id, page_number, callback=callback_function) 11491 11492 :param callback function: The callback function 11493 for asynchronous request. (optional) 11494 :param str account_id: The external account number (int) or account ID Guid. (required) 11495 :param str document_id: The ID of the document being accessed. (required) 11496 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11497 :param str page_number: The page number being accessed. (required) 11498 :param PageRequest page_request: 11499 :return: None 11500 If the method is called asynchronously, 11501 returns the request thread. 11502 """ 11503 kwargs['_return_http_data_only'] = True 11504 if kwargs.get('callback'): 11505 return self.rotate_document_page_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 11506 else: 11507 (data) = self.rotate_document_page_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 11508 return data 11509 11510 def rotate_document_page_with_http_info(self, account_id, document_id, envelope_id, page_number, **kwargs): 11511 """ 11512 Rotates page image from an envelope for display. 11513 Rotates page image from an envelope for display. The page image can be rotated to the left or right. 11514 This method makes a synchronous HTTP request by default. To make an 11515 asynchronous HTTP request, please define a `callback` function 11516 to be invoked when receiving the response. 11517 >>> def callback_function(response): 11518 >>> pprint(response) 11519 >>> 11520 >>> thread = api.rotate_document_page_with_http_info(account_id, document_id, envelope_id, page_number, callback=callback_function) 11521 11522 :param callback function: The callback function 11523 for asynchronous request. (optional) 11524 :param str account_id: The external account number (int) or account ID Guid. (required) 11525 :param str document_id: The ID of the document being accessed. (required) 11526 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11527 :param str page_number: The page number being accessed. (required) 11528 :param PageRequest page_request: 11529 :return: None 11530 If the method is called asynchronously, 11531 returns the request thread. 11532 """ 11533 11534 all_params = ['account_id', 'document_id', 'envelope_id', 'page_number', 'page_request'] 11535 all_params.append('callback') 11536 all_params.append('_return_http_data_only') 11537 all_params.append('_preload_content') 11538 all_params.append('_request_timeout') 11539 11540 params = locals() 11541 for key, val in iteritems(params['kwargs']): 11542 if key not in all_params: 11543 raise TypeError( 11544 "Got an unexpected keyword argument '%s'" 11545 " to method rotate_document_page" % key 11546 ) 11547 params[key] = val 11548 del params['kwargs'] 11549 # verify the required parameter 'account_id' is set 11550 if ('account_id' not in params) or (params['account_id'] is None): 11551 raise ValueError("Missing the required parameter `account_id` when calling `rotate_document_page`") 11552 # verify the required parameter 'document_id' is set 11553 if ('document_id' not in params) or (params['document_id'] is None): 11554 raise ValueError("Missing the required parameter `document_id` when calling `rotate_document_page`") 11555 # verify the required parameter 'envelope_id' is set 11556 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11557 raise ValueError("Missing the required parameter `envelope_id` when calling `rotate_document_page`") 11558 # verify the required parameter 'page_number' is set 11559 if ('page_number' not in params) or (params['page_number'] is None): 11560 raise ValueError("Missing the required parameter `page_number` when calling `rotate_document_page`") 11561 11562 11563 collection_formats = {} 11564 11565 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/pages/{pageNumber}/page_image'.replace('{format}', 'json') 11566 path_params = {} 11567 if 'account_id' in params: 11568 path_params['accountId'] = params['account_id'] 11569 if 'document_id' in params: 11570 path_params['documentId'] = params['document_id'] 11571 if 'envelope_id' in params: 11572 path_params['envelopeId'] = params['envelope_id'] 11573 if 'page_number' in params: 11574 path_params['pageNumber'] = params['page_number'] 11575 11576 query_params = {} 11577 11578 header_params = {} 11579 11580 form_params = [] 11581 local_var_files = {} 11582 11583 body_params = None 11584 if 'page_request' in params: 11585 body_params = params['page_request'] 11586 # HTTP header `Accept` 11587 header_params['Accept'] = self.api_client.\ 11588 select_header_accept(['application/json']) 11589 11590 # Authentication setting 11591 auth_settings = [] 11592 11593 return self.api_client.call_api(resource_path, 'PUT', 11594 path_params, 11595 query_params, 11596 header_params, 11597 body=body_params, 11598 post_params=form_params, 11599 files=local_var_files, 11600 response_type=None, 11601 auth_settings=auth_settings, 11602 callback=params.get('callback'), 11603 _return_http_data_only=params.get('_return_http_data_only'), 11604 _preload_content=params.get('_preload_content', True), 11605 _request_timeout=params.get('_request_timeout'), 11606 collection_formats=collection_formats) 11607 11608 def update(self, account_id, envelope_id, **kwargs): 11609 """ 11610 Send Draft Envelope/Void Envelope/Move/Purge Envelope/Modify draft 11611 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. 11612 This method makes a synchronous HTTP request by default. To make an 11613 asynchronous HTTP request, please define a `callback` function 11614 to be invoked when receiving the response. 11615 >>> def callback_function(response): 11616 >>> pprint(response) 11617 >>> 11618 >>> thread = api.update(account_id, envelope_id, callback=callback_function) 11619 11620 :param callback function: The callback function 11621 for asynchronous request. (optional) 11622 :param str account_id: The external account number (int) or account ID Guid. (required) 11623 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11624 :param str advanced_update: When set to **true**, allows the caller to update recipients, tabs, custom fields, notification, email settings and other envelope attributes. 11625 :param str resend_envelope: When set to **true**, sends the specified envelope again. 11626 :param Envelope envelope: 11627 :return: EnvelopeUpdateSummary 11628 If the method is called asynchronously, 11629 returns the request thread. 11630 """ 11631 kwargs['_return_http_data_only'] = True 11632 if kwargs.get('callback'): 11633 return self.update_with_http_info(account_id, envelope_id, **kwargs) 11634 else: 11635 (data) = self.update_with_http_info(account_id, envelope_id, **kwargs) 11636 return data 11637 11638 def update_with_http_info(self, account_id, envelope_id, **kwargs): 11639 """ 11640 Send Draft Envelope/Void Envelope/Move/Purge Envelope/Modify draft 11641 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. 11642 This method makes a synchronous HTTP request by default. To make an 11643 asynchronous HTTP request, please define a `callback` function 11644 to be invoked when receiving the response. 11645 >>> def callback_function(response): 11646 >>> pprint(response) 11647 >>> 11648 >>> thread = api.update_with_http_info(account_id, envelope_id, callback=callback_function) 11649 11650 :param callback function: The callback function 11651 for asynchronous request. (optional) 11652 :param str account_id: The external account number (int) or account ID Guid. (required) 11653 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11654 :param str advanced_update: When set to **true**, allows the caller to update recipients, tabs, custom fields, notification, email settings and other envelope attributes. 11655 :param str resend_envelope: When set to **true**, sends the specified envelope again. 11656 :param Envelope envelope: 11657 :return: EnvelopeUpdateSummary 11658 If the method is called asynchronously, 11659 returns the request thread. 11660 """ 11661 11662 all_params = ['account_id', 'envelope_id', 'advanced_update', 'resend_envelope', 'envelope'] 11663 all_params.append('callback') 11664 all_params.append('_return_http_data_only') 11665 all_params.append('_preload_content') 11666 all_params.append('_request_timeout') 11667 11668 params = locals() 11669 for key, val in iteritems(params['kwargs']): 11670 if key not in all_params: 11671 raise TypeError( 11672 "Got an unexpected keyword argument '%s'" 11673 " to method update" % key 11674 ) 11675 params[key] = val 11676 del params['kwargs'] 11677 # verify the required parameter 'account_id' is set 11678 if ('account_id' not in params) or (params['account_id'] is None): 11679 raise ValueError("Missing the required parameter `account_id` when calling `update`") 11680 # verify the required parameter 'envelope_id' is set 11681 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11682 raise ValueError("Missing the required parameter `envelope_id` when calling `update`") 11683 11684 11685 collection_formats = {} 11686 11687 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}'.replace('{format}', 'json') 11688 path_params = {} 11689 if 'account_id' in params: 11690 path_params['accountId'] = params['account_id'] 11691 if 'envelope_id' in params: 11692 path_params['envelopeId'] = params['envelope_id'] 11693 11694 query_params = {} 11695 if 'advanced_update' in params: 11696 query_params['advanced_update'] = params['advanced_update'] 11697 if 'resend_envelope' in params: 11698 query_params['resend_envelope'] = params['resend_envelope'] 11699 11700 header_params = {} 11701 11702 form_params = [] 11703 local_var_files = {} 11704 11705 body_params = None 11706 if 'envelope' in params: 11707 body_params = params['envelope'] 11708 # HTTP header `Accept` 11709 header_params['Accept'] = self.api_client.\ 11710 select_header_accept(['application/json']) 11711 11712 # Authentication setting 11713 auth_settings = [] 11714 11715 return self.api_client.call_api(resource_path, 'PUT', 11716 path_params, 11717 query_params, 11718 header_params, 11719 body=body_params, 11720 post_params=form_params, 11721 files=local_var_files, 11722 response_type='EnvelopeUpdateSummary', 11723 auth_settings=auth_settings, 11724 callback=params.get('callback'), 11725 _return_http_data_only=params.get('_return_http_data_only'), 11726 _preload_content=params.get('_preload_content', True), 11727 _request_timeout=params.get('_request_timeout'), 11728 collection_formats=collection_formats) 11729 11730 def update_chunked_upload(self, account_id, chunked_upload_id, **kwargs): 11731 """ 11732 Integrity-Check and Commit a ChunkedUpload, readying it for use elsewhere. 11733 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. 11734 This method makes a synchronous HTTP request by default. To make an 11735 asynchronous HTTP request, please define a `callback` function 11736 to be invoked when receiving the response. 11737 >>> def callback_function(response): 11738 >>> pprint(response) 11739 >>> 11740 >>> thread = api.update_chunked_upload(account_id, chunked_upload_id, callback=callback_function) 11741 11742 :param callback function: The callback function 11743 for asynchronous request. (optional) 11744 :param str account_id: The external account number (int) or account ID Guid. (required) 11745 :param str chunked_upload_id: (required) 11746 :param str action: 11747 :return: ChunkedUploadResponse 11748 If the method is called asynchronously, 11749 returns the request thread. 11750 """ 11751 kwargs['_return_http_data_only'] = True 11752 if kwargs.get('callback'): 11753 return self.update_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 11754 else: 11755 (data) = self.update_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 11756 return data 11757 11758 def update_chunked_upload_with_http_info(self, account_id, chunked_upload_id, **kwargs): 11759 """ 11760 Integrity-Check and Commit a ChunkedUpload, readying it for use elsewhere. 11761 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. 11762 This method makes a synchronous HTTP request by default. To make an 11763 asynchronous HTTP request, please define a `callback` function 11764 to be invoked when receiving the response. 11765 >>> def callback_function(response): 11766 >>> pprint(response) 11767 >>> 11768 >>> thread = api.update_chunked_upload_with_http_info(account_id, chunked_upload_id, callback=callback_function) 11769 11770 :param callback function: The callback function 11771 for asynchronous request. (optional) 11772 :param str account_id: The external account number (int) or account ID Guid. (required) 11773 :param str chunked_upload_id: (required) 11774 :param str action: 11775 :return: ChunkedUploadResponse 11776 If the method is called asynchronously, 11777 returns the request thread. 11778 """ 11779 11780 all_params = ['account_id', 'chunked_upload_id', 'action'] 11781 all_params.append('callback') 11782 all_params.append('_return_http_data_only') 11783 all_params.append('_preload_content') 11784 all_params.append('_request_timeout') 11785 11786 params = locals() 11787 for key, val in iteritems(params['kwargs']): 11788 if key not in all_params: 11789 raise TypeError( 11790 "Got an unexpected keyword argument '%s'" 11791 " to method update_chunked_upload" % key 11792 ) 11793 params[key] = val 11794 del params['kwargs'] 11795 # verify the required parameter 'account_id' is set 11796 if ('account_id' not in params) or (params['account_id'] is None): 11797 raise ValueError("Missing the required parameter `account_id` when calling `update_chunked_upload`") 11798 # verify the required parameter 'chunked_upload_id' is set 11799 if ('chunked_upload_id' not in params) or (params['chunked_upload_id'] is None): 11800 raise ValueError("Missing the required parameter `chunked_upload_id` when calling `update_chunked_upload`") 11801 11802 11803 collection_formats = {} 11804 11805 resource_path = '/v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}'.replace('{format}', 'json') 11806 path_params = {} 11807 if 'account_id' in params: 11808 path_params['accountId'] = params['account_id'] 11809 if 'chunked_upload_id' in params: 11810 path_params['chunkedUploadId'] = params['chunked_upload_id'] 11811 11812 query_params = {} 11813 if 'action' in params: 11814 query_params['action'] = params['action'] 11815 11816 header_params = {} 11817 11818 form_params = [] 11819 local_var_files = {} 11820 11821 body_params = None 11822 # HTTP header `Accept` 11823 header_params['Accept'] = self.api_client.\ 11824 select_header_accept(['application/json']) 11825 11826 # Authentication setting 11827 auth_settings = [] 11828 11829 return self.api_client.call_api(resource_path, 'PUT', 11830 path_params, 11831 query_params, 11832 header_params, 11833 body=body_params, 11834 post_params=form_params, 11835 files=local_var_files, 11836 response_type='ChunkedUploadResponse', 11837 auth_settings=auth_settings, 11838 callback=params.get('callback'), 11839 _return_http_data_only=params.get('_return_http_data_only'), 11840 _preload_content=params.get('_preload_content', True), 11841 _request_timeout=params.get('_request_timeout'), 11842 collection_formats=collection_formats) 11843 11844 def update_chunked_upload_part(self, account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs): 11845 """ 11846 Add a chunk, a chunk 'part', to an existing ChunkedUpload. 11847 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. 11848 This method makes a synchronous HTTP request by default. To make an 11849 asynchronous HTTP request, please define a `callback` function 11850 to be invoked when receiving the response. 11851 >>> def callback_function(response): 11852 >>> pprint(response) 11853 >>> 11854 >>> thread = api.update_chunked_upload_part(account_id, chunked_upload_id, chunked_upload_part_seq, callback=callback_function) 11855 11856 :param callback function: The callback function 11857 for asynchronous request. (optional) 11858 :param str account_id: The external account number (int) or account ID Guid. (required) 11859 :param str chunked_upload_id: (required) 11860 :param str chunked_upload_part_seq: (required) 11861 :param ChunkedUploadRequest chunked_upload_request: 11862 :return: ChunkedUploadResponse 11863 If the method is called asynchronously, 11864 returns the request thread. 11865 """ 11866 kwargs['_return_http_data_only'] = True 11867 if kwargs.get('callback'): 11868 return self.update_chunked_upload_part_with_http_info(account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs) 11869 else: 11870 (data) = self.update_chunked_upload_part_with_http_info(account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs) 11871 return data 11872 11873 def update_chunked_upload_part_with_http_info(self, account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs): 11874 """ 11875 Add a chunk, a chunk 'part', to an existing ChunkedUpload. 11876 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. 11877 This method makes a synchronous HTTP request by default. To make an 11878 asynchronous HTTP request, please define a `callback` function 11879 to be invoked when receiving the response. 11880 >>> def callback_function(response): 11881 >>> pprint(response) 11882 >>> 11883 >>> thread = api.update_chunked_upload_part_with_http_info(account_id, chunked_upload_id, chunked_upload_part_seq, callback=callback_function) 11884 11885 :param callback function: The callback function 11886 for asynchronous request. (optional) 11887 :param str account_id: The external account number (int) or account ID Guid. (required) 11888 :param str chunked_upload_id: (required) 11889 :param str chunked_upload_part_seq: (required) 11890 :param ChunkedUploadRequest chunked_upload_request: 11891 :return: ChunkedUploadResponse 11892 If the method is called asynchronously, 11893 returns the request thread. 11894 """ 11895 11896 all_params = ['account_id', 'chunked_upload_id', 'chunked_upload_part_seq', 'chunked_upload_request'] 11897 all_params.append('callback') 11898 all_params.append('_return_http_data_only') 11899 all_params.append('_preload_content') 11900 all_params.append('_request_timeout') 11901 11902 params = locals() 11903 for key, val in iteritems(params['kwargs']): 11904 if key not in all_params: 11905 raise TypeError( 11906 "Got an unexpected keyword argument '%s'" 11907 " to method update_chunked_upload_part" % key 11908 ) 11909 params[key] = val 11910 del params['kwargs'] 11911 # verify the required parameter 'account_id' is set 11912 if ('account_id' not in params) or (params['account_id'] is None): 11913 raise ValueError("Missing the required parameter `account_id` when calling `update_chunked_upload_part`") 11914 # verify the required parameter 'chunked_upload_id' is set 11915 if ('chunked_upload_id' not in params) or (params['chunked_upload_id'] is None): 11916 raise ValueError("Missing the required parameter `chunked_upload_id` when calling `update_chunked_upload_part`") 11917 # verify the required parameter 'chunked_upload_part_seq' is set 11918 if ('chunked_upload_part_seq' not in params) or (params['chunked_upload_part_seq'] is None): 11919 raise ValueError("Missing the required parameter `chunked_upload_part_seq` when calling `update_chunked_upload_part`") 11920 11921 11922 collection_formats = {} 11923 11924 resource_path = '/v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}/{chunkedUploadPartSeq}'.replace('{format}', 'json') 11925 path_params = {} 11926 if 'account_id' in params: 11927 path_params['accountId'] = params['account_id'] 11928 if 'chunked_upload_id' in params: 11929 path_params['chunkedUploadId'] = params['chunked_upload_id'] 11930 if 'chunked_upload_part_seq' in params: 11931 path_params['chunkedUploadPartSeq'] = params['chunked_upload_part_seq'] 11932 11933 query_params = {} 11934 11935 header_params = {} 11936 11937 form_params = [] 11938 local_var_files = {} 11939 11940 body_params = None 11941 if 'chunked_upload_request' in params: 11942 body_params = params['chunked_upload_request'] 11943 # HTTP header `Accept` 11944 header_params['Accept'] = self.api_client.\ 11945 select_header_accept(['application/json']) 11946 11947 # Authentication setting 11948 auth_settings = [] 11949 11950 return self.api_client.call_api(resource_path, 'PUT', 11951 path_params, 11952 query_params, 11953 header_params, 11954 body=body_params, 11955 post_params=form_params, 11956 files=local_var_files, 11957 response_type='ChunkedUploadResponse', 11958 auth_settings=auth_settings, 11959 callback=params.get('callback'), 11960 _return_http_data_only=params.get('_return_http_data_only'), 11961 _preload_content=params.get('_preload_content', True), 11962 _request_timeout=params.get('_request_timeout'), 11963 collection_formats=collection_formats) 11964 11965 def update_custom_fields(self, account_id, envelope_id, **kwargs): 11966 """ 11967 Updates envelope custom fields in an envelope. 11968 Updates the envelope custom fields in draft and in-process envelopes. Each custom field used in an envelope must have a unique name. 11969 This method makes a synchronous HTTP request by default. To make an 11970 asynchronous HTTP request, please define a `callback` function 11971 to be invoked when receiving the response. 11972 >>> def callback_function(response): 11973 >>> pprint(response) 11974 >>> 11975 >>> thread = api.update_custom_fields(account_id, envelope_id, callback=callback_function) 11976 11977 :param callback function: The callback function 11978 for asynchronous request. (optional) 11979 :param str account_id: The external account number (int) or account ID Guid. (required) 11980 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11981 :param CustomFields custom_fields: 11982 :return: CustomFields 11983 If the method is called asynchronously, 11984 returns the request thread. 11985 """ 11986 kwargs['_return_http_data_only'] = True 11987 if kwargs.get('callback'): 11988 return self.update_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 11989 else: 11990 (data) = self.update_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 11991 return data 11992 11993 def update_custom_fields_with_http_info(self, account_id, envelope_id, **kwargs): 11994 """ 11995 Updates envelope custom fields in an envelope. 11996 Updates the envelope custom fields in draft and in-process envelopes. Each custom field used in an envelope must have a unique name. 11997 This method makes a synchronous HTTP request by default. To make an 11998 asynchronous HTTP request, please define a `callback` function 11999 to be invoked when receiving the response. 12000 >>> def callback_function(response): 12001 >>> pprint(response) 12002 >>> 12003 >>> thread = api.update_custom_fields_with_http_info(account_id, envelope_id, callback=callback_function) 12004 12005 :param callback function: The callback function 12006 for asynchronous request. (optional) 12007 :param str account_id: The external account number (int) or account ID Guid. (required) 12008 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12009 :param CustomFields custom_fields: 12010 :return: CustomFields 12011 If the method is called asynchronously, 12012 returns the request thread. 12013 """ 12014 12015 all_params = ['account_id', 'envelope_id', 'custom_fields'] 12016 all_params.append('callback') 12017 all_params.append('_return_http_data_only') 12018 all_params.append('_preload_content') 12019 all_params.append('_request_timeout') 12020 12021 params = locals() 12022 for key, val in iteritems(params['kwargs']): 12023 if key not in all_params: 12024 raise TypeError( 12025 "Got an unexpected keyword argument '%s'" 12026 " to method update_custom_fields" % key 12027 ) 12028 params[key] = val 12029 del params['kwargs'] 12030 # verify the required parameter 'account_id' is set 12031 if ('account_id' not in params) or (params['account_id'] is None): 12032 raise ValueError("Missing the required parameter `account_id` when calling `update_custom_fields`") 12033 # verify the required parameter 'envelope_id' is set 12034 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12035 raise ValueError("Missing the required parameter `envelope_id` when calling `update_custom_fields`") 12036 12037 12038 collection_formats = {} 12039 12040 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/custom_fields'.replace('{format}', 'json') 12041 path_params = {} 12042 if 'account_id' in params: 12043 path_params['accountId'] = params['account_id'] 12044 if 'envelope_id' in params: 12045 path_params['envelopeId'] = params['envelope_id'] 12046 12047 query_params = {} 12048 12049 header_params = {} 12050 12051 form_params = [] 12052 local_var_files = {} 12053 12054 body_params = None 12055 if 'custom_fields' in params: 12056 body_params = params['custom_fields'] 12057 # HTTP header `Accept` 12058 header_params['Accept'] = self.api_client.\ 12059 select_header_accept(['application/json']) 12060 12061 # Authentication setting 12062 auth_settings = [] 12063 12064 return self.api_client.call_api(resource_path, 'PUT', 12065 path_params, 12066 query_params, 12067 header_params, 12068 body=body_params, 12069 post_params=form_params, 12070 files=local_var_files, 12071 response_type='CustomFields', 12072 auth_settings=auth_settings, 12073 callback=params.get('callback'), 12074 _return_http_data_only=params.get('_return_http_data_only'), 12075 _preload_content=params.get('_preload_content', True), 12076 _request_timeout=params.get('_request_timeout'), 12077 collection_formats=collection_formats) 12078 12079 def update_document(self, account_id, document_id, envelope_id, document_file_bytes, **kwargs): 12080 """ 12081 Adds a document to an existing draft envelope. 12082 Adds a document to an existing draft envelope. 12083 This method makes a synchronous HTTP request by default. To make an 12084 asynchronous HTTP request, please define a `callback` function 12085 to be invoked when receiving the response. 12086 >>> def callback_function(response): 12087 >>> pprint(response) 12088 >>> 12089 >>> thread = api.update_document(account_id, document_id, envelope_id, document_file_bytes, callback=callback_function) 12090 12091 :param callback function: The callback function 12092 for asynchronous request. (optional) 12093 :param str account_id: The external account number (int) or account ID Guid. (required) 12094 :param str document_id: The ID of the document being accessed. (required) 12095 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12096 :param str document_file_bytes: Updated document content. (required) 12097 :return: EnvelopeDocument 12098 If the method is called asynchronously, 12099 returns the request thread. 12100 """ 12101 kwargs['_return_http_data_only'] = True 12102 if kwargs.get('callback'): 12103 return self.update_document_with_http_info(account_id, document_id, envelope_id, document_file_bytes, **kwargs) 12104 else: 12105 (data) = self.update_document_with_http_info(account_id, document_id, envelope_id, document_file_bytes, **kwargs) 12106 return data 12107 12108 def update_document_with_http_info(self, account_id, document_id, envelope_id, document_file_bytes, **kwargs): 12109 """ 12110 Adds a document to an existing draft envelope. 12111 Adds a document to an existing draft envelope. 12112 This method makes a synchronous HTTP request by default. To make an 12113 asynchronous HTTP request, please define a `callback` function 12114 to be invoked when receiving the response. 12115 >>> def callback_function(response): 12116 >>> pprint(response) 12117 >>> 12118 >>> thread = api.update_document_with_http_info(account_id, document_id, envelope_id, document_file_bytes, callback=callback_function) 12119 12120 :param callback function: The callback function 12121 for asynchronous request. (optional) 12122 :param str account_id: The external account number (int) or account ID Guid. (required) 12123 :param str document_id: The ID of the document being accessed. (required) 12124 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12125 :param str document_file_bytes: Updated document content. (required) 12126 :return: EnvelopeDocument 12127 If the method is called asynchronously, 12128 returns the request thread. 12129 """ 12130 12131 all_params = ['account_id', 'document_id', 'envelope_id', 'document_file_bytes'] 12132 all_params.append('callback') 12133 all_params.append('_return_http_data_only') 12134 all_params.append('_preload_content') 12135 all_params.append('_request_timeout') 12136 12137 params = locals() 12138 for key, val in iteritems(params['kwargs']): 12139 if key not in all_params: 12140 raise TypeError( 12141 "Got an unexpected keyword argument '%s'" 12142 " to method update_document" % key 12143 ) 12144 params[key] = val 12145 del params['kwargs'] 12146 # verify the required parameter 'account_id' is set 12147 if ('account_id' not in params) or (params['account_id'] is None): 12148 raise ValueError("Missing the required parameter `account_id` when calling `update_document`") 12149 # verify the required parameter 'document_id' is set 12150 if ('document_id' not in params) or (params['document_id'] is None): 12151 raise ValueError("Missing the required parameter `document_id` when calling `update_document`") 12152 # verify the required parameter 'envelope_id' is set 12153 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12154 raise ValueError("Missing the required parameter `envelope_id` when calling `update_document`") 12155 # verify the required parameter 'document_file_bytes' is set 12156 if ('document_file_bytes' not in params) or (params['document_file_bytes'] is None): 12157 raise ValueError("Missing the required parameter `document_file_bytes` when calling `update_document`") 12158 12159 12160 collection_formats = {} 12161 12162 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}'.replace('{format}', 'json') 12163 path_params = {} 12164 if 'account_id' in params: 12165 path_params['accountId'] = params['account_id'] 12166 if 'document_id' in params: 12167 path_params['documentId'] = params['document_id'] 12168 if 'envelope_id' in params: 12169 path_params['envelopeId'] = params['envelope_id'] 12170 12171 query_params = {} 12172 12173 header_params = {} 12174 12175 form_params = [] 12176 local_var_files = {} 12177 12178 body_params = None 12179 if 'document_file_bytes' in params: 12180 body_params = params['document_file_bytes'] 12181 # HTTP header `Accept` 12182 header_params['Accept'] = self.api_client.\ 12183 select_header_accept(['application/json']) 12184 12185 # HTTP header `Content-Type` 12186 header_params['Content-Type'] = self.api_client.\ 12187 select_header_content_type(['application/pdf']) 12188 12189 # Authentication setting 12190 auth_settings = [] 12191 12192 return self.api_client.call_api(resource_path, 'PUT', 12193 path_params, 12194 query_params, 12195 header_params, 12196 body=body_params, 12197 post_params=form_params, 12198 files=local_var_files, 12199 response_type='EnvelopeDocument', 12200 auth_settings=auth_settings, 12201 callback=params.get('callback'), 12202 _return_http_data_only=params.get('_return_http_data_only'), 12203 _preload_content=params.get('_preload_content', True), 12204 _request_timeout=params.get('_request_timeout'), 12205 collection_formats=collection_formats) 12206 12207 def update_document_fields(self, account_id, document_id, envelope_id, **kwargs): 12208 """ 12209 Updates existing custom document fields in an existing envelope document. 12210 Updates existing custom document fields in an existing envelope document. 12211 This method makes a synchronous HTTP request by default. To make an 12212 asynchronous HTTP request, please define a `callback` function 12213 to be invoked when receiving the response. 12214 >>> def callback_function(response): 12215 >>> pprint(response) 12216 >>> 12217 >>> thread = api.update_document_fields(account_id, document_id, envelope_id, callback=callback_function) 12218 12219 :param callback function: The callback function 12220 for asynchronous request. (optional) 12221 :param str account_id: The external account number (int) or account ID Guid. (required) 12222 :param str document_id: The ID of the document being accessed. (required) 12223 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12224 :param DocumentFieldsInformation document_fields_information: 12225 :return: DocumentFieldsInformation 12226 If the method is called asynchronously, 12227 returns the request thread. 12228 """ 12229 kwargs['_return_http_data_only'] = True 12230 if kwargs.get('callback'): 12231 return self.update_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 12232 else: 12233 (data) = self.update_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 12234 return data 12235 12236 def update_document_fields_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 12237 """ 12238 Updates existing custom document fields in an existing envelope document. 12239 Updates existing custom document fields in an existing envelope document. 12240 This method makes a synchronous HTTP request by default. To make an 12241 asynchronous HTTP request, please define a `callback` function 12242 to be invoked when receiving the response. 12243 >>> def callback_function(response): 12244 >>> pprint(response) 12245 >>> 12246 >>> thread = api.update_document_fields_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 12247 12248 :param callback function: The callback function 12249 for asynchronous request. (optional) 12250 :param str account_id: The external account number (int) or account ID Guid. (required) 12251 :param str document_id: The ID of the document being accessed. (required) 12252 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12253 :param DocumentFieldsInformation document_fields_information: 12254 :return: DocumentFieldsInformation 12255 If the method is called asynchronously, 12256 returns the request thread. 12257 """ 12258 12259 all_params = ['account_id', 'document_id', 'envelope_id', 'document_fields_information'] 12260 all_params.append('callback') 12261 all_params.append('_return_http_data_only') 12262 all_params.append('_preload_content') 12263 all_params.append('_request_timeout') 12264 12265 params = locals() 12266 for key, val in iteritems(params['kwargs']): 12267 if key not in all_params: 12268 raise TypeError( 12269 "Got an unexpected keyword argument '%s'" 12270 " to method update_document_fields" % key 12271 ) 12272 params[key] = val 12273 del params['kwargs'] 12274 # verify the required parameter 'account_id' is set 12275 if ('account_id' not in params) or (params['account_id'] is None): 12276 raise ValueError("Missing the required parameter `account_id` when calling `update_document_fields`") 12277 # verify the required parameter 'document_id' is set 12278 if ('document_id' not in params) or (params['document_id'] is None): 12279 raise ValueError("Missing the required parameter `document_id` when calling `update_document_fields`") 12280 # verify the required parameter 'envelope_id' is set 12281 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12282 raise ValueError("Missing the required parameter `envelope_id` when calling `update_document_fields`") 12283 12284 12285 collection_formats = {} 12286 12287 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/fields'.replace('{format}', 'json') 12288 path_params = {} 12289 if 'account_id' in params: 12290 path_params['accountId'] = params['account_id'] 12291 if 'document_id' in params: 12292 path_params['documentId'] = params['document_id'] 12293 if 'envelope_id' in params: 12294 path_params['envelopeId'] = params['envelope_id'] 12295 12296 query_params = {} 12297 12298 header_params = {} 12299 12300 form_params = [] 12301 local_var_files = {} 12302 12303 body_params = None 12304 if 'document_fields_information' in params: 12305 body_params = params['document_fields_information'] 12306 # HTTP header `Accept` 12307 header_params['Accept'] = self.api_client.\ 12308 select_header_accept(['application/json']) 12309 12310 # Authentication setting 12311 auth_settings = [] 12312 12313 return self.api_client.call_api(resource_path, 'PUT', 12314 path_params, 12315 query_params, 12316 header_params, 12317 body=body_params, 12318 post_params=form_params, 12319 files=local_var_files, 12320 response_type='DocumentFieldsInformation', 12321 auth_settings=auth_settings, 12322 callback=params.get('callback'), 12323 _return_http_data_only=params.get('_return_http_data_only'), 12324 _preload_content=params.get('_preload_content', True), 12325 _request_timeout=params.get('_request_timeout'), 12326 collection_formats=collection_formats) 12327 12328 def update_document_tabs(self, account_id, document_id, envelope_id, **kwargs): 12329 """ 12330 Updates the tabs for an envelope document 12331 Updates tabs in the document specified by `documentId` in the envelope specified by `envelopeId`. 12332 This method makes a synchronous HTTP request by default. To make an 12333 asynchronous HTTP request, please define a `callback` function 12334 to be invoked when receiving the response. 12335 >>> def callback_function(response): 12336 >>> pprint(response) 12337 >>> 12338 >>> thread = api.update_document_tabs(account_id, document_id, envelope_id, callback=callback_function) 12339 12340 :param callback function: The callback function 12341 for asynchronous request. (optional) 12342 :param str account_id: The external account number (int) or account ID Guid. (required) 12343 :param str document_id: The ID of the document being accessed. (required) 12344 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12345 :param Tabs tabs: 12346 :return: Tabs 12347 If the method is called asynchronously, 12348 returns the request thread. 12349 """ 12350 kwargs['_return_http_data_only'] = True 12351 if kwargs.get('callback'): 12352 return self.update_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 12353 else: 12354 (data) = self.update_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 12355 return data 12356 12357 def update_document_tabs_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 12358 """ 12359 Updates the tabs for an envelope document 12360 Updates tabs in the document specified by `documentId` in the envelope specified by `envelopeId`. 12361 This method makes a synchronous HTTP request by default. To make an 12362 asynchronous HTTP request, please define a `callback` function 12363 to be invoked when receiving the response. 12364 >>> def callback_function(response): 12365 >>> pprint(response) 12366 >>> 12367 >>> thread = api.update_document_tabs_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 12368 12369 :param callback function: The callback function 12370 for asynchronous request. (optional) 12371 :param str account_id: The external account number (int) or account ID Guid. (required) 12372 :param str document_id: The ID of the document being accessed. (required) 12373 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12374 :param Tabs tabs: 12375 :return: Tabs 12376 If the method is called asynchronously, 12377 returns the request thread. 12378 """ 12379 12380 all_params = ['account_id', 'document_id', 'envelope_id', 'tabs'] 12381 all_params.append('callback') 12382 all_params.append('_return_http_data_only') 12383 all_params.append('_preload_content') 12384 all_params.append('_request_timeout') 12385 12386 params = locals() 12387 for key, val in iteritems(params['kwargs']): 12388 if key not in all_params: 12389 raise TypeError( 12390 "Got an unexpected keyword argument '%s'" 12391 " to method update_document_tabs" % key 12392 ) 12393 params[key] = val 12394 del params['kwargs'] 12395 # verify the required parameter 'account_id' is set 12396 if ('account_id' not in params) or (params['account_id'] is None): 12397 raise ValueError("Missing the required parameter `account_id` when calling `update_document_tabs`") 12398 # verify the required parameter 'document_id' is set 12399 if ('document_id' not in params) or (params['document_id'] is None): 12400 raise ValueError("Missing the required parameter `document_id` when calling `update_document_tabs`") 12401 # verify the required parameter 'envelope_id' is set 12402 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12403 raise ValueError("Missing the required parameter `envelope_id` when calling `update_document_tabs`") 12404 12405 12406 collection_formats = {} 12407 12408 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/tabs'.replace('{format}', 'json') 12409 path_params = {} 12410 if 'account_id' in params: 12411 path_params['accountId'] = params['account_id'] 12412 if 'document_id' in params: 12413 path_params['documentId'] = params['document_id'] 12414 if 'envelope_id' in params: 12415 path_params['envelopeId'] = params['envelope_id'] 12416 12417 query_params = {} 12418 12419 header_params = {} 12420 12421 form_params = [] 12422 local_var_files = {} 12423 12424 body_params = None 12425 if 'tabs' in params: 12426 body_params = params['tabs'] 12427 # HTTP header `Accept` 12428 header_params['Accept'] = self.api_client.\ 12429 select_header_accept(['application/json']) 12430 12431 # Authentication setting 12432 auth_settings = [] 12433 12434 return self.api_client.call_api(resource_path, 'PUT', 12435 path_params, 12436 query_params, 12437 header_params, 12438 body=body_params, 12439 post_params=form_params, 12440 files=local_var_files, 12441 response_type='Tabs', 12442 auth_settings=auth_settings, 12443 callback=params.get('callback'), 12444 _return_http_data_only=params.get('_return_http_data_only'), 12445 _preload_content=params.get('_preload_content', True), 12446 _request_timeout=params.get('_request_timeout'), 12447 collection_formats=collection_formats) 12448 12449 def update_documents(self, account_id, envelope_id, **kwargs): 12450 """ 12451 Adds one or more documents to an existing envelope document. 12452 Adds one or more documents to an existing envelope document. 12453 This method makes a synchronous HTTP request by default. To make an 12454 asynchronous HTTP request, please define a `callback` function 12455 to be invoked when receiving the response. 12456 >>> def callback_function(response): 12457 >>> pprint(response) 12458 >>> 12459 >>> thread = api.update_documents(account_id, envelope_id, callback=callback_function) 12460 12461 :param callback function: The callback function 12462 for asynchronous request. (optional) 12463 :param str account_id: The external account number (int) or account ID Guid. (required) 12464 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12465 :param EnvelopeDefinition envelope_definition: 12466 :return: EnvelopeDocumentsResult 12467 If the method is called asynchronously, 12468 returns the request thread. 12469 """ 12470 kwargs['_return_http_data_only'] = True 12471 if kwargs.get('callback'): 12472 return self.update_documents_with_http_info(account_id, envelope_id, **kwargs) 12473 else: 12474 (data) = self.update_documents_with_http_info(account_id, envelope_id, **kwargs) 12475 return data 12476 12477 def update_documents_with_http_info(self, account_id, envelope_id, **kwargs): 12478 """ 12479 Adds one or more documents to an existing envelope document. 12480 Adds one or more documents to an existing envelope document. 12481 This method makes a synchronous HTTP request by default. To make an 12482 asynchronous HTTP request, please define a `callback` function 12483 to be invoked when receiving the response. 12484 >>> def callback_function(response): 12485 >>> pprint(response) 12486 >>> 12487 >>> thread = api.update_documents_with_http_info(account_id, envelope_id, callback=callback_function) 12488 12489 :param callback function: The callback function 12490 for asynchronous request. (optional) 12491 :param str account_id: The external account number (int) or account ID Guid. (required) 12492 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12493 :param EnvelopeDefinition envelope_definition: 12494 :return: EnvelopeDocumentsResult 12495 If the method is called asynchronously, 12496 returns the request thread. 12497 """ 12498 12499 all_params = ['account_id', 'envelope_id', 'envelope_definition'] 12500 all_params.append('callback') 12501 all_params.append('_return_http_data_only') 12502 all_params.append('_preload_content') 12503 all_params.append('_request_timeout') 12504 12505 params = locals() 12506 for key, val in iteritems(params['kwargs']): 12507 if key not in all_params: 12508 raise TypeError( 12509 "Got an unexpected keyword argument '%s'" 12510 " to method update_documents" % key 12511 ) 12512 params[key] = val 12513 del params['kwargs'] 12514 # verify the required parameter 'account_id' is set 12515 if ('account_id' not in params) or (params['account_id'] is None): 12516 raise ValueError("Missing the required parameter `account_id` when calling `update_documents`") 12517 # verify the required parameter 'envelope_id' is set 12518 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12519 raise ValueError("Missing the required parameter `envelope_id` when calling `update_documents`") 12520 12521 12522 collection_formats = {} 12523 12524 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents'.replace('{format}', 'json') 12525 path_params = {} 12526 if 'account_id' in params: 12527 path_params['accountId'] = params['account_id'] 12528 if 'envelope_id' in params: 12529 path_params['envelopeId'] = params['envelope_id'] 12530 12531 query_params = {} 12532 12533 header_params = {} 12534 12535 form_params = [] 12536 local_var_files = {} 12537 12538 body_params = None 12539 if 'envelope_definition' in params: 12540 body_params = params['envelope_definition'] 12541 # HTTP header `Accept` 12542 header_params['Accept'] = self.api_client.\ 12543 select_header_accept(['application/json']) 12544 12545 # Authentication setting 12546 auth_settings = [] 12547 12548 return self.api_client.call_api(resource_path, 'PUT', 12549 path_params, 12550 query_params, 12551 header_params, 12552 body=body_params, 12553 post_params=form_params, 12554 files=local_var_files, 12555 response_type='EnvelopeDocumentsResult', 12556 auth_settings=auth_settings, 12557 callback=params.get('callback'), 12558 _return_http_data_only=params.get('_return_http_data_only'), 12559 _preload_content=params.get('_preload_content', True), 12560 _request_timeout=params.get('_request_timeout'), 12561 collection_formats=collection_formats) 12562 12563 def update_email_settings(self, account_id, envelope_id, **kwargs): 12564 """ 12565 Updates the email setting overrides for an envelope. 12566 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. 12567 This method makes a synchronous HTTP request by default. To make an 12568 asynchronous HTTP request, please define a `callback` function 12569 to be invoked when receiving the response. 12570 >>> def callback_function(response): 12571 >>> pprint(response) 12572 >>> 12573 >>> thread = api.update_email_settings(account_id, envelope_id, callback=callback_function) 12574 12575 :param callback function: The callback function 12576 for asynchronous request. (optional) 12577 :param str account_id: The external account number (int) or account ID Guid. (required) 12578 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12579 :param EmailSettings email_settings: 12580 :return: EmailSettings 12581 If the method is called asynchronously, 12582 returns the request thread. 12583 """ 12584 kwargs['_return_http_data_only'] = True 12585 if kwargs.get('callback'): 12586 return self.update_email_settings_with_http_info(account_id, envelope_id, **kwargs) 12587 else: 12588 (data) = self.update_email_settings_with_http_info(account_id, envelope_id, **kwargs) 12589 return data 12590 12591 def update_email_settings_with_http_info(self, account_id, envelope_id, **kwargs): 12592 """ 12593 Updates the email setting overrides for an envelope. 12594 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. 12595 This method makes a synchronous HTTP request by default. To make an 12596 asynchronous HTTP request, please define a `callback` function 12597 to be invoked when receiving the response. 12598 >>> def callback_function(response): 12599 >>> pprint(response) 12600 >>> 12601 >>> thread = api.update_email_settings_with_http_info(account_id, envelope_id, callback=callback_function) 12602 12603 :param callback function: The callback function 12604 for asynchronous request. (optional) 12605 :param str account_id: The external account number (int) or account ID Guid. (required) 12606 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12607 :param EmailSettings email_settings: 12608 :return: EmailSettings 12609 If the method is called asynchronously, 12610 returns the request thread. 12611 """ 12612 12613 all_params = ['account_id', 'envelope_id', 'email_settings'] 12614 all_params.append('callback') 12615 all_params.append('_return_http_data_only') 12616 all_params.append('_preload_content') 12617 all_params.append('_request_timeout') 12618 12619 params = locals() 12620 for key, val in iteritems(params['kwargs']): 12621 if key not in all_params: 12622 raise TypeError( 12623 "Got an unexpected keyword argument '%s'" 12624 " to method update_email_settings" % key 12625 ) 12626 params[key] = val 12627 del params['kwargs'] 12628 # verify the required parameter 'account_id' is set 12629 if ('account_id' not in params) or (params['account_id'] is None): 12630 raise ValueError("Missing the required parameter `account_id` when calling `update_email_settings`") 12631 # verify the required parameter 'envelope_id' is set 12632 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12633 raise ValueError("Missing the required parameter `envelope_id` when calling `update_email_settings`") 12634 12635 12636 collection_formats = {} 12637 12638 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/email_settings'.replace('{format}', 'json') 12639 path_params = {} 12640 if 'account_id' in params: 12641 path_params['accountId'] = params['account_id'] 12642 if 'envelope_id' in params: 12643 path_params['envelopeId'] = params['envelope_id'] 12644 12645 query_params = {} 12646 12647 header_params = {} 12648 12649 form_params = [] 12650 local_var_files = {} 12651 12652 body_params = None 12653 if 'email_settings' in params: 12654 body_params = params['email_settings'] 12655 # HTTP header `Accept` 12656 header_params['Accept'] = self.api_client.\ 12657 select_header_accept(['application/json']) 12658 12659 # Authentication setting 12660 auth_settings = [] 12661 12662 return self.api_client.call_api(resource_path, 'PUT', 12663 path_params, 12664 query_params, 12665 header_params, 12666 body=body_params, 12667 post_params=form_params, 12668 files=local_var_files, 12669 response_type='EmailSettings', 12670 auth_settings=auth_settings, 12671 callback=params.get('callback'), 12672 _return_http_data_only=params.get('_return_http_data_only'), 12673 _preload_content=params.get('_preload_content', True), 12674 _request_timeout=params.get('_request_timeout'), 12675 collection_formats=collection_formats) 12676 12677 def update_envelope_delayed_routing_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 12678 """ 12679 Updates the delayed routing rules for an envelope's workflow step definition. 12680 This method makes a synchronous HTTP request by default. To make an 12681 asynchronous HTTP request, please define a `callback` function 12682 to be invoked when receiving the response. 12683 >>> def callback_function(response): 12684 >>> pprint(response) 12685 >>> 12686 >>> thread = api.update_envelope_delayed_routing_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 12687 12688 :param callback function: The callback function 12689 for asynchronous request. (optional) 12690 :param str account_id: The external account number (int) or account ID Guid. (required) 12691 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12692 :param str workflow_step_id: (required) 12693 :param DelayedRouting delayed_routing: 12694 :return: DelayedRouting 12695 If the method is called asynchronously, 12696 returns the request thread. 12697 """ 12698 kwargs['_return_http_data_only'] = True 12699 if kwargs.get('callback'): 12700 return self.update_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 12701 else: 12702 (data) = self.update_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 12703 return data 12704 12705 def update_envelope_delayed_routing_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 12706 """ 12707 Updates the delayed routing rules for an envelope's workflow step definition. 12708 This method makes a synchronous HTTP request by default. To make an 12709 asynchronous HTTP request, please define a `callback` function 12710 to be invoked when receiving the response. 12711 >>> def callback_function(response): 12712 >>> pprint(response) 12713 >>> 12714 >>> thread = api.update_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 12715 12716 :param callback function: The callback function 12717 for asynchronous request. (optional) 12718 :param str account_id: The external account number (int) or account ID Guid. (required) 12719 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12720 :param str workflow_step_id: (required) 12721 :param DelayedRouting delayed_routing: 12722 :return: DelayedRouting 12723 If the method is called asynchronously, 12724 returns the request thread. 12725 """ 12726 12727 all_params = ['account_id', 'envelope_id', 'workflow_step_id', 'delayed_routing'] 12728 all_params.append('callback') 12729 all_params.append('_return_http_data_only') 12730 all_params.append('_preload_content') 12731 all_params.append('_request_timeout') 12732 12733 params = locals() 12734 for key, val in iteritems(params['kwargs']): 12735 if key not in all_params: 12736 raise TypeError( 12737 "Got an unexpected keyword argument '%s'" 12738 " to method update_envelope_delayed_routing_definition" % key 12739 ) 12740 params[key] = val 12741 del params['kwargs'] 12742 # verify the required parameter 'account_id' is set 12743 if ('account_id' not in params) or (params['account_id'] is None): 12744 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_delayed_routing_definition`") 12745 # verify the required parameter 'envelope_id' is set 12746 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12747 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_delayed_routing_definition`") 12748 # verify the required parameter 'workflow_step_id' is set 12749 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 12750 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_envelope_delayed_routing_definition`") 12751 12752 12753 collection_formats = {} 12754 12755 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 12756 path_params = {} 12757 if 'account_id' in params: 12758 path_params['accountId'] = params['account_id'] 12759 if 'envelope_id' in params: 12760 path_params['envelopeId'] = params['envelope_id'] 12761 if 'workflow_step_id' in params: 12762 path_params['workflowStepId'] = params['workflow_step_id'] 12763 12764 query_params = {} 12765 12766 header_params = {} 12767 12768 form_params = [] 12769 local_var_files = {} 12770 12771 body_params = None 12772 if 'delayed_routing' in params: 12773 body_params = params['delayed_routing'] 12774 # HTTP header `Accept` 12775 header_params['Accept'] = self.api_client.\ 12776 select_header_accept(['application/json']) 12777 12778 # Authentication setting 12779 auth_settings = [] 12780 12781 return self.api_client.call_api(resource_path, 'PUT', 12782 path_params, 12783 query_params, 12784 header_params, 12785 body=body_params, 12786 post_params=form_params, 12787 files=local_var_files, 12788 response_type='DelayedRouting', 12789 auth_settings=auth_settings, 12790 callback=params.get('callback'), 12791 _return_http_data_only=params.get('_return_http_data_only'), 12792 _preload_content=params.get('_preload_content', True), 12793 _request_timeout=params.get('_request_timeout'), 12794 collection_formats=collection_formats) 12795 12796 def update_envelope_doc_gen_form_fields(self, account_id, envelope_id, **kwargs): 12797 """ 12798 Updates formfields for an envelope 12799 This method makes a synchronous HTTP request by default. To make an 12800 asynchronous HTTP request, please define a `callback` function 12801 to be invoked when receiving the response. 12802 >>> def callback_function(response): 12803 >>> pprint(response) 12804 >>> 12805 >>> thread = api.update_envelope_doc_gen_form_fields(account_id, envelope_id, callback=callback_function) 12806 12807 :param callback function: The callback function 12808 for asynchronous request. (optional) 12809 :param str account_id: The external account number (int) or account ID Guid. (required) 12810 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12811 :param str update_docgen_formfields_only: 12812 :param DocGenFormFieldRequest doc_gen_form_field_request: 12813 :return: DocGenFormFieldResponse 12814 If the method is called asynchronously, 12815 returns the request thread. 12816 """ 12817 kwargs['_return_http_data_only'] = True 12818 if kwargs.get('callback'): 12819 return self.update_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, **kwargs) 12820 else: 12821 (data) = self.update_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, **kwargs) 12822 return data 12823 12824 def update_envelope_doc_gen_form_fields_with_http_info(self, account_id, envelope_id, **kwargs): 12825 """ 12826 Updates formfields for an envelope 12827 This method makes a synchronous HTTP request by default. To make an 12828 asynchronous HTTP request, please define a `callback` function 12829 to be invoked when receiving the response. 12830 >>> def callback_function(response): 12831 >>> pprint(response) 12832 >>> 12833 >>> thread = api.update_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, callback=callback_function) 12834 12835 :param callback function: The callback function 12836 for asynchronous request. (optional) 12837 :param str account_id: The external account number (int) or account ID Guid. (required) 12838 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12839 :param str update_docgen_formfields_only: 12840 :param DocGenFormFieldRequest doc_gen_form_field_request: 12841 :return: DocGenFormFieldResponse 12842 If the method is called asynchronously, 12843 returns the request thread. 12844 """ 12845 12846 all_params = ['account_id', 'envelope_id', 'update_docgen_formfields_only', 'doc_gen_form_field_request'] 12847 all_params.append('callback') 12848 all_params.append('_return_http_data_only') 12849 all_params.append('_preload_content') 12850 all_params.append('_request_timeout') 12851 12852 params = locals() 12853 for key, val in iteritems(params['kwargs']): 12854 if key not in all_params: 12855 raise TypeError( 12856 "Got an unexpected keyword argument '%s'" 12857 " to method update_envelope_doc_gen_form_fields" % key 12858 ) 12859 params[key] = val 12860 del params['kwargs'] 12861 # verify the required parameter 'account_id' is set 12862 if ('account_id' not in params) or (params['account_id'] is None): 12863 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_doc_gen_form_fields`") 12864 # verify the required parameter 'envelope_id' is set 12865 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12866 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_doc_gen_form_fields`") 12867 12868 12869 collection_formats = {} 12870 12871 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/docGenFormFields'.replace('{format}', 'json') 12872 path_params = {} 12873 if 'account_id' in params: 12874 path_params['accountId'] = params['account_id'] 12875 if 'envelope_id' in params: 12876 path_params['envelopeId'] = params['envelope_id'] 12877 12878 query_params = {} 12879 if 'update_docgen_formfields_only' in params: 12880 query_params['update_docgen_formfields_only'] = params['update_docgen_formfields_only'] 12881 12882 header_params = {} 12883 12884 form_params = [] 12885 local_var_files = {} 12886 12887 body_params = None 12888 if 'doc_gen_form_field_request' in params: 12889 body_params = params['doc_gen_form_field_request'] 12890 # HTTP header `Accept` 12891 header_params['Accept'] = self.api_client.\ 12892 select_header_accept(['application/json']) 12893 12894 # Authentication setting 12895 auth_settings = [] 12896 12897 return self.api_client.call_api(resource_path, 'PUT', 12898 path_params, 12899 query_params, 12900 header_params, 12901 body=body_params, 12902 post_params=form_params, 12903 files=local_var_files, 12904 response_type='DocGenFormFieldResponse', 12905 auth_settings=auth_settings, 12906 callback=params.get('callback'), 12907 _return_http_data_only=params.get('_return_http_data_only'), 12908 _preload_content=params.get('_preload_content', True), 12909 _request_timeout=params.get('_request_timeout'), 12910 collection_formats=collection_formats) 12911 12912 def update_envelope_scheduled_sending_definition(self, account_id, envelope_id, **kwargs): 12913 """ 12914 Updates the scheduled sending rules for an envelope's workflow definition. 12915 This method makes a synchronous HTTP request by default. To make an 12916 asynchronous HTTP request, please define a `callback` function 12917 to be invoked when receiving the response. 12918 >>> def callback_function(response): 12919 >>> pprint(response) 12920 >>> 12921 >>> thread = api.update_envelope_scheduled_sending_definition(account_id, envelope_id, callback=callback_function) 12922 12923 :param callback function: The callback function 12924 for asynchronous request. (optional) 12925 :param str account_id: The external account number (int) or account ID Guid. (required) 12926 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12927 :param ScheduledSending scheduled_sending: 12928 :return: ScheduledSending 12929 If the method is called asynchronously, 12930 returns the request thread. 12931 """ 12932 kwargs['_return_http_data_only'] = True 12933 if kwargs.get('callback'): 12934 return self.update_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 12935 else: 12936 (data) = self.update_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 12937 return data 12938 12939 def update_envelope_scheduled_sending_definition_with_http_info(self, account_id, envelope_id, **kwargs): 12940 """ 12941 Updates the scheduled sending rules for an envelope's workflow definition. 12942 This method makes a synchronous HTTP request by default. To make an 12943 asynchronous HTTP request, please define a `callback` function 12944 to be invoked when receiving the response. 12945 >>> def callback_function(response): 12946 >>> pprint(response) 12947 >>> 12948 >>> thread = api.update_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, callback=callback_function) 12949 12950 :param callback function: The callback function 12951 for asynchronous request. (optional) 12952 :param str account_id: The external account number (int) or account ID Guid. (required) 12953 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12954 :param ScheduledSending scheduled_sending: 12955 :return: ScheduledSending 12956 If the method is called asynchronously, 12957 returns the request thread. 12958 """ 12959 12960 all_params = ['account_id', 'envelope_id', 'scheduled_sending'] 12961 all_params.append('callback') 12962 all_params.append('_return_http_data_only') 12963 all_params.append('_preload_content') 12964 all_params.append('_request_timeout') 12965 12966 params = locals() 12967 for key, val in iteritems(params['kwargs']): 12968 if key not in all_params: 12969 raise TypeError( 12970 "Got an unexpected keyword argument '%s'" 12971 " to method update_envelope_scheduled_sending_definition" % key 12972 ) 12973 params[key] = val 12974 del params['kwargs'] 12975 # verify the required parameter 'account_id' is set 12976 if ('account_id' not in params) or (params['account_id'] is None): 12977 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_scheduled_sending_definition`") 12978 # verify the required parameter 'envelope_id' is set 12979 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12980 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_scheduled_sending_definition`") 12981 12982 12983 collection_formats = {} 12984 12985 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/scheduledSending'.replace('{format}', 'json') 12986 path_params = {} 12987 if 'account_id' in params: 12988 path_params['accountId'] = params['account_id'] 12989 if 'envelope_id' in params: 12990 path_params['envelopeId'] = params['envelope_id'] 12991 12992 query_params = {} 12993 12994 header_params = {} 12995 12996 form_params = [] 12997 local_var_files = {} 12998 12999 body_params = None 13000 if 'scheduled_sending' in params: 13001 body_params = params['scheduled_sending'] 13002 # HTTP header `Accept` 13003 header_params['Accept'] = self.api_client.\ 13004 select_header_accept(['application/json']) 13005 13006 # Authentication setting 13007 auth_settings = [] 13008 13009 return self.api_client.call_api(resource_path, 'PUT', 13010 path_params, 13011 query_params, 13012 header_params, 13013 body=body_params, 13014 post_params=form_params, 13015 files=local_var_files, 13016 response_type='ScheduledSending', 13017 auth_settings=auth_settings, 13018 callback=params.get('callback'), 13019 _return_http_data_only=params.get('_return_http_data_only'), 13020 _preload_content=params.get('_preload_content', True), 13021 _request_timeout=params.get('_request_timeout'), 13022 collection_formats=collection_formats) 13023 13024 def update_envelope_transfer_rule(self, account_id, envelope_transfer_rule_id, **kwargs): 13025 """ 13026 Update an envelope transfer rule for an account. 13027 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. 13028 This method makes a synchronous HTTP request by default. To make an 13029 asynchronous HTTP request, please define a `callback` function 13030 to be invoked when receiving the response. 13031 >>> def callback_function(response): 13032 >>> pprint(response) 13033 >>> 13034 >>> thread = api.update_envelope_transfer_rule(account_id, envelope_transfer_rule_id, callback=callback_function) 13035 13036 :param callback function: The callback function 13037 for asynchronous request. (optional) 13038 :param str account_id: The external account number (int) or account ID Guid. (required) 13039 :param str envelope_transfer_rule_id: (required) 13040 :param EnvelopeTransferRule envelope_transfer_rule: 13041 :return: EnvelopeTransferRule 13042 If the method is called asynchronously, 13043 returns the request thread. 13044 """ 13045 kwargs['_return_http_data_only'] = True 13046 if kwargs.get('callback'): 13047 return self.update_envelope_transfer_rule_with_http_info(account_id, envelope_transfer_rule_id, **kwargs) 13048 else: 13049 (data) = self.update_envelope_transfer_rule_with_http_info(account_id, envelope_transfer_rule_id, **kwargs) 13050 return data 13051 13052 def update_envelope_transfer_rule_with_http_info(self, account_id, envelope_transfer_rule_id, **kwargs): 13053 """ 13054 Update an envelope transfer rule for an account. 13055 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. 13056 This method makes a synchronous HTTP request by default. To make an 13057 asynchronous HTTP request, please define a `callback` function 13058 to be invoked when receiving the response. 13059 >>> def callback_function(response): 13060 >>> pprint(response) 13061 >>> 13062 >>> thread = api.update_envelope_transfer_rule_with_http_info(account_id, envelope_transfer_rule_id, callback=callback_function) 13063 13064 :param callback function: The callback function 13065 for asynchronous request. (optional) 13066 :param str account_id: The external account number (int) or account ID Guid. (required) 13067 :param str envelope_transfer_rule_id: (required) 13068 :param EnvelopeTransferRule envelope_transfer_rule: 13069 :return: EnvelopeTransferRule 13070 If the method is called asynchronously, 13071 returns the request thread. 13072 """ 13073 13074 all_params = ['account_id', 'envelope_transfer_rule_id', 'envelope_transfer_rule'] 13075 all_params.append('callback') 13076 all_params.append('_return_http_data_only') 13077 all_params.append('_preload_content') 13078 all_params.append('_request_timeout') 13079 13080 params = locals() 13081 for key, val in iteritems(params['kwargs']): 13082 if key not in all_params: 13083 raise TypeError( 13084 "Got an unexpected keyword argument '%s'" 13085 " to method update_envelope_transfer_rule" % key 13086 ) 13087 params[key] = val 13088 del params['kwargs'] 13089 # verify the required parameter 'account_id' is set 13090 if ('account_id' not in params) or (params['account_id'] is None): 13091 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_transfer_rule`") 13092 # verify the required parameter 'envelope_transfer_rule_id' is set 13093 if ('envelope_transfer_rule_id' not in params) or (params['envelope_transfer_rule_id'] is None): 13094 raise ValueError("Missing the required parameter `envelope_transfer_rule_id` when calling `update_envelope_transfer_rule`") 13095 13096 13097 collection_formats = {} 13098 13099 resource_path = '/v2.1/accounts/{accountId}/envelopes/transfer_rules/{envelopeTransferRuleId}'.replace('{format}', 'json') 13100 path_params = {} 13101 if 'account_id' in params: 13102 path_params['accountId'] = params['account_id'] 13103 if 'envelope_transfer_rule_id' in params: 13104 path_params['envelopeTransferRuleId'] = params['envelope_transfer_rule_id'] 13105 13106 query_params = {} 13107 13108 header_params = {} 13109 13110 form_params = [] 13111 local_var_files = {} 13112 13113 body_params = None 13114 if 'envelope_transfer_rule' in params: 13115 body_params = params['envelope_transfer_rule'] 13116 # HTTP header `Accept` 13117 header_params['Accept'] = self.api_client.\ 13118 select_header_accept(['application/json']) 13119 13120 # Authentication setting 13121 auth_settings = [] 13122 13123 return self.api_client.call_api(resource_path, 'PUT', 13124 path_params, 13125 query_params, 13126 header_params, 13127 body=body_params, 13128 post_params=form_params, 13129 files=local_var_files, 13130 response_type='EnvelopeTransferRule', 13131 auth_settings=auth_settings, 13132 callback=params.get('callback'), 13133 _return_http_data_only=params.get('_return_http_data_only'), 13134 _preload_content=params.get('_preload_content', True), 13135 _request_timeout=params.get('_request_timeout'), 13136 collection_formats=collection_formats) 13137 13138 def update_envelope_transfer_rules(self, account_id, **kwargs): 13139 """ 13140 Update envelope transfer rules for an account. 13141 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. 13142 This method makes a synchronous HTTP request by default. To make an 13143 asynchronous HTTP request, please define a `callback` function 13144 to be invoked when receiving the response. 13145 >>> def callback_function(response): 13146 >>> pprint(response) 13147 >>> 13148 >>> thread = api.update_envelope_transfer_rules(account_id, callback=callback_function) 13149 13150 :param callback function: The callback function 13151 for asynchronous request. (optional) 13152 :param str account_id: The external account number (int) or account ID Guid. (required) 13153 :param EnvelopeTransferRuleInformation envelope_transfer_rule_information: 13154 :return: EnvelopeTransferRuleInformation 13155 If the method is called asynchronously, 13156 returns the request thread. 13157 """ 13158 kwargs['_return_http_data_only'] = True 13159 if kwargs.get('callback'): 13160 return self.update_envelope_transfer_rules_with_http_info(account_id, **kwargs) 13161 else: 13162 (data) = self.update_envelope_transfer_rules_with_http_info(account_id, **kwargs) 13163 return data 13164 13165 def update_envelope_transfer_rules_with_http_info(self, account_id, **kwargs): 13166 """ 13167 Update envelope transfer rules for an account. 13168 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. 13169 This method makes a synchronous HTTP request by default. To make an 13170 asynchronous HTTP request, please define a `callback` function 13171 to be invoked when receiving the response. 13172 >>> def callback_function(response): 13173 >>> pprint(response) 13174 >>> 13175 >>> thread = api.update_envelope_transfer_rules_with_http_info(account_id, callback=callback_function) 13176 13177 :param callback function: The callback function 13178 for asynchronous request. (optional) 13179 :param str account_id: The external account number (int) or account ID Guid. (required) 13180 :param EnvelopeTransferRuleInformation envelope_transfer_rule_information: 13181 :return: EnvelopeTransferRuleInformation 13182 If the method is called asynchronously, 13183 returns the request thread. 13184 """ 13185 13186 all_params = ['account_id', 'envelope_transfer_rule_information'] 13187 all_params.append('callback') 13188 all_params.append('_return_http_data_only') 13189 all_params.append('_preload_content') 13190 all_params.append('_request_timeout') 13191 13192 params = locals() 13193 for key, val in iteritems(params['kwargs']): 13194 if key not in all_params: 13195 raise TypeError( 13196 "Got an unexpected keyword argument '%s'" 13197 " to method update_envelope_transfer_rules" % key 13198 ) 13199 params[key] = val 13200 del params['kwargs'] 13201 # verify the required parameter 'account_id' is set 13202 if ('account_id' not in params) or (params['account_id'] is None): 13203 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_transfer_rules`") 13204 13205 13206 collection_formats = {} 13207 13208 resource_path = '/v2.1/accounts/{accountId}/envelopes/transfer_rules'.replace('{format}', 'json') 13209 path_params = {} 13210 if 'account_id' in params: 13211 path_params['accountId'] = params['account_id'] 13212 13213 query_params = {} 13214 13215 header_params = {} 13216 13217 form_params = [] 13218 local_var_files = {} 13219 13220 body_params = None 13221 if 'envelope_transfer_rule_information' in params: 13222 body_params = params['envelope_transfer_rule_information'] 13223 # HTTP header `Accept` 13224 header_params['Accept'] = self.api_client.\ 13225 select_header_accept(['application/json']) 13226 13227 # Authentication setting 13228 auth_settings = [] 13229 13230 return self.api_client.call_api(resource_path, 'PUT', 13231 path_params, 13232 query_params, 13233 header_params, 13234 body=body_params, 13235 post_params=form_params, 13236 files=local_var_files, 13237 response_type='EnvelopeTransferRuleInformation', 13238 auth_settings=auth_settings, 13239 callback=params.get('callback'), 13240 _return_http_data_only=params.get('_return_http_data_only'), 13241 _preload_content=params.get('_preload_content', True), 13242 _request_timeout=params.get('_request_timeout'), 13243 collection_formats=collection_formats) 13244 13245 def update_envelope_workflow_definition(self, account_id, envelope_id, **kwargs): 13246 """ 13247 Updates the envelope workflow definition for an envelope. 13248 Updates the specified envelope's workflow definition if it has one. 13249 This method makes a synchronous HTTP request by default. To make an 13250 asynchronous HTTP request, please define a `callback` function 13251 to be invoked when receiving the response. 13252 >>> def callback_function(response): 13253 >>> pprint(response) 13254 >>> 13255 >>> thread = api.update_envelope_workflow_definition(account_id, envelope_id, callback=callback_function) 13256 13257 :param callback function: The callback function 13258 for asynchronous request. (optional) 13259 :param str account_id: The external account number (int) or account ID Guid. (required) 13260 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13261 :param Workflow workflow: 13262 :return: Workflow 13263 If the method is called asynchronously, 13264 returns the request thread. 13265 """ 13266 kwargs['_return_http_data_only'] = True 13267 if kwargs.get('callback'): 13268 return self.update_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 13269 else: 13270 (data) = self.update_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 13271 return data 13272 13273 def update_envelope_workflow_definition_with_http_info(self, account_id, envelope_id, **kwargs): 13274 """ 13275 Updates the envelope workflow definition for an envelope. 13276 Updates the specified envelope's workflow definition if it has one. 13277 This method makes a synchronous HTTP request by default. To make an 13278 asynchronous HTTP request, please define a `callback` function 13279 to be invoked when receiving the response. 13280 >>> def callback_function(response): 13281 >>> pprint(response) 13282 >>> 13283 >>> thread = api.update_envelope_workflow_definition_with_http_info(account_id, envelope_id, callback=callback_function) 13284 13285 :param callback function: The callback function 13286 for asynchronous request. (optional) 13287 :param str account_id: The external account number (int) or account ID Guid. (required) 13288 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13289 :param Workflow workflow: 13290 :return: Workflow 13291 If the method is called asynchronously, 13292 returns the request thread. 13293 """ 13294 13295 all_params = ['account_id', 'envelope_id', 'workflow'] 13296 all_params.append('callback') 13297 all_params.append('_return_http_data_only') 13298 all_params.append('_preload_content') 13299 all_params.append('_request_timeout') 13300 13301 params = locals() 13302 for key, val in iteritems(params['kwargs']): 13303 if key not in all_params: 13304 raise TypeError( 13305 "Got an unexpected keyword argument '%s'" 13306 " to method update_envelope_workflow_definition" % key 13307 ) 13308 params[key] = val 13309 del params['kwargs'] 13310 # verify the required parameter 'account_id' is set 13311 if ('account_id' not in params) or (params['account_id'] is None): 13312 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_workflow_definition`") 13313 # verify the required parameter 'envelope_id' is set 13314 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13315 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_workflow_definition`") 13316 13317 13318 collection_formats = {} 13319 13320 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow'.replace('{format}', 'json') 13321 path_params = {} 13322 if 'account_id' in params: 13323 path_params['accountId'] = params['account_id'] 13324 if 'envelope_id' in params: 13325 path_params['envelopeId'] = params['envelope_id'] 13326 13327 query_params = {} 13328 13329 header_params = {} 13330 13331 form_params = [] 13332 local_var_files = {} 13333 13334 body_params = None 13335 if 'workflow' in params: 13336 body_params = params['workflow'] 13337 # HTTP header `Accept` 13338 header_params['Accept'] = self.api_client.\ 13339 select_header_accept(['application/json']) 13340 13341 # Authentication setting 13342 auth_settings = [] 13343 13344 return self.api_client.call_api(resource_path, 'PUT', 13345 path_params, 13346 query_params, 13347 header_params, 13348 body=body_params, 13349 post_params=form_params, 13350 files=local_var_files, 13351 response_type='Workflow', 13352 auth_settings=auth_settings, 13353 callback=params.get('callback'), 13354 _return_http_data_only=params.get('_return_http_data_only'), 13355 _preload_content=params.get('_preload_content', True), 13356 _request_timeout=params.get('_request_timeout'), 13357 collection_formats=collection_formats) 13358 13359 def update_envelope_workflow_step_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 13360 """ 13361 Updates the envelope workflow step definition for an envelope. 13362 This method makes a synchronous HTTP request by default. To make an 13363 asynchronous HTTP request, please define a `callback` function 13364 to be invoked when receiving the response. 13365 >>> def callback_function(response): 13366 >>> pprint(response) 13367 >>> 13368 >>> thread = api.update_envelope_workflow_step_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 13369 13370 :param callback function: The callback function 13371 for asynchronous request. (optional) 13372 :param str account_id: The external account number (int) or account ID Guid. (required) 13373 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13374 :param str workflow_step_id: (required) 13375 :param WorkflowStep workflow_step: 13376 :return: WorkflowStep 13377 If the method is called asynchronously, 13378 returns the request thread. 13379 """ 13380 kwargs['_return_http_data_only'] = True 13381 if kwargs.get('callback'): 13382 return self.update_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 13383 else: 13384 (data) = self.update_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 13385 return data 13386 13387 def update_envelope_workflow_step_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 13388 """ 13389 Updates the envelope workflow step definition for an envelope. 13390 This method makes a synchronous HTTP request by default. To make an 13391 asynchronous HTTP request, please define a `callback` function 13392 to be invoked when receiving the response. 13393 >>> def callback_function(response): 13394 >>> pprint(response) 13395 >>> 13396 >>> thread = api.update_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 13397 13398 :param callback function: The callback function 13399 for asynchronous request. (optional) 13400 :param str account_id: The external account number (int) or account ID Guid. (required) 13401 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13402 :param str workflow_step_id: (required) 13403 :param WorkflowStep workflow_step: 13404 :return: WorkflowStep 13405 If the method is called asynchronously, 13406 returns the request thread. 13407 """ 13408 13409 all_params = ['account_id', 'envelope_id', 'workflow_step_id', 'workflow_step'] 13410 all_params.append('callback') 13411 all_params.append('_return_http_data_only') 13412 all_params.append('_preload_content') 13413 all_params.append('_request_timeout') 13414 13415 params = locals() 13416 for key, val in iteritems(params['kwargs']): 13417 if key not in all_params: 13418 raise TypeError( 13419 "Got an unexpected keyword argument '%s'" 13420 " to method update_envelope_workflow_step_definition" % key 13421 ) 13422 params[key] = val 13423 del params['kwargs'] 13424 # verify the required parameter 'account_id' is set 13425 if ('account_id' not in params) or (params['account_id'] is None): 13426 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_workflow_step_definition`") 13427 # verify the required parameter 'envelope_id' is set 13428 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13429 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_workflow_step_definition`") 13430 # verify the required parameter 'workflow_step_id' is set 13431 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 13432 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_envelope_workflow_step_definition`") 13433 13434 13435 collection_formats = {} 13436 13437 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 13438 path_params = {} 13439 if 'account_id' in params: 13440 path_params['accountId'] = params['account_id'] 13441 if 'envelope_id' in params: 13442 path_params['envelopeId'] = params['envelope_id'] 13443 if 'workflow_step_id' in params: 13444 path_params['workflowStepId'] = params['workflow_step_id'] 13445 13446 query_params = {} 13447 13448 header_params = {} 13449 13450 form_params = [] 13451 local_var_files = {} 13452 13453 body_params = None 13454 if 'workflow_step' in params: 13455 body_params = params['workflow_step'] 13456 # HTTP header `Accept` 13457 header_params['Accept'] = self.api_client.\ 13458 select_header_accept(['application/json']) 13459 13460 # Authentication setting 13461 auth_settings = [] 13462 13463 return self.api_client.call_api(resource_path, 'PUT', 13464 path_params, 13465 query_params, 13466 header_params, 13467 body=body_params, 13468 post_params=form_params, 13469 files=local_var_files, 13470 response_type='WorkflowStep', 13471 auth_settings=auth_settings, 13472 callback=params.get('callback'), 13473 _return_http_data_only=params.get('_return_http_data_only'), 13474 _preload_content=params.get('_preload_content', True), 13475 _request_timeout=params.get('_request_timeout'), 13476 collection_formats=collection_formats) 13477 13478 def update_lock(self, account_id, envelope_id, **kwargs): 13479 """ 13480 Updates an envelope lock. 13481 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. 13482 This method makes a synchronous HTTP request by default. To make an 13483 asynchronous HTTP request, please define a `callback` function 13484 to be invoked when receiving the response. 13485 >>> def callback_function(response): 13486 >>> pprint(response) 13487 >>> 13488 >>> thread = api.update_lock(account_id, envelope_id, callback=callback_function) 13489 13490 :param callback function: The callback function 13491 for asynchronous request. (optional) 13492 :param str account_id: The external account number (int) or account ID Guid. (required) 13493 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13494 :param LockRequest lock_request: 13495 :return: LockInformation 13496 If the method is called asynchronously, 13497 returns the request thread. 13498 """ 13499 kwargs['_return_http_data_only'] = True 13500 if kwargs.get('callback'): 13501 return self.update_lock_with_http_info(account_id, envelope_id, **kwargs) 13502 else: 13503 (data) = self.update_lock_with_http_info(account_id, envelope_id, **kwargs) 13504 return data 13505 13506 def update_lock_with_http_info(self, account_id, envelope_id, **kwargs): 13507 """ 13508 Updates an envelope lock. 13509 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. 13510 This method makes a synchronous HTTP request by default. To make an 13511 asynchronous HTTP request, please define a `callback` function 13512 to be invoked when receiving the response. 13513 >>> def callback_function(response): 13514 >>> pprint(response) 13515 >>> 13516 >>> thread = api.update_lock_with_http_info(account_id, envelope_id, callback=callback_function) 13517 13518 :param callback function: The callback function 13519 for asynchronous request. (optional) 13520 :param str account_id: The external account number (int) or account ID Guid. (required) 13521 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13522 :param LockRequest lock_request: 13523 :return: LockInformation 13524 If the method is called asynchronously, 13525 returns the request thread. 13526 """ 13527 13528 all_params = ['account_id', 'envelope_id', 'lock_request'] 13529 all_params.append('callback') 13530 all_params.append('_return_http_data_only') 13531 all_params.append('_preload_content') 13532 all_params.append('_request_timeout') 13533 13534 params = locals() 13535 for key, val in iteritems(params['kwargs']): 13536 if key not in all_params: 13537 raise TypeError( 13538 "Got an unexpected keyword argument '%s'" 13539 " to method update_lock" % key 13540 ) 13541 params[key] = val 13542 del params['kwargs'] 13543 # verify the required parameter 'account_id' is set 13544 if ('account_id' not in params) or (params['account_id'] is None): 13545 raise ValueError("Missing the required parameter `account_id` when calling `update_lock`") 13546 # verify the required parameter 'envelope_id' is set 13547 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13548 raise ValueError("Missing the required parameter `envelope_id` when calling `update_lock`") 13549 13550 13551 collection_formats = {} 13552 13553 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/lock'.replace('{format}', 'json') 13554 path_params = {} 13555 if 'account_id' in params: 13556 path_params['accountId'] = params['account_id'] 13557 if 'envelope_id' in params: 13558 path_params['envelopeId'] = params['envelope_id'] 13559 13560 query_params = {} 13561 13562 header_params = {} 13563 13564 form_params = [] 13565 local_var_files = {} 13566 13567 body_params = None 13568 if 'lock_request' in params: 13569 body_params = params['lock_request'] 13570 # HTTP header `Accept` 13571 header_params['Accept'] = self.api_client.\ 13572 select_header_accept(['application/json']) 13573 13574 # Authentication setting 13575 auth_settings = [] 13576 13577 return self.api_client.call_api(resource_path, 'PUT', 13578 path_params, 13579 query_params, 13580 header_params, 13581 body=body_params, 13582 post_params=form_params, 13583 files=local_var_files, 13584 response_type='LockInformation', 13585 auth_settings=auth_settings, 13586 callback=params.get('callback'), 13587 _return_http_data_only=params.get('_return_http_data_only'), 13588 _preload_content=params.get('_preload_content', True), 13589 _request_timeout=params.get('_request_timeout'), 13590 collection_formats=collection_formats) 13591 13592 def update_notification_settings(self, account_id, envelope_id, **kwargs): 13593 """ 13594 Sets envelope notification (Reminders/Expirations) structure for an existing envelope. 13595 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. 13596 This method makes a synchronous HTTP request by default. To make an 13597 asynchronous HTTP request, please define a `callback` function 13598 to be invoked when receiving the response. 13599 >>> def callback_function(response): 13600 >>> pprint(response) 13601 >>> 13602 >>> thread = api.update_notification_settings(account_id, envelope_id, callback=callback_function) 13603 13604 :param callback function: The callback function 13605 for asynchronous request. (optional) 13606 :param str account_id: The external account number (int) or account ID Guid. (required) 13607 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13608 :param EnvelopeNotificationRequest envelope_notification_request: 13609 :return: Notification 13610 If the method is called asynchronously, 13611 returns the request thread. 13612 """ 13613 kwargs['_return_http_data_only'] = True 13614 if kwargs.get('callback'): 13615 return self.update_notification_settings_with_http_info(account_id, envelope_id, **kwargs) 13616 else: 13617 (data) = self.update_notification_settings_with_http_info(account_id, envelope_id, **kwargs) 13618 return data 13619 13620 def update_notification_settings_with_http_info(self, account_id, envelope_id, **kwargs): 13621 """ 13622 Sets envelope notification (Reminders/Expirations) structure for an existing envelope. 13623 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. 13624 This method makes a synchronous HTTP request by default. To make an 13625 asynchronous HTTP request, please define a `callback` function 13626 to be invoked when receiving the response. 13627 >>> def callback_function(response): 13628 >>> pprint(response) 13629 >>> 13630 >>> thread = api.update_notification_settings_with_http_info(account_id, envelope_id, callback=callback_function) 13631 13632 :param callback function: The callback function 13633 for asynchronous request. (optional) 13634 :param str account_id: The external account number (int) or account ID Guid. (required) 13635 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13636 :param EnvelopeNotificationRequest envelope_notification_request: 13637 :return: Notification 13638 If the method is called asynchronously, 13639 returns the request thread. 13640 """ 13641 13642 all_params = ['account_id', 'envelope_id', 'envelope_notification_request'] 13643 all_params.append('callback') 13644 all_params.append('_return_http_data_only') 13645 all_params.append('_preload_content') 13646 all_params.append('_request_timeout') 13647 13648 params = locals() 13649 for key, val in iteritems(params['kwargs']): 13650 if key not in all_params: 13651 raise TypeError( 13652 "Got an unexpected keyword argument '%s'" 13653 " to method update_notification_settings" % key 13654 ) 13655 params[key] = val 13656 del params['kwargs'] 13657 # verify the required parameter 'account_id' is set 13658 if ('account_id' not in params) or (params['account_id'] is None): 13659 raise ValueError("Missing the required parameter `account_id` when calling `update_notification_settings`") 13660 # verify the required parameter 'envelope_id' is set 13661 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13662 raise ValueError("Missing the required parameter `envelope_id` when calling `update_notification_settings`") 13663 13664 13665 collection_formats = {} 13666 13667 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/notification'.replace('{format}', 'json') 13668 path_params = {} 13669 if 'account_id' in params: 13670 path_params['accountId'] = params['account_id'] 13671 if 'envelope_id' in params: 13672 path_params['envelopeId'] = params['envelope_id'] 13673 13674 query_params = {} 13675 13676 header_params = {} 13677 13678 form_params = [] 13679 local_var_files = {} 13680 13681 body_params = None 13682 if 'envelope_notification_request' in params: 13683 body_params = params['envelope_notification_request'] 13684 # HTTP header `Accept` 13685 header_params['Accept'] = self.api_client.\ 13686 select_header_accept(['application/json']) 13687 13688 # Authentication setting 13689 auth_settings = [] 13690 13691 return self.api_client.call_api(resource_path, 'PUT', 13692 path_params, 13693 query_params, 13694 header_params, 13695 body=body_params, 13696 post_params=form_params, 13697 files=local_var_files, 13698 response_type='Notification', 13699 auth_settings=auth_settings, 13700 callback=params.get('callback'), 13701 _return_http_data_only=params.get('_return_http_data_only'), 13702 _preload_content=params.get('_preload_content', True), 13703 _request_timeout=params.get('_request_timeout'), 13704 collection_formats=collection_formats) 13705 13706 def update_recipient_document_visibility(self, account_id, envelope_id, recipient_id, **kwargs): 13707 """ 13708 Updates document visibility for the recipients 13709 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. 13710 This method makes a synchronous HTTP request by default. To make an 13711 asynchronous HTTP request, please define a `callback` function 13712 to be invoked when receiving the response. 13713 >>> def callback_function(response): 13714 >>> pprint(response) 13715 >>> 13716 >>> thread = api.update_recipient_document_visibility(account_id, envelope_id, recipient_id, callback=callback_function) 13717 13718 :param callback function: The callback function 13719 for asynchronous request. (optional) 13720 :param str account_id: The external account number (int) or account ID Guid. (required) 13721 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13722 :param str recipient_id: The ID of the recipient being accessed. (required) 13723 :param DocumentVisibilityList document_visibility_list: 13724 :return: DocumentVisibilityList 13725 If the method is called asynchronously, 13726 returns the request thread. 13727 """ 13728 kwargs['_return_http_data_only'] = True 13729 if kwargs.get('callback'): 13730 return self.update_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13731 else: 13732 (data) = self.update_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13733 return data 13734 13735 def update_recipient_document_visibility_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 13736 """ 13737 Updates document visibility for the recipients 13738 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. 13739 This method makes a synchronous HTTP request by default. To make an 13740 asynchronous HTTP request, please define a `callback` function 13741 to be invoked when receiving the response. 13742 >>> def callback_function(response): 13743 >>> pprint(response) 13744 >>> 13745 >>> thread = api.update_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 13746 13747 :param callback function: The callback function 13748 for asynchronous request. (optional) 13749 :param str account_id: The external account number (int) or account ID Guid. (required) 13750 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13751 :param str recipient_id: The ID of the recipient being accessed. (required) 13752 :param DocumentVisibilityList document_visibility_list: 13753 :return: DocumentVisibilityList 13754 If the method is called asynchronously, 13755 returns the request thread. 13756 """ 13757 13758 all_params = ['account_id', 'envelope_id', 'recipient_id', 'document_visibility_list'] 13759 all_params.append('callback') 13760 all_params.append('_return_http_data_only') 13761 all_params.append('_preload_content') 13762 all_params.append('_request_timeout') 13763 13764 params = locals() 13765 for key, val in iteritems(params['kwargs']): 13766 if key not in all_params: 13767 raise TypeError( 13768 "Got an unexpected keyword argument '%s'" 13769 " to method update_recipient_document_visibility" % key 13770 ) 13771 params[key] = val 13772 del params['kwargs'] 13773 # verify the required parameter 'account_id' is set 13774 if ('account_id' not in params) or (params['account_id'] is None): 13775 raise ValueError("Missing the required parameter `account_id` when calling `update_recipient_document_visibility`") 13776 # verify the required parameter 'envelope_id' is set 13777 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13778 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipient_document_visibility`") 13779 # verify the required parameter 'recipient_id' is set 13780 if ('recipient_id' not in params) or (params['recipient_id'] is None): 13781 raise ValueError("Missing the required parameter `recipient_id` when calling `update_recipient_document_visibility`") 13782 13783 13784 collection_formats = {} 13785 13786 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/document_visibility'.replace('{format}', 'json') 13787 path_params = {} 13788 if 'account_id' in params: 13789 path_params['accountId'] = params['account_id'] 13790 if 'envelope_id' in params: 13791 path_params['envelopeId'] = params['envelope_id'] 13792 if 'recipient_id' in params: 13793 path_params['recipientId'] = params['recipient_id'] 13794 13795 query_params = {} 13796 13797 header_params = {} 13798 13799 form_params = [] 13800 local_var_files = {} 13801 13802 body_params = None 13803 if 'document_visibility_list' in params: 13804 body_params = params['document_visibility_list'] 13805 # HTTP header `Accept` 13806 header_params['Accept'] = self.api_client.\ 13807 select_header_accept(['application/json']) 13808 13809 # Authentication setting 13810 auth_settings = [] 13811 13812 return self.api_client.call_api(resource_path, 'PUT', 13813 path_params, 13814 query_params, 13815 header_params, 13816 body=body_params, 13817 post_params=form_params, 13818 files=local_var_files, 13819 response_type='DocumentVisibilityList', 13820 auth_settings=auth_settings, 13821 callback=params.get('callback'), 13822 _return_http_data_only=params.get('_return_http_data_only'), 13823 _preload_content=params.get('_preload_content', True), 13824 _request_timeout=params.get('_request_timeout'), 13825 collection_formats=collection_formats) 13826 13827 def update_recipient_initials_image(self, account_id, envelope_id, recipient_id, **kwargs): 13828 """ 13829 Sets the initials image for an accountless signer. 13830 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**. 13831 This method makes a synchronous HTTP request by default. To make an 13832 asynchronous HTTP request, please define a `callback` function 13833 to be invoked when receiving the response. 13834 >>> def callback_function(response): 13835 >>> pprint(response) 13836 >>> 13837 >>> thread = api.update_recipient_initials_image(account_id, envelope_id, recipient_id, callback=callback_function) 13838 13839 :param callback function: The callback function 13840 for asynchronous request. (optional) 13841 :param str account_id: The external account number (int) or account ID Guid. (required) 13842 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13843 :param str recipient_id: The ID of the recipient being accessed. (required) 13844 :return: None 13845 If the method is called asynchronously, 13846 returns the request thread. 13847 """ 13848 kwargs['_return_http_data_only'] = True 13849 if kwargs.get('callback'): 13850 return self.update_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13851 else: 13852 (data) = self.update_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13853 return data 13854 13855 def update_recipient_initials_image_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 13856 """ 13857 Sets the initials image for an accountless signer. 13858 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**. 13859 This method makes a synchronous HTTP request by default. To make an 13860 asynchronous HTTP request, please define a `callback` function 13861 to be invoked when receiving the response. 13862 >>> def callback_function(response): 13863 >>> pprint(response) 13864 >>> 13865 >>> thread = api.update_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 13866 13867 :param callback function: The callback function 13868 for asynchronous request. (optional) 13869 :param str account_id: The external account number (int) or account ID Guid. (required) 13870 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13871 :param str recipient_id: The ID of the recipient being accessed. (required) 13872 :return: None 13873 If the method is called asynchronously, 13874 returns the request thread. 13875 """ 13876 13877 all_params = ['account_id', 'envelope_id', 'recipient_id'] 13878 all_params.append('callback') 13879 all_params.append('_return_http_data_only') 13880 all_params.append('_preload_content') 13881 all_params.append('_request_timeout') 13882 13883 params = locals() 13884 for key, val in iteritems(params['kwargs']): 13885 if key not in all_params: 13886 raise TypeError( 13887 "Got an unexpected keyword argument '%s'" 13888 " to method update_recipient_initials_image" % key 13889 ) 13890 params[key] = val 13891 del params['kwargs'] 13892 # verify the required parameter 'account_id' is set 13893 if ('account_id' not in params) or (params['account_id'] is None): 13894 raise ValueError("Missing the required parameter `account_id` when calling `update_recipient_initials_image`") 13895 # verify the required parameter 'envelope_id' is set 13896 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13897 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipient_initials_image`") 13898 # verify the required parameter 'recipient_id' is set 13899 if ('recipient_id' not in params) or (params['recipient_id'] is None): 13900 raise ValueError("Missing the required parameter `recipient_id` when calling `update_recipient_initials_image`") 13901 13902 13903 collection_formats = {} 13904 13905 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/initials_image'.replace('{format}', 'json') 13906 path_params = {} 13907 if 'account_id' in params: 13908 path_params['accountId'] = params['account_id'] 13909 if 'envelope_id' in params: 13910 path_params['envelopeId'] = params['envelope_id'] 13911 if 'recipient_id' in params: 13912 path_params['recipientId'] = params['recipient_id'] 13913 13914 query_params = {} 13915 13916 header_params = {} 13917 13918 form_params = [] 13919 local_var_files = {} 13920 13921 body_params = None 13922 # HTTP header `Accept` 13923 header_params['Accept'] = self.api_client.\ 13924 select_header_accept(['application/json']) 13925 13926 # HTTP header `Content-Type` 13927 header_params['Content-Type'] = self.api_client.\ 13928 select_header_content_type(['image/gif']) 13929 13930 # Authentication setting 13931 auth_settings = [] 13932 13933 return self.api_client.call_api(resource_path, 'PUT', 13934 path_params, 13935 query_params, 13936 header_params, 13937 body=body_params, 13938 post_params=form_params, 13939 files=local_var_files, 13940 response_type=None, 13941 auth_settings=auth_settings, 13942 callback=params.get('callback'), 13943 _return_http_data_only=params.get('_return_http_data_only'), 13944 _preload_content=params.get('_preload_content', True), 13945 _request_timeout=params.get('_request_timeout'), 13946 collection_formats=collection_formats) 13947 13948 def update_recipient_signature_image(self, account_id, envelope_id, recipient_id, **kwargs): 13949 """ 13950 Sets the signature image for an accountless signer. 13951 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**. 13952 This method makes a synchronous HTTP request by default. To make an 13953 asynchronous HTTP request, please define a `callback` function 13954 to be invoked when receiving the response. 13955 >>> def callback_function(response): 13956 >>> pprint(response) 13957 >>> 13958 >>> thread = api.update_recipient_signature_image(account_id, envelope_id, recipient_id, callback=callback_function) 13959 13960 :param callback function: The callback function 13961 for asynchronous request. (optional) 13962 :param str account_id: The external account number (int) or account ID Guid. (required) 13963 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13964 :param str recipient_id: The ID of the recipient being accessed. (required) 13965 :return: None 13966 If the method is called asynchronously, 13967 returns the request thread. 13968 """ 13969 kwargs['_return_http_data_only'] = True 13970 if kwargs.get('callback'): 13971 return self.update_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13972 else: 13973 (data) = self.update_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13974 return data 13975 13976 def update_recipient_signature_image_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 13977 """ 13978 Sets the signature image for an accountless signer. 13979 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**. 13980 This method makes a synchronous HTTP request by default. To make an 13981 asynchronous HTTP request, please define a `callback` function 13982 to be invoked when receiving the response. 13983 >>> def callback_function(response): 13984 >>> pprint(response) 13985 >>> 13986 >>> thread = api.update_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 13987 13988 :param callback function: The callback function 13989 for asynchronous request. (optional) 13990 :param str account_id: The external account number (int) or account ID Guid. (required) 13991 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13992 :param str recipient_id: The ID of the recipient being accessed. (required) 13993 :return: None 13994 If the method is called asynchronously, 13995 returns the request thread. 13996 """ 13997 13998 all_params = ['account_id', 'envelope_id', 'recipient_id'] 13999 all_params.append('callback') 14000 all_params.append('_return_http_data_only') 14001 all_params.append('_preload_content') 14002 all_params.append('_request_timeout') 14003 14004 params = locals() 14005 for key, val in iteritems(params['kwargs']): 14006 if key not in all_params: 14007 raise TypeError( 14008 "Got an unexpected keyword argument '%s'" 14009 " to method update_recipient_signature_image" % key 14010 ) 14011 params[key] = val 14012 del params['kwargs'] 14013 # verify the required parameter 'account_id' is set 14014 if ('account_id' not in params) or (params['account_id'] is None): 14015 raise ValueError("Missing the required parameter `account_id` when calling `update_recipient_signature_image`") 14016 # verify the required parameter 'envelope_id' is set 14017 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14018 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipient_signature_image`") 14019 # verify the required parameter 'recipient_id' is set 14020 if ('recipient_id' not in params) or (params['recipient_id'] is None): 14021 raise ValueError("Missing the required parameter `recipient_id` when calling `update_recipient_signature_image`") 14022 14023 14024 collection_formats = {} 14025 14026 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/signature_image'.replace('{format}', 'json') 14027 path_params = {} 14028 if 'account_id' in params: 14029 path_params['accountId'] = params['account_id'] 14030 if 'envelope_id' in params: 14031 path_params['envelopeId'] = params['envelope_id'] 14032 if 'recipient_id' in params: 14033 path_params['recipientId'] = params['recipient_id'] 14034 14035 query_params = {} 14036 14037 header_params = {} 14038 14039 form_params = [] 14040 local_var_files = {} 14041 14042 body_params = None 14043 # HTTP header `Accept` 14044 header_params['Accept'] = self.api_client.\ 14045 select_header_accept(['application/json']) 14046 14047 # HTTP header `Content-Type` 14048 header_params['Content-Type'] = self.api_client.\ 14049 select_header_content_type(['image/gif']) 14050 14051 # Authentication setting 14052 auth_settings = [] 14053 14054 return self.api_client.call_api(resource_path, 'PUT', 14055 path_params, 14056 query_params, 14057 header_params, 14058 body=body_params, 14059 post_params=form_params, 14060 files=local_var_files, 14061 response_type=None, 14062 auth_settings=auth_settings, 14063 callback=params.get('callback'), 14064 _return_http_data_only=params.get('_return_http_data_only'), 14065 _preload_content=params.get('_preload_content', True), 14066 _request_timeout=params.get('_request_timeout'), 14067 collection_formats=collection_formats) 14068 14069 def update_recipients(self, account_id, envelope_id, **kwargs): 14070 """ 14071 Updates recipients in a draft envelope or corrects recipient information for an in process envelope. 14072 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). 14073 This method makes a synchronous HTTP request by default. To make an 14074 asynchronous HTTP request, please define a `callback` function 14075 to be invoked when receiving the response. 14076 >>> def callback_function(response): 14077 >>> pprint(response) 14078 >>> 14079 >>> thread = api.update_recipients(account_id, envelope_id, callback=callback_function) 14080 14081 :param callback function: The callback function 14082 for asynchronous request. (optional) 14083 :param str account_id: The external account number (int) or account ID Guid. (required) 14084 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14085 :param str combine_same_order_recipients: 14086 :param str offline_signing: 14087 :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. 14088 :param Recipients recipients: 14089 :return: RecipientsUpdateSummary 14090 If the method is called asynchronously, 14091 returns the request thread. 14092 """ 14093 kwargs['_return_http_data_only'] = True 14094 if kwargs.get('callback'): 14095 return self.update_recipients_with_http_info(account_id, envelope_id, **kwargs) 14096 else: 14097 (data) = self.update_recipients_with_http_info(account_id, envelope_id, **kwargs) 14098 return data 14099 14100 def update_recipients_with_http_info(self, account_id, envelope_id, **kwargs): 14101 """ 14102 Updates recipients in a draft envelope or corrects recipient information for an in process envelope. 14103 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). 14104 This method makes a synchronous HTTP request by default. To make an 14105 asynchronous HTTP request, please define a `callback` function 14106 to be invoked when receiving the response. 14107 >>> def callback_function(response): 14108 >>> pprint(response) 14109 >>> 14110 >>> thread = api.update_recipients_with_http_info(account_id, envelope_id, callback=callback_function) 14111 14112 :param callback function: The callback function 14113 for asynchronous request. (optional) 14114 :param str account_id: The external account number (int) or account ID Guid. (required) 14115 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14116 :param str combine_same_order_recipients: 14117 :param str offline_signing: 14118 :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. 14119 :param Recipients recipients: 14120 :return: RecipientsUpdateSummary 14121 If the method is called asynchronously, 14122 returns the request thread. 14123 """ 14124 14125 all_params = ['account_id', 'envelope_id', 'combine_same_order_recipients', 'offline_signing', 'resend_envelope', 'recipients'] 14126 all_params.append('callback') 14127 all_params.append('_return_http_data_only') 14128 all_params.append('_preload_content') 14129 all_params.append('_request_timeout') 14130 14131 params = locals() 14132 for key, val in iteritems(params['kwargs']): 14133 if key not in all_params: 14134 raise TypeError( 14135 "Got an unexpected keyword argument '%s'" 14136 " to method update_recipients" % key 14137 ) 14138 params[key] = val 14139 del params['kwargs'] 14140 # verify the required parameter 'account_id' is set 14141 if ('account_id' not in params) or (params['account_id'] is None): 14142 raise ValueError("Missing the required parameter `account_id` when calling `update_recipients`") 14143 # verify the required parameter 'envelope_id' is set 14144 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14145 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipients`") 14146 14147 14148 collection_formats = {} 14149 14150 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients'.replace('{format}', 'json') 14151 path_params = {} 14152 if 'account_id' in params: 14153 path_params['accountId'] = params['account_id'] 14154 if 'envelope_id' in params: 14155 path_params['envelopeId'] = params['envelope_id'] 14156 14157 query_params = {} 14158 if 'combine_same_order_recipients' in params: 14159 query_params['combine_same_order_recipients'] = params['combine_same_order_recipients'] 14160 if 'offline_signing' in params: 14161 query_params['offline_signing'] = params['offline_signing'] 14162 if 'resend_envelope' in params: 14163 query_params['resend_envelope'] = params['resend_envelope'] 14164 14165 header_params = {} 14166 14167 form_params = [] 14168 local_var_files = {} 14169 14170 body_params = None 14171 if 'recipients' in params: 14172 body_params = params['recipients'] 14173 # HTTP header `Accept` 14174 header_params['Accept'] = self.api_client.\ 14175 select_header_accept(['application/json']) 14176 14177 # Authentication setting 14178 auth_settings = [] 14179 14180 return self.api_client.call_api(resource_path, 'PUT', 14181 path_params, 14182 query_params, 14183 header_params, 14184 body=body_params, 14185 post_params=form_params, 14186 files=local_var_files, 14187 response_type='RecipientsUpdateSummary', 14188 auth_settings=auth_settings, 14189 callback=params.get('callback'), 14190 _return_http_data_only=params.get('_return_http_data_only'), 14191 _preload_content=params.get('_preload_content', True), 14192 _request_timeout=params.get('_request_timeout'), 14193 collection_formats=collection_formats) 14194 14195 def update_recipients_document_visibility(self, account_id, envelope_id, **kwargs): 14196 """ 14197 Updates document visibility for the recipients 14198 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. 14199 This method makes a synchronous HTTP request by default. To make an 14200 asynchronous HTTP request, please define a `callback` function 14201 to be invoked when receiving the response. 14202 >>> def callback_function(response): 14203 >>> pprint(response) 14204 >>> 14205 >>> thread = api.update_recipients_document_visibility(account_id, envelope_id, callback=callback_function) 14206 14207 :param callback function: The callback function 14208 for asynchronous request. (optional) 14209 :param str account_id: The external account number (int) or account ID Guid. (required) 14210 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14211 :param DocumentVisibilityList document_visibility_list: 14212 :return: DocumentVisibilityList 14213 If the method is called asynchronously, 14214 returns the request thread. 14215 """ 14216 kwargs['_return_http_data_only'] = True 14217 if kwargs.get('callback'): 14218 return self.update_recipients_document_visibility_with_http_info(account_id, envelope_id, **kwargs) 14219 else: 14220 (data) = self.update_recipients_document_visibility_with_http_info(account_id, envelope_id, **kwargs) 14221 return data 14222 14223 def update_recipients_document_visibility_with_http_info(self, account_id, envelope_id, **kwargs): 14224 """ 14225 Updates document visibility for the recipients 14226 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. 14227 This method makes a synchronous HTTP request by default. To make an 14228 asynchronous HTTP request, please define a `callback` function 14229 to be invoked when receiving the response. 14230 >>> def callback_function(response): 14231 >>> pprint(response) 14232 >>> 14233 >>> thread = api.update_recipients_document_visibility_with_http_info(account_id, envelope_id, callback=callback_function) 14234 14235 :param callback function: The callback function 14236 for asynchronous request. (optional) 14237 :param str account_id: The external account number (int) or account ID Guid. (required) 14238 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14239 :param DocumentVisibilityList document_visibility_list: 14240 :return: DocumentVisibilityList 14241 If the method is called asynchronously, 14242 returns the request thread. 14243 """ 14244 14245 all_params = ['account_id', 'envelope_id', 'document_visibility_list'] 14246 all_params.append('callback') 14247 all_params.append('_return_http_data_only') 14248 all_params.append('_preload_content') 14249 all_params.append('_request_timeout') 14250 14251 params = locals() 14252 for key, val in iteritems(params['kwargs']): 14253 if key not in all_params: 14254 raise TypeError( 14255 "Got an unexpected keyword argument '%s'" 14256 " to method update_recipients_document_visibility" % key 14257 ) 14258 params[key] = val 14259 del params['kwargs'] 14260 # verify the required parameter 'account_id' is set 14261 if ('account_id' not in params) or (params['account_id'] is None): 14262 raise ValueError("Missing the required parameter `account_id` when calling `update_recipients_document_visibility`") 14263 # verify the required parameter 'envelope_id' is set 14264 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14265 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipients_document_visibility`") 14266 14267 14268 collection_formats = {} 14269 14270 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/document_visibility'.replace('{format}', 'json') 14271 path_params = {} 14272 if 'account_id' in params: 14273 path_params['accountId'] = params['account_id'] 14274 if 'envelope_id' in params: 14275 path_params['envelopeId'] = params['envelope_id'] 14276 14277 query_params = {} 14278 14279 header_params = {} 14280 14281 form_params = [] 14282 local_var_files = {} 14283 14284 body_params = None 14285 if 'document_visibility_list' in params: 14286 body_params = params['document_visibility_list'] 14287 # HTTP header `Accept` 14288 header_params['Accept'] = self.api_client.\ 14289 select_header_accept(['application/json']) 14290 14291 # Authentication setting 14292 auth_settings = [] 14293 14294 return self.api_client.call_api(resource_path, 'PUT', 14295 path_params, 14296 query_params, 14297 header_params, 14298 body=body_params, 14299 post_params=form_params, 14300 files=local_var_files, 14301 response_type='DocumentVisibilityList', 14302 auth_settings=auth_settings, 14303 callback=params.get('callback'), 14304 _return_http_data_only=params.get('_return_http_data_only'), 14305 _preload_content=params.get('_preload_content', True), 14306 _request_timeout=params.get('_request_timeout'), 14307 collection_formats=collection_formats) 14308 14309 def update_tabs(self, account_id, envelope_id, recipient_id, **kwargs): 14310 """ 14311 Updates the tabs for a recipient. 14312 Updates one or more tabs for a recipient in a draft envelope. 14313 This method makes a synchronous HTTP request by default. To make an 14314 asynchronous HTTP request, please define a `callback` function 14315 to be invoked when receiving the response. 14316 >>> def callback_function(response): 14317 >>> pprint(response) 14318 >>> 14319 >>> thread = api.update_tabs(account_id, envelope_id, recipient_id, callback=callback_function) 14320 14321 :param callback function: The callback function 14322 for asynchronous request. (optional) 14323 :param str account_id: The external account number (int) or account ID Guid. (required) 14324 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14325 :param str recipient_id: The ID of the recipient being accessed. (required) 14326 :param Tabs tabs: 14327 :return: Tabs 14328 If the method is called asynchronously, 14329 returns the request thread. 14330 """ 14331 kwargs['_return_http_data_only'] = True 14332 if kwargs.get('callback'): 14333 return self.update_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 14334 else: 14335 (data) = self.update_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 14336 return data 14337 14338 def update_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 14339 """ 14340 Updates the tabs for a recipient. 14341 Updates one or more tabs for a recipient in a draft envelope. 14342 This method makes a synchronous HTTP request by default. To make an 14343 asynchronous HTTP request, please define a `callback` function 14344 to be invoked when receiving the response. 14345 >>> def callback_function(response): 14346 >>> pprint(response) 14347 >>> 14348 >>> thread = api.update_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 14349 14350 :param callback function: The callback function 14351 for asynchronous request. (optional) 14352 :param str account_id: The external account number (int) or account ID Guid. (required) 14353 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14354 :param str recipient_id: The ID of the recipient being accessed. (required) 14355 :param Tabs tabs: 14356 :return: Tabs 14357 If the method is called asynchronously, 14358 returns the request thread. 14359 """ 14360 14361 all_params = ['account_id', 'envelope_id', 'recipient_id', 'tabs'] 14362 all_params.append('callback') 14363 all_params.append('_return_http_data_only') 14364 all_params.append('_preload_content') 14365 all_params.append('_request_timeout') 14366 14367 params = locals() 14368 for key, val in iteritems(params['kwargs']): 14369 if key not in all_params: 14370 raise TypeError( 14371 "Got an unexpected keyword argument '%s'" 14372 " to method update_tabs" % key 14373 ) 14374 params[key] = val 14375 del params['kwargs'] 14376 # verify the required parameter 'account_id' is set 14377 if ('account_id' not in params) or (params['account_id'] is None): 14378 raise ValueError("Missing the required parameter `account_id` when calling `update_tabs`") 14379 # verify the required parameter 'envelope_id' is set 14380 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14381 raise ValueError("Missing the required parameter `envelope_id` when calling `update_tabs`") 14382 # verify the required parameter 'recipient_id' is set 14383 if ('recipient_id' not in params) or (params['recipient_id'] is None): 14384 raise ValueError("Missing the required parameter `recipient_id` when calling `update_tabs`") 14385 14386 14387 collection_formats = {} 14388 14389 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/tabs'.replace('{format}', 'json') 14390 path_params = {} 14391 if 'account_id' in params: 14392 path_params['accountId'] = params['account_id'] 14393 if 'envelope_id' in params: 14394 path_params['envelopeId'] = params['envelope_id'] 14395 if 'recipient_id' in params: 14396 path_params['recipientId'] = params['recipient_id'] 14397 14398 query_params = {} 14399 14400 header_params = {} 14401 14402 form_params = [] 14403 local_var_files = {} 14404 14405 body_params = None 14406 if 'tabs' in params: 14407 body_params = params['tabs'] 14408 # HTTP header `Accept` 14409 header_params['Accept'] = self.api_client.\ 14410 select_header_accept(['application/json']) 14411 14412 # Authentication setting 14413 auth_settings = [] 14414 14415 return self.api_client.call_api(resource_path, 'PUT', 14416 path_params, 14417 query_params, 14418 header_params, 14419 body=body_params, 14420 post_params=form_params, 14421 files=local_var_files, 14422 response_type='Tabs', 14423 auth_settings=auth_settings, 14424 callback=params.get('callback'), 14425 _return_http_data_only=params.get('_return_http_data_only'), 14426 _preload_content=params.get('_preload_content', True), 14427 _request_timeout=params.get('_request_timeout'), 14428 collection_formats=collection_formats) 14429 14430 def update_tabs_blob(self, account_id, envelope_id, **kwargs): 14431 """ 14432 Update encrypted tabs for envelope. 14433 14434 This method makes a synchronous HTTP request by default. To make an 14435 asynchronous HTTP request, please define a `callback` function 14436 to be invoked when receiving the response. 14437 >>> def callback_function(response): 14438 >>> pprint(response) 14439 >>> 14440 >>> thread = api.update_tabs_blob(account_id, envelope_id, callback=callback_function) 14441 14442 :param callback function: The callback function 14443 for asynchronous request. (optional) 14444 :param str account_id: The external account number (int) or account ID Guid. (required) 14445 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14446 :return: None 14447 If the method is called asynchronously, 14448 returns the request thread. 14449 """ 14450 kwargs['_return_http_data_only'] = True 14451 if kwargs.get('callback'): 14452 return self.update_tabs_blob_with_http_info(account_id, envelope_id, **kwargs) 14453 else: 14454 (data) = self.update_tabs_blob_with_http_info(account_id, envelope_id, **kwargs) 14455 return data 14456 14457 def update_tabs_blob_with_http_info(self, account_id, envelope_id, **kwargs): 14458 """ 14459 Update encrypted tabs for envelope. 14460 14461 This method makes a synchronous HTTP request by default. To make an 14462 asynchronous HTTP request, please define a `callback` function 14463 to be invoked when receiving the response. 14464 >>> def callback_function(response): 14465 >>> pprint(response) 14466 >>> 14467 >>> thread = api.update_tabs_blob_with_http_info(account_id, envelope_id, callback=callback_function) 14468 14469 :param callback function: The callback function 14470 for asynchronous request. (optional) 14471 :param str account_id: The external account number (int) or account ID Guid. (required) 14472 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14473 :return: None 14474 If the method is called asynchronously, 14475 returns the request thread. 14476 """ 14477 14478 all_params = ['account_id', 'envelope_id'] 14479 all_params.append('callback') 14480 all_params.append('_return_http_data_only') 14481 all_params.append('_preload_content') 14482 all_params.append('_request_timeout') 14483 14484 params = locals() 14485 for key, val in iteritems(params['kwargs']): 14486 if key not in all_params: 14487 raise TypeError( 14488 "Got an unexpected keyword argument '%s'" 14489 " to method update_tabs_blob" % key 14490 ) 14491 params[key] = val 14492 del params['kwargs'] 14493 # verify the required parameter 'account_id' is set 14494 if ('account_id' not in params) or (params['account_id'] is None): 14495 raise ValueError("Missing the required parameter `account_id` when calling `update_tabs_blob`") 14496 # verify the required parameter 'envelope_id' is set 14497 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14498 raise ValueError("Missing the required parameter `envelope_id` when calling `update_tabs_blob`") 14499 14500 14501 collection_formats = {} 14502 14503 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/tabs_blob'.replace('{format}', 'json') 14504 path_params = {} 14505 if 'account_id' in params: 14506 path_params['accountId'] = params['account_id'] 14507 if 'envelope_id' in params: 14508 path_params['envelopeId'] = params['envelope_id'] 14509 14510 query_params = {} 14511 14512 header_params = {} 14513 14514 form_params = [] 14515 local_var_files = {} 14516 14517 body_params = None 14518 # HTTP header `Accept` 14519 header_params['Accept'] = self.api_client.\ 14520 select_header_accept(['application/json']) 14521 14522 # Authentication setting 14523 auth_settings = [] 14524 14525 return self.api_client.call_api(resource_path, 'PUT', 14526 path_params, 14527 query_params, 14528 header_params, 14529 body=body_params, 14530 post_params=form_params, 14531 files=local_var_files, 14532 response_type=None, 14533 auth_settings=auth_settings, 14534 callback=params.get('callback'), 14535 _return_http_data_only=params.get('_return_http_data_only'), 14536 _preload_content=params.get('_preload_content', True), 14537 _request_timeout=params.get('_request_timeout'), 14538 collection_formats=collection_formats) 14539 14540 def update_template_delayed_routing_definition(self, account_id, template_id, workflow_step_id, **kwargs): 14541 """ 14542 Updates the delayed routing rules for a template's workflow step definition. 14543 This method makes a synchronous HTTP request by default. To make an 14544 asynchronous HTTP request, please define a `callback` function 14545 to be invoked when receiving the response. 14546 >>> def callback_function(response): 14547 >>> pprint(response) 14548 >>> 14549 >>> thread = api.update_template_delayed_routing_definition(account_id, template_id, workflow_step_id, callback=callback_function) 14550 14551 :param callback function: The callback function 14552 for asynchronous request. (optional) 14553 :param str account_id: The external account number (int) or account ID Guid. (required) 14554 :param str template_id: The ID of the template being accessed. (required) 14555 :param str workflow_step_id: (required) 14556 :param DelayedRouting delayed_routing: 14557 :return: DelayedRouting 14558 If the method is called asynchronously, 14559 returns the request thread. 14560 """ 14561 kwargs['_return_http_data_only'] = True 14562 if kwargs.get('callback'): 14563 return self.update_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 14564 else: 14565 (data) = self.update_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 14566 return data 14567 14568 def update_template_delayed_routing_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 14569 """ 14570 Updates the delayed routing rules for a template's workflow step definition. 14571 This method makes a synchronous HTTP request by default. To make an 14572 asynchronous HTTP request, please define a `callback` function 14573 to be invoked when receiving the response. 14574 >>> def callback_function(response): 14575 >>> pprint(response) 14576 >>> 14577 >>> thread = api.update_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 14578 14579 :param callback function: The callback function 14580 for asynchronous request. (optional) 14581 :param str account_id: The external account number (int) or account ID Guid. (required) 14582 :param str template_id: The ID of the template being accessed. (required) 14583 :param str workflow_step_id: (required) 14584 :param DelayedRouting delayed_routing: 14585 :return: DelayedRouting 14586 If the method is called asynchronously, 14587 returns the request thread. 14588 """ 14589 14590 all_params = ['account_id', 'template_id', 'workflow_step_id', 'delayed_routing'] 14591 all_params.append('callback') 14592 all_params.append('_return_http_data_only') 14593 all_params.append('_preload_content') 14594 all_params.append('_request_timeout') 14595 14596 params = locals() 14597 for key, val in iteritems(params['kwargs']): 14598 if key not in all_params: 14599 raise TypeError( 14600 "Got an unexpected keyword argument '%s'" 14601 " to method update_template_delayed_routing_definition" % key 14602 ) 14603 params[key] = val 14604 del params['kwargs'] 14605 # verify the required parameter 'account_id' is set 14606 if ('account_id' not in params) or (params['account_id'] is None): 14607 raise ValueError("Missing the required parameter `account_id` when calling `update_template_delayed_routing_definition`") 14608 # verify the required parameter 'template_id' is set 14609 if ('template_id' not in params) or (params['template_id'] is None): 14610 raise ValueError("Missing the required parameter `template_id` when calling `update_template_delayed_routing_definition`") 14611 # verify the required parameter 'workflow_step_id' is set 14612 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 14613 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_template_delayed_routing_definition`") 14614 14615 14616 collection_formats = {} 14617 14618 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 14619 path_params = {} 14620 if 'account_id' in params: 14621 path_params['accountId'] = params['account_id'] 14622 if 'template_id' in params: 14623 path_params['templateId'] = params['template_id'] 14624 if 'workflow_step_id' in params: 14625 path_params['workflowStepId'] = params['workflow_step_id'] 14626 14627 query_params = {} 14628 14629 header_params = {} 14630 14631 form_params = [] 14632 local_var_files = {} 14633 14634 body_params = None 14635 if 'delayed_routing' in params: 14636 body_params = params['delayed_routing'] 14637 # HTTP header `Accept` 14638 header_params['Accept'] = self.api_client.\ 14639 select_header_accept(['application/json']) 14640 14641 # Authentication setting 14642 auth_settings = [] 14643 14644 return self.api_client.call_api(resource_path, 'PUT', 14645 path_params, 14646 query_params, 14647 header_params, 14648 body=body_params, 14649 post_params=form_params, 14650 files=local_var_files, 14651 response_type='DelayedRouting', 14652 auth_settings=auth_settings, 14653 callback=params.get('callback'), 14654 _return_http_data_only=params.get('_return_http_data_only'), 14655 _preload_content=params.get('_preload_content', True), 14656 _request_timeout=params.get('_request_timeout'), 14657 collection_formats=collection_formats) 14658 14659 def update_template_recipient_document_visibility(self, account_id, recipient_id, template_id, **kwargs): 14660 """ 14661 Updates document visibility for the recipients 14662 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. 14663 This method makes a synchronous HTTP request by default. To make an 14664 asynchronous HTTP request, please define a `callback` function 14665 to be invoked when receiving the response. 14666 >>> def callback_function(response): 14667 >>> pprint(response) 14668 >>> 14669 >>> thread = api.update_template_recipient_document_visibility(account_id, recipient_id, template_id, callback=callback_function) 14670 14671 :param callback function: The callback function 14672 for asynchronous request. (optional) 14673 :param str account_id: The external account number (int) or account ID Guid. (required) 14674 :param str recipient_id: The ID of the recipient being accessed. (required) 14675 :param str template_id: The ID of the template being accessed. (required) 14676 :param TemplateDocumentVisibilityList template_document_visibility_list: 14677 :return: TemplateDocumentVisibilityList 14678 If the method is called asynchronously, 14679 returns the request thread. 14680 """ 14681 kwargs['_return_http_data_only'] = True 14682 if kwargs.get('callback'): 14683 return self.update_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, **kwargs) 14684 else: 14685 (data) = self.update_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, **kwargs) 14686 return data 14687 14688 def update_template_recipient_document_visibility_with_http_info(self, account_id, recipient_id, template_id, **kwargs): 14689 """ 14690 Updates document visibility for the recipients 14691 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. 14692 This method makes a synchronous HTTP request by default. To make an 14693 asynchronous HTTP request, please define a `callback` function 14694 to be invoked when receiving the response. 14695 >>> def callback_function(response): 14696 >>> pprint(response) 14697 >>> 14698 >>> thread = api.update_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, callback=callback_function) 14699 14700 :param callback function: The callback function 14701 for asynchronous request. (optional) 14702 :param str account_id: The external account number (int) or account ID Guid. (required) 14703 :param str recipient_id: The ID of the recipient being accessed. (required) 14704 :param str template_id: The ID of the template being accessed. (required) 14705 :param TemplateDocumentVisibilityList template_document_visibility_list: 14706 :return: TemplateDocumentVisibilityList 14707 If the method is called asynchronously, 14708 returns the request thread. 14709 """ 14710 14711 all_params = ['account_id', 'recipient_id', 'template_id', 'template_document_visibility_list'] 14712 all_params.append('callback') 14713 all_params.append('_return_http_data_only') 14714 all_params.append('_preload_content') 14715 all_params.append('_request_timeout') 14716 14717 params = locals() 14718 for key, val in iteritems(params['kwargs']): 14719 if key not in all_params: 14720 raise TypeError( 14721 "Got an unexpected keyword argument '%s'" 14722 " to method update_template_recipient_document_visibility" % key 14723 ) 14724 params[key] = val 14725 del params['kwargs'] 14726 # verify the required parameter 'account_id' is set 14727 if ('account_id' not in params) or (params['account_id'] is None): 14728 raise ValueError("Missing the required parameter `account_id` when calling `update_template_recipient_document_visibility`") 14729 # verify the required parameter 'recipient_id' is set 14730 if ('recipient_id' not in params) or (params['recipient_id'] is None): 14731 raise ValueError("Missing the required parameter `recipient_id` when calling `update_template_recipient_document_visibility`") 14732 # verify the required parameter 'template_id' is set 14733 if ('template_id' not in params) or (params['template_id'] is None): 14734 raise ValueError("Missing the required parameter `template_id` when calling `update_template_recipient_document_visibility`") 14735 14736 14737 collection_formats = {} 14738 14739 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/recipients/{recipientId}/document_visibility'.replace('{format}', 'json') 14740 path_params = {} 14741 if 'account_id' in params: 14742 path_params['accountId'] = params['account_id'] 14743 if 'recipient_id' in params: 14744 path_params['recipientId'] = params['recipient_id'] 14745 if 'template_id' in params: 14746 path_params['templateId'] = params['template_id'] 14747 14748 query_params = {} 14749 14750 header_params = {} 14751 14752 form_params = [] 14753 local_var_files = {} 14754 14755 body_params = None 14756 if 'template_document_visibility_list' in params: 14757 body_params = params['template_document_visibility_list'] 14758 # HTTP header `Accept` 14759 header_params['Accept'] = self.api_client.\ 14760 select_header_accept(['application/json']) 14761 14762 # Authentication setting 14763 auth_settings = [] 14764 14765 return self.api_client.call_api(resource_path, 'PUT', 14766 path_params, 14767 query_params, 14768 header_params, 14769 body=body_params, 14770 post_params=form_params, 14771 files=local_var_files, 14772 response_type='TemplateDocumentVisibilityList', 14773 auth_settings=auth_settings, 14774 callback=params.get('callback'), 14775 _return_http_data_only=params.get('_return_http_data_only'), 14776 _preload_content=params.get('_preload_content', True), 14777 _request_timeout=params.get('_request_timeout'), 14778 collection_formats=collection_formats) 14779 14780 def update_template_recipients_document_visibility(self, account_id, template_id, **kwargs): 14781 """ 14782 Updates document visibility for the recipients 14783 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. 14784 This method makes a synchronous HTTP request by default. To make an 14785 asynchronous HTTP request, please define a `callback` function 14786 to be invoked when receiving the response. 14787 >>> def callback_function(response): 14788 >>> pprint(response) 14789 >>> 14790 >>> thread = api.update_template_recipients_document_visibility(account_id, template_id, callback=callback_function) 14791 14792 :param callback function: The callback function 14793 for asynchronous request. (optional) 14794 :param str account_id: The external account number (int) or account ID Guid. (required) 14795 :param str template_id: The ID of the template being accessed. (required) 14796 :param TemplateDocumentVisibilityList template_document_visibility_list: 14797 :return: TemplateDocumentVisibilityList 14798 If the method is called asynchronously, 14799 returns the request thread. 14800 """ 14801 kwargs['_return_http_data_only'] = True 14802 if kwargs.get('callback'): 14803 return self.update_template_recipients_document_visibility_with_http_info(account_id, template_id, **kwargs) 14804 else: 14805 (data) = self.update_template_recipients_document_visibility_with_http_info(account_id, template_id, **kwargs) 14806 return data 14807 14808 def update_template_recipients_document_visibility_with_http_info(self, account_id, template_id, **kwargs): 14809 """ 14810 Updates document visibility for the recipients 14811 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. 14812 This method makes a synchronous HTTP request by default. To make an 14813 asynchronous HTTP request, please define a `callback` function 14814 to be invoked when receiving the response. 14815 >>> def callback_function(response): 14816 >>> pprint(response) 14817 >>> 14818 >>> thread = api.update_template_recipients_document_visibility_with_http_info(account_id, template_id, callback=callback_function) 14819 14820 :param callback function: The callback function 14821 for asynchronous request. (optional) 14822 :param str account_id: The external account number (int) or account ID Guid. (required) 14823 :param str template_id: The ID of the template being accessed. (required) 14824 :param TemplateDocumentVisibilityList template_document_visibility_list: 14825 :return: TemplateDocumentVisibilityList 14826 If the method is called asynchronously, 14827 returns the request thread. 14828 """ 14829 14830 all_params = ['account_id', 'template_id', 'template_document_visibility_list'] 14831 all_params.append('callback') 14832 all_params.append('_return_http_data_only') 14833 all_params.append('_preload_content') 14834 all_params.append('_request_timeout') 14835 14836 params = locals() 14837 for key, val in iteritems(params['kwargs']): 14838 if key not in all_params: 14839 raise TypeError( 14840 "Got an unexpected keyword argument '%s'" 14841 " to method update_template_recipients_document_visibility" % key 14842 ) 14843 params[key] = val 14844 del params['kwargs'] 14845 # verify the required parameter 'account_id' is set 14846 if ('account_id' not in params) or (params['account_id'] is None): 14847 raise ValueError("Missing the required parameter `account_id` when calling `update_template_recipients_document_visibility`") 14848 # verify the required parameter 'template_id' is set 14849 if ('template_id' not in params) or (params['template_id'] is None): 14850 raise ValueError("Missing the required parameter `template_id` when calling `update_template_recipients_document_visibility`") 14851 14852 14853 collection_formats = {} 14854 14855 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/recipients/document_visibility'.replace('{format}', 'json') 14856 path_params = {} 14857 if 'account_id' in params: 14858 path_params['accountId'] = params['account_id'] 14859 if 'template_id' in params: 14860 path_params['templateId'] = params['template_id'] 14861 14862 query_params = {} 14863 14864 header_params = {} 14865 14866 form_params = [] 14867 local_var_files = {} 14868 14869 body_params = None 14870 if 'template_document_visibility_list' in params: 14871 body_params = params['template_document_visibility_list'] 14872 # HTTP header `Accept` 14873 header_params['Accept'] = self.api_client.\ 14874 select_header_accept(['application/json']) 14875 14876 # Authentication setting 14877 auth_settings = [] 14878 14879 return self.api_client.call_api(resource_path, 'PUT', 14880 path_params, 14881 query_params, 14882 header_params, 14883 body=body_params, 14884 post_params=form_params, 14885 files=local_var_files, 14886 response_type='TemplateDocumentVisibilityList', 14887 auth_settings=auth_settings, 14888 callback=params.get('callback'), 14889 _return_http_data_only=params.get('_return_http_data_only'), 14890 _preload_content=params.get('_preload_content', True), 14891 _request_timeout=params.get('_request_timeout'), 14892 collection_formats=collection_formats) 14893 14894 def update_template_scheduled_sending_definition(self, account_id, template_id, **kwargs): 14895 """ 14896 Updates the scheduled sending rules for a template's workflow definition. 14897 This method makes a synchronous HTTP request by default. To make an 14898 asynchronous HTTP request, please define a `callback` function 14899 to be invoked when receiving the response. 14900 >>> def callback_function(response): 14901 >>> pprint(response) 14902 >>> 14903 >>> thread = api.update_template_scheduled_sending_definition(account_id, template_id, callback=callback_function) 14904 14905 :param callback function: The callback function 14906 for asynchronous request. (optional) 14907 :param str account_id: The external account number (int) or account ID Guid. (required) 14908 :param str template_id: The ID of the template being accessed. (required) 14909 :param ScheduledSending scheduled_sending: 14910 :return: ScheduledSending 14911 If the method is called asynchronously, 14912 returns the request thread. 14913 """ 14914 kwargs['_return_http_data_only'] = True 14915 if kwargs.get('callback'): 14916 return self.update_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 14917 else: 14918 (data) = self.update_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 14919 return data 14920 14921 def update_template_scheduled_sending_definition_with_http_info(self, account_id, template_id, **kwargs): 14922 """ 14923 Updates the scheduled sending rules for a template's workflow definition. 14924 This method makes a synchronous HTTP request by default. To make an 14925 asynchronous HTTP request, please define a `callback` function 14926 to be invoked when receiving the response. 14927 >>> def callback_function(response): 14928 >>> pprint(response) 14929 >>> 14930 >>> thread = api.update_template_scheduled_sending_definition_with_http_info(account_id, template_id, callback=callback_function) 14931 14932 :param callback function: The callback function 14933 for asynchronous request. (optional) 14934 :param str account_id: The external account number (int) or account ID Guid. (required) 14935 :param str template_id: The ID of the template being accessed. (required) 14936 :param ScheduledSending scheduled_sending: 14937 :return: ScheduledSending 14938 If the method is called asynchronously, 14939 returns the request thread. 14940 """ 14941 14942 all_params = ['account_id', 'template_id', 'scheduled_sending'] 14943 all_params.append('callback') 14944 all_params.append('_return_http_data_only') 14945 all_params.append('_preload_content') 14946 all_params.append('_request_timeout') 14947 14948 params = locals() 14949 for key, val in iteritems(params['kwargs']): 14950 if key not in all_params: 14951 raise TypeError( 14952 "Got an unexpected keyword argument '%s'" 14953 " to method update_template_scheduled_sending_definition" % key 14954 ) 14955 params[key] = val 14956 del params['kwargs'] 14957 # verify the required parameter 'account_id' is set 14958 if ('account_id' not in params) or (params['account_id'] is None): 14959 raise ValueError("Missing the required parameter `account_id` when calling `update_template_scheduled_sending_definition`") 14960 # verify the required parameter 'template_id' is set 14961 if ('template_id' not in params) or (params['template_id'] is None): 14962 raise ValueError("Missing the required parameter `template_id` when calling `update_template_scheduled_sending_definition`") 14963 14964 14965 collection_formats = {} 14966 14967 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/scheduledSending'.replace('{format}', 'json') 14968 path_params = {} 14969 if 'account_id' in params: 14970 path_params['accountId'] = params['account_id'] 14971 if 'template_id' in params: 14972 path_params['templateId'] = params['template_id'] 14973 14974 query_params = {} 14975 14976 header_params = {} 14977 14978 form_params = [] 14979 local_var_files = {} 14980 14981 body_params = None 14982 if 'scheduled_sending' in params: 14983 body_params = params['scheduled_sending'] 14984 # HTTP header `Accept` 14985 header_params['Accept'] = self.api_client.\ 14986 select_header_accept(['application/json']) 14987 14988 # Authentication setting 14989 auth_settings = [] 14990 14991 return self.api_client.call_api(resource_path, 'PUT', 14992 path_params, 14993 query_params, 14994 header_params, 14995 body=body_params, 14996 post_params=form_params, 14997 files=local_var_files, 14998 response_type='ScheduledSending', 14999 auth_settings=auth_settings, 15000 callback=params.get('callback'), 15001 _return_http_data_only=params.get('_return_http_data_only'), 15002 _preload_content=params.get('_preload_content', True), 15003 _request_timeout=params.get('_request_timeout'), 15004 collection_formats=collection_formats) 15005 15006 def update_template_workflow_definition(self, account_id, template_id, **kwargs): 15007 """ 15008 Updates the workflow definition for a template. 15009 Updates the specified template's workflow definition if it has one. 15010 This method makes a synchronous HTTP request by default. To make an 15011 asynchronous HTTP request, please define a `callback` function 15012 to be invoked when receiving the response. 15013 >>> def callback_function(response): 15014 >>> pprint(response) 15015 >>> 15016 >>> thread = api.update_template_workflow_definition(account_id, template_id, callback=callback_function) 15017 15018 :param callback function: The callback function 15019 for asynchronous request. (optional) 15020 :param str account_id: The external account number (int) or account ID Guid. (required) 15021 :param str template_id: The ID of the template being accessed. (required) 15022 :param Workflow workflow: 15023 :return: Workflow 15024 If the method is called asynchronously, 15025 returns the request thread. 15026 """ 15027 kwargs['_return_http_data_only'] = True 15028 if kwargs.get('callback'): 15029 return self.update_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 15030 else: 15031 (data) = self.update_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 15032 return data 15033 15034 def update_template_workflow_definition_with_http_info(self, account_id, template_id, **kwargs): 15035 """ 15036 Updates the workflow definition for a template. 15037 Updates the specified template's workflow definition if it has one. 15038 This method makes a synchronous HTTP request by default. To make an 15039 asynchronous HTTP request, please define a `callback` function 15040 to be invoked when receiving the response. 15041 >>> def callback_function(response): 15042 >>> pprint(response) 15043 >>> 15044 >>> thread = api.update_template_workflow_definition_with_http_info(account_id, template_id, callback=callback_function) 15045 15046 :param callback function: The callback function 15047 for asynchronous request. (optional) 15048 :param str account_id: The external account number (int) or account ID Guid. (required) 15049 :param str template_id: The ID of the template being accessed. (required) 15050 :param Workflow workflow: 15051 :return: Workflow 15052 If the method is called asynchronously, 15053 returns the request thread. 15054 """ 15055 15056 all_params = ['account_id', 'template_id', 'workflow'] 15057 all_params.append('callback') 15058 all_params.append('_return_http_data_only') 15059 all_params.append('_preload_content') 15060 all_params.append('_request_timeout') 15061 15062 params = locals() 15063 for key, val in iteritems(params['kwargs']): 15064 if key not in all_params: 15065 raise TypeError( 15066 "Got an unexpected keyword argument '%s'" 15067 " to method update_template_workflow_definition" % key 15068 ) 15069 params[key] = val 15070 del params['kwargs'] 15071 # verify the required parameter 'account_id' is set 15072 if ('account_id' not in params) or (params['account_id'] is None): 15073 raise ValueError("Missing the required parameter `account_id` when calling `update_template_workflow_definition`") 15074 # verify the required parameter 'template_id' is set 15075 if ('template_id' not in params) or (params['template_id'] is None): 15076 raise ValueError("Missing the required parameter `template_id` when calling `update_template_workflow_definition`") 15077 15078 15079 collection_formats = {} 15080 15081 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow'.replace('{format}', 'json') 15082 path_params = {} 15083 if 'account_id' in params: 15084 path_params['accountId'] = params['account_id'] 15085 if 'template_id' in params: 15086 path_params['templateId'] = params['template_id'] 15087 15088 query_params = {} 15089 15090 header_params = {} 15091 15092 form_params = [] 15093 local_var_files = {} 15094 15095 body_params = None 15096 if 'workflow' in params: 15097 body_params = params['workflow'] 15098 # HTTP header `Accept` 15099 header_params['Accept'] = self.api_client.\ 15100 select_header_accept(['application/json']) 15101 15102 # Authentication setting 15103 auth_settings = [] 15104 15105 return self.api_client.call_api(resource_path, 'PUT', 15106 path_params, 15107 query_params, 15108 header_params, 15109 body=body_params, 15110 post_params=form_params, 15111 files=local_var_files, 15112 response_type='Workflow', 15113 auth_settings=auth_settings, 15114 callback=params.get('callback'), 15115 _return_http_data_only=params.get('_return_http_data_only'), 15116 _preload_content=params.get('_preload_content', True), 15117 _request_timeout=params.get('_request_timeout'), 15118 collection_formats=collection_formats) 15119 15120 def update_template_workflow_step_definition(self, account_id, template_id, workflow_step_id, **kwargs): 15121 """ 15122 Updates the template workflow step definition for an envelope. 15123 This method makes a synchronous HTTP request by default. To make an 15124 asynchronous HTTP request, please define a `callback` function 15125 to be invoked when receiving the response. 15126 >>> def callback_function(response): 15127 >>> pprint(response) 15128 >>> 15129 >>> thread = api.update_template_workflow_step_definition(account_id, template_id, workflow_step_id, callback=callback_function) 15130 15131 :param callback function: The callback function 15132 for asynchronous request. (optional) 15133 :param str account_id: The external account number (int) or account ID Guid. (required) 15134 :param str template_id: The ID of the template being accessed. (required) 15135 :param str workflow_step_id: (required) 15136 :param WorkflowStep workflow_step: 15137 :return: WorkflowStep 15138 If the method is called asynchronously, 15139 returns the request thread. 15140 """ 15141 kwargs['_return_http_data_only'] = True 15142 if kwargs.get('callback'): 15143 return self.update_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 15144 else: 15145 (data) = self.update_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 15146 return data 15147 15148 def update_template_workflow_step_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 15149 """ 15150 Updates the template workflow step definition for an envelope. 15151 This method makes a synchronous HTTP request by default. To make an 15152 asynchronous HTTP request, please define a `callback` function 15153 to be invoked when receiving the response. 15154 >>> def callback_function(response): 15155 >>> pprint(response) 15156 >>> 15157 >>> thread = api.update_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 15158 15159 :param callback function: The callback function 15160 for asynchronous request. (optional) 15161 :param str account_id: The external account number (int) or account ID Guid. (required) 15162 :param str template_id: The ID of the template being accessed. (required) 15163 :param str workflow_step_id: (required) 15164 :param WorkflowStep workflow_step: 15165 :return: WorkflowStep 15166 If the method is called asynchronously, 15167 returns the request thread. 15168 """ 15169 15170 all_params = ['account_id', 'template_id', 'workflow_step_id', 'workflow_step'] 15171 all_params.append('callback') 15172 all_params.append('_return_http_data_only') 15173 all_params.append('_preload_content') 15174 all_params.append('_request_timeout') 15175 15176 params = locals() 15177 for key, val in iteritems(params['kwargs']): 15178 if key not in all_params: 15179 raise TypeError( 15180 "Got an unexpected keyword argument '%s'" 15181 " to method update_template_workflow_step_definition" % key 15182 ) 15183 params[key] = val 15184 del params['kwargs'] 15185 # verify the required parameter 'account_id' is set 15186 if ('account_id' not in params) or (params['account_id'] is None): 15187 raise ValueError("Missing the required parameter `account_id` when calling `update_template_workflow_step_definition`") 15188 # verify the required parameter 'template_id' is set 15189 if ('template_id' not in params) or (params['template_id'] is None): 15190 raise ValueError("Missing the required parameter `template_id` when calling `update_template_workflow_step_definition`") 15191 # verify the required parameter 'workflow_step_id' is set 15192 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 15193 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_template_workflow_step_definition`") 15194 15195 15196 collection_formats = {} 15197 15198 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 15199 path_params = {} 15200 if 'account_id' in params: 15201 path_params['accountId'] = params['account_id'] 15202 if 'template_id' in params: 15203 path_params['templateId'] = params['template_id'] 15204 if 'workflow_step_id' in params: 15205 path_params['workflowStepId'] = params['workflow_step_id'] 15206 15207 query_params = {} 15208 15209 header_params = {} 15210 15211 form_params = [] 15212 local_var_files = {} 15213 15214 body_params = None 15215 if 'workflow_step' in params: 15216 body_params = params['workflow_step'] 15217 # HTTP header `Accept` 15218 header_params['Accept'] = self.api_client.\ 15219 select_header_accept(['application/json']) 15220 15221 # Authentication setting 15222 auth_settings = [] 15223 15224 return self.api_client.call_api(resource_path, 'PUT', 15225 path_params, 15226 query_params, 15227 header_params, 15228 body=body_params, 15229 post_params=form_params, 15230 files=local_var_files, 15231 response_type='WorkflowStep', 15232 auth_settings=auth_settings, 15233 callback=params.get('callback'), 15234 _return_http_data_only=params.get('_return_http_data_only'), 15235 _preload_content=params.get('_preload_content', True), 15236 _request_timeout=params.get('_request_timeout'), 15237 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 CorrectViewRequest correct_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)
- CorrectViewRequest correct_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 CorrectViewRequest correct_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', 'correct_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 'correct_view_request' in params: 592 body_params = params['correct_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)
- CorrectViewRequest correct_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 ReturnUrlRequest return_url_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)
- ReturnUrlRequest return_url_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 ReturnUrlRequest return_url_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', 'return_url_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 'return_url_request' in params: 1183 body_params = params['return_url_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)
- ReturnUrlRequest return_url_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, token_scopes, **kwargs)
2579 def create_recipient_proof_file_resource_token(self, account_id, envelope_id, recipient_id, token_scopes, **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, token_scopes, 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: (required) 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, token_scopes, **kwargs) 2604 else: 2605 (data) = self.create_recipient_proof_file_resource_token_with_http_info(account_id, envelope_id, recipient_id, token_scopes, **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, token_scopes, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str 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: (required)
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, token_scopes, **kwargs)
2608 def create_recipient_proof_file_resource_token_with_http_info(self, account_id, envelope_id, recipient_id, token_scopes, **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, token_scopes, 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: (required) 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 # verify the required parameter 'token_scopes' is set 2656 if ('token_scopes' not in params) or (params['token_scopes'] is None): 2657 raise ValueError("Missing the required parameter `token_scopes` when calling `create_recipient_proof_file_resource_token`") 2658 2659 2660 collection_formats = {} 2661 2662 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/identity_proof_token'.replace('{format}', 'json') 2663 path_params = {} 2664 if 'account_id' in params: 2665 path_params['accountId'] = params['account_id'] 2666 if 'envelope_id' in params: 2667 path_params['envelopeId'] = params['envelope_id'] 2668 if 'recipient_id' in params: 2669 path_params['recipientId'] = params['recipient_id'] 2670 if 'token_scopes' in params: 2671 path_params['token_scopes'] = params['token_scopes'] 2672 2673 query_params = {} 2674 2675 header_params = {} 2676 2677 form_params = [] 2678 local_var_files = {} 2679 2680 body_params = None 2681 # HTTP header `Accept` 2682 header_params['Accept'] = self.api_client.\ 2683 select_header_accept(['application/json']) 2684 2685 # Authentication setting 2686 auth_settings = [] 2687 2688 return self.api_client.call_api(resource_path, 'POST', 2689 path_params, 2690 query_params, 2691 header_params, 2692 body=body_params, 2693 post_params=form_params, 2694 files=local_var_files, 2695 response_type='IdEvidenceResourceToken', 2696 auth_settings=auth_settings, 2697 callback=params.get('callback'), 2698 _return_http_data_only=params.get('_return_http_data_only'), 2699 _preload_content=params.get('_preload_content', True), 2700 _request_timeout=params.get('_request_timeout'), 2701 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, token_scopes, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str 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: (required)
Returns
IdEvidenceResourceToken If the method is called asynchronously, returns the request thread.
def
create_recipient_view(self, account_id, envelope_id, **kwargs)
2703 def create_recipient_view(self, account_id, envelope_id, **kwargs): 2704 """ 2705 Returns a URL to the recipient view UI. 2706 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. 2707 This method makes a synchronous HTTP request by default. To make an 2708 asynchronous HTTP request, please define a `callback` function 2709 to be invoked when receiving the response. 2710 >>> def callback_function(response): 2711 >>> pprint(response) 2712 >>> 2713 >>> thread = api.create_recipient_view(account_id, envelope_id, callback=callback_function) 2714 2715 :param callback function: The callback function 2716 for asynchronous request. (optional) 2717 :param str account_id: The external account number (int) or account ID Guid. (required) 2718 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2719 :param RecipientViewRequest recipient_view_request: 2720 :return: ViewUrl 2721 If the method is called asynchronously, 2722 returns the request thread. 2723 """ 2724 kwargs['_return_http_data_only'] = True 2725 if kwargs.get('callback'): 2726 return self.create_recipient_view_with_http_info(account_id, envelope_id, **kwargs) 2727 else: 2728 (data) = self.create_recipient_view_with_http_info(account_id, envelope_id, **kwargs) 2729 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)
2731 def create_recipient_view_with_http_info(self, account_id, envelope_id, **kwargs): 2732 """ 2733 Returns a URL to the recipient view UI. 2734 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. 2735 This method makes a synchronous HTTP request by default. To make an 2736 asynchronous HTTP request, please define a `callback` function 2737 to be invoked when receiving the response. 2738 >>> def callback_function(response): 2739 >>> pprint(response) 2740 >>> 2741 >>> thread = api.create_recipient_view_with_http_info(account_id, envelope_id, callback=callback_function) 2742 2743 :param callback function: The callback function 2744 for asynchronous request. (optional) 2745 :param str account_id: The external account number (int) or account ID Guid. (required) 2746 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2747 :param RecipientViewRequest recipient_view_request: 2748 :return: ViewUrl 2749 If the method is called asynchronously, 2750 returns the request thread. 2751 """ 2752 2753 all_params = ['account_id', 'envelope_id', 'recipient_view_request'] 2754 all_params.append('callback') 2755 all_params.append('_return_http_data_only') 2756 all_params.append('_preload_content') 2757 all_params.append('_request_timeout') 2758 2759 params = locals() 2760 for key, val in iteritems(params['kwargs']): 2761 if key not in all_params: 2762 raise TypeError( 2763 "Got an unexpected keyword argument '%s'" 2764 " to method create_recipient_view" % key 2765 ) 2766 params[key] = val 2767 del params['kwargs'] 2768 # verify the required parameter 'account_id' is set 2769 if ('account_id' not in params) or (params['account_id'] is None): 2770 raise ValueError("Missing the required parameter `account_id` when calling `create_recipient_view`") 2771 # verify the required parameter 'envelope_id' is set 2772 if ('envelope_id' not in params) or (params['envelope_id'] is None): 2773 raise ValueError("Missing the required parameter `envelope_id` when calling `create_recipient_view`") 2774 2775 2776 collection_formats = {} 2777 2778 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/recipient'.replace('{format}', 'json') 2779 path_params = {} 2780 if 'account_id' in params: 2781 path_params['accountId'] = params['account_id'] 2782 if 'envelope_id' in params: 2783 path_params['envelopeId'] = params['envelope_id'] 2784 2785 query_params = {} 2786 2787 header_params = {} 2788 2789 form_params = [] 2790 local_var_files = {} 2791 2792 body_params = None 2793 if 'recipient_view_request' in params: 2794 body_params = params['recipient_view_request'] 2795 # HTTP header `Accept` 2796 header_params['Accept'] = self.api_client.\ 2797 select_header_accept(['application/json']) 2798 2799 # Authentication setting 2800 auth_settings = [] 2801 2802 return self.api_client.call_api(resource_path, 'POST', 2803 path_params, 2804 query_params, 2805 header_params, 2806 body=body_params, 2807 post_params=form_params, 2808 files=local_var_files, 2809 response_type='ViewUrl', 2810 auth_settings=auth_settings, 2811 callback=params.get('callback'), 2812 _return_http_data_only=params.get('_return_http_data_only'), 2813 _preload_content=params.get('_preload_content', True), 2814 _request_timeout=params.get('_request_timeout'), 2815 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)
2817 def create_responsive_html_preview(self, account_id, envelope_id, **kwargs): 2818 """ 2819 Get Responsive HTML Preview for all documents in an envelope. 2820 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. 2821 This method makes a synchronous HTTP request by default. To make an 2822 asynchronous HTTP request, please define a `callback` function 2823 to be invoked when receiving the response. 2824 >>> def callback_function(response): 2825 >>> pprint(response) 2826 >>> 2827 >>> thread = api.create_responsive_html_preview(account_id, envelope_id, callback=callback_function) 2828 2829 :param callback function: The callback function 2830 for asynchronous request. (optional) 2831 :param str account_id: The external account number (int) or account ID Guid. (required) 2832 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2833 :param DocumentHtmlDefinition document_html_definition: 2834 :return: DocumentHtmlDefinitions 2835 If the method is called asynchronously, 2836 returns the request thread. 2837 """ 2838 kwargs['_return_http_data_only'] = True 2839 if kwargs.get('callback'): 2840 return self.create_responsive_html_preview_with_http_info(account_id, envelope_id, **kwargs) 2841 else: 2842 (data) = self.create_responsive_html_preview_with_http_info(account_id, envelope_id, **kwargs) 2843 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)
2845 def create_responsive_html_preview_with_http_info(self, account_id, envelope_id, **kwargs): 2846 """ 2847 Get Responsive HTML Preview for all documents in an envelope. 2848 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. 2849 This method makes a synchronous HTTP request by default. To make an 2850 asynchronous HTTP request, please define a `callback` function 2851 to be invoked when receiving the response. 2852 >>> def callback_function(response): 2853 >>> pprint(response) 2854 >>> 2855 >>> thread = api.create_responsive_html_preview_with_http_info(account_id, envelope_id, callback=callback_function) 2856 2857 :param callback function: The callback function 2858 for asynchronous request. (optional) 2859 :param str account_id: The external account number (int) or account ID Guid. (required) 2860 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2861 :param DocumentHtmlDefinition document_html_definition: 2862 :return: DocumentHtmlDefinitions 2863 If the method is called asynchronously, 2864 returns the request thread. 2865 """ 2866 2867 all_params = ['account_id', 'envelope_id', 'document_html_definition'] 2868 all_params.append('callback') 2869 all_params.append('_return_http_data_only') 2870 all_params.append('_preload_content') 2871 all_params.append('_request_timeout') 2872 2873 params = locals() 2874 for key, val in iteritems(params['kwargs']): 2875 if key not in all_params: 2876 raise TypeError( 2877 "Got an unexpected keyword argument '%s'" 2878 " to method create_responsive_html_preview" % key 2879 ) 2880 params[key] = val 2881 del params['kwargs'] 2882 # verify the required parameter 'account_id' is set 2883 if ('account_id' not in params) or (params['account_id'] is None): 2884 raise ValueError("Missing the required parameter `account_id` when calling `create_responsive_html_preview`") 2885 # verify the required parameter 'envelope_id' is set 2886 if ('envelope_id' not in params) or (params['envelope_id'] is None): 2887 raise ValueError("Missing the required parameter `envelope_id` when calling `create_responsive_html_preview`") 2888 2889 2890 collection_formats = {} 2891 2892 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/responsive_html_preview'.replace('{format}', 'json') 2893 path_params = {} 2894 if 'account_id' in params: 2895 path_params['accountId'] = params['account_id'] 2896 if 'envelope_id' in params: 2897 path_params['envelopeId'] = params['envelope_id'] 2898 2899 query_params = {} 2900 2901 header_params = {} 2902 2903 form_params = [] 2904 local_var_files = {} 2905 2906 body_params = None 2907 if 'document_html_definition' in params: 2908 body_params = params['document_html_definition'] 2909 # HTTP header `Accept` 2910 header_params['Accept'] = self.api_client.\ 2911 select_header_accept(['application/json']) 2912 2913 # Authentication setting 2914 auth_settings = [] 2915 2916 return self.api_client.call_api(resource_path, 'POST', 2917 path_params, 2918 query_params, 2919 header_params, 2920 body=body_params, 2921 post_params=form_params, 2922 files=local_var_files, 2923 response_type='DocumentHtmlDefinitions', 2924 auth_settings=auth_settings, 2925 callback=params.get('callback'), 2926 _return_http_data_only=params.get('_return_http_data_only'), 2927 _preload_content=params.get('_preload_content', True), 2928 _request_timeout=params.get('_request_timeout'), 2929 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)
2931 def create_sender_view(self, account_id, envelope_id, **kwargs): 2932 """ 2933 Returns a URL to the sender view UI. 2934 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. 2935 This method makes a synchronous HTTP request by default. To make an 2936 asynchronous HTTP request, please define a `callback` function 2937 to be invoked when receiving the response. 2938 >>> def callback_function(response): 2939 >>> pprint(response) 2940 >>> 2941 >>> thread = api.create_sender_view(account_id, envelope_id, callback=callback_function) 2942 2943 :param callback function: The callback function 2944 for asynchronous request. (optional) 2945 :param str account_id: The external account number (int) or account ID Guid. (required) 2946 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2947 :param ReturnUrlRequest return_url_request: 2948 :return: ViewUrl 2949 If the method is called asynchronously, 2950 returns the request thread. 2951 """ 2952 kwargs['_return_http_data_only'] = True 2953 if kwargs.get('callback'): 2954 return self.create_sender_view_with_http_info(account_id, envelope_id, **kwargs) 2955 else: 2956 (data) = self.create_sender_view_with_http_info(account_id, envelope_id, **kwargs) 2957 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)
- ReturnUrlRequest return_url_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)
2959 def create_sender_view_with_http_info(self, account_id, envelope_id, **kwargs): 2960 """ 2961 Returns a URL to the sender view UI. 2962 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. 2963 This method makes a synchronous HTTP request by default. To make an 2964 asynchronous HTTP request, please define a `callback` function 2965 to be invoked when receiving the response. 2966 >>> def callback_function(response): 2967 >>> pprint(response) 2968 >>> 2969 >>> thread = api.create_sender_view_with_http_info(account_id, envelope_id, callback=callback_function) 2970 2971 :param callback function: The callback function 2972 for asynchronous request. (optional) 2973 :param str account_id: The external account number (int) or account ID Guid. (required) 2974 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 2975 :param ReturnUrlRequest return_url_request: 2976 :return: ViewUrl 2977 If the method is called asynchronously, 2978 returns the request thread. 2979 """ 2980 2981 all_params = ['account_id', 'envelope_id', 'return_url_request'] 2982 all_params.append('callback') 2983 all_params.append('_return_http_data_only') 2984 all_params.append('_preload_content') 2985 all_params.append('_request_timeout') 2986 2987 params = locals() 2988 for key, val in iteritems(params['kwargs']): 2989 if key not in all_params: 2990 raise TypeError( 2991 "Got an unexpected keyword argument '%s'" 2992 " to method create_sender_view" % key 2993 ) 2994 params[key] = val 2995 del params['kwargs'] 2996 # verify the required parameter 'account_id' is set 2997 if ('account_id' not in params) or (params['account_id'] is None): 2998 raise ValueError("Missing the required parameter `account_id` when calling `create_sender_view`") 2999 # verify the required parameter 'envelope_id' is set 3000 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3001 raise ValueError("Missing the required parameter `envelope_id` when calling `create_sender_view`") 3002 3003 3004 collection_formats = {} 3005 3006 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/sender'.replace('{format}', 'json') 3007 path_params = {} 3008 if 'account_id' in params: 3009 path_params['accountId'] = params['account_id'] 3010 if 'envelope_id' in params: 3011 path_params['envelopeId'] = params['envelope_id'] 3012 3013 query_params = {} 3014 3015 header_params = {} 3016 3017 form_params = [] 3018 local_var_files = {} 3019 3020 body_params = None 3021 if 'return_url_request' in params: 3022 body_params = params['return_url_request'] 3023 # HTTP header `Accept` 3024 header_params['Accept'] = self.api_client.\ 3025 select_header_accept(['application/json']) 3026 3027 # Authentication setting 3028 auth_settings = [] 3029 3030 return self.api_client.call_api(resource_path, 'POST', 3031 path_params, 3032 query_params, 3033 header_params, 3034 body=body_params, 3035 post_params=form_params, 3036 files=local_var_files, 3037 response_type='ViewUrl', 3038 auth_settings=auth_settings, 3039 callback=params.get('callback'), 3040 _return_http_data_only=params.get('_return_http_data_only'), 3041 _preload_content=params.get('_preload_content', True), 3042 _request_timeout=params.get('_request_timeout'), 3043 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)
- ReturnUrlRequest return_url_request:
Returns
ViewUrl If the method is called asynchronously, returns the request thread.
def
create_tabs(self, account_id, envelope_id, recipient_id, **kwargs)
3045 def create_tabs(self, account_id, envelope_id, recipient_id, **kwargs): 3046 """ 3047 Adds tabs for a recipient. 3048 Adds one or more tabs for a recipient. 3049 This method makes a synchronous HTTP request by default. To make an 3050 asynchronous HTTP request, please define a `callback` function 3051 to be invoked when receiving the response. 3052 >>> def callback_function(response): 3053 >>> pprint(response) 3054 >>> 3055 >>> thread = api.create_tabs(account_id, envelope_id, recipient_id, callback=callback_function) 3056 3057 :param callback function: The callback function 3058 for asynchronous request. (optional) 3059 :param str account_id: The external account number (int) or account ID Guid. (required) 3060 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3061 :param str recipient_id: The ID of the recipient being accessed. (required) 3062 :param Tabs tabs: 3063 :return: Tabs 3064 If the method is called asynchronously, 3065 returns the request thread. 3066 """ 3067 kwargs['_return_http_data_only'] = True 3068 if kwargs.get('callback'): 3069 return self.create_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 3070 else: 3071 (data) = self.create_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 3072 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)
3074 def create_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 3075 """ 3076 Adds tabs for a recipient. 3077 Adds one or more tabs for a recipient. 3078 This method makes a synchronous HTTP request by default. To make an 3079 asynchronous HTTP request, please define a `callback` function 3080 to be invoked when receiving the response. 3081 >>> def callback_function(response): 3082 >>> pprint(response) 3083 >>> 3084 >>> thread = api.create_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 3085 3086 :param callback function: The callback function 3087 for asynchronous request. (optional) 3088 :param str account_id: The external account number (int) or account ID Guid. (required) 3089 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3090 :param str recipient_id: The ID of the recipient being accessed. (required) 3091 :param Tabs tabs: 3092 :return: Tabs 3093 If the method is called asynchronously, 3094 returns the request thread. 3095 """ 3096 3097 all_params = ['account_id', 'envelope_id', 'recipient_id', 'tabs'] 3098 all_params.append('callback') 3099 all_params.append('_return_http_data_only') 3100 all_params.append('_preload_content') 3101 all_params.append('_request_timeout') 3102 3103 params = locals() 3104 for key, val in iteritems(params['kwargs']): 3105 if key not in all_params: 3106 raise TypeError( 3107 "Got an unexpected keyword argument '%s'" 3108 " to method create_tabs" % key 3109 ) 3110 params[key] = val 3111 del params['kwargs'] 3112 # verify the required parameter 'account_id' is set 3113 if ('account_id' not in params) or (params['account_id'] is None): 3114 raise ValueError("Missing the required parameter `account_id` when calling `create_tabs`") 3115 # verify the required parameter 'envelope_id' is set 3116 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3117 raise ValueError("Missing the required parameter `envelope_id` when calling `create_tabs`") 3118 # verify the required parameter 'recipient_id' is set 3119 if ('recipient_id' not in params) or (params['recipient_id'] is None): 3120 raise ValueError("Missing the required parameter `recipient_id` when calling `create_tabs`") 3121 3122 3123 collection_formats = {} 3124 3125 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/tabs'.replace('{format}', 'json') 3126 path_params = {} 3127 if 'account_id' in params: 3128 path_params['accountId'] = params['account_id'] 3129 if 'envelope_id' in params: 3130 path_params['envelopeId'] = params['envelope_id'] 3131 if 'recipient_id' in params: 3132 path_params['recipientId'] = params['recipient_id'] 3133 3134 query_params = {} 3135 3136 header_params = {} 3137 3138 form_params = [] 3139 local_var_files = {} 3140 3141 body_params = None 3142 if 'tabs' in params: 3143 body_params = params['tabs'] 3144 # HTTP header `Accept` 3145 header_params['Accept'] = self.api_client.\ 3146 select_header_accept(['application/json']) 3147 3148 # Authentication setting 3149 auth_settings = [] 3150 3151 return self.api_client.call_api(resource_path, 'POST', 3152 path_params, 3153 query_params, 3154 header_params, 3155 body=body_params, 3156 post_params=form_params, 3157 files=local_var_files, 3158 response_type='Tabs', 3159 auth_settings=auth_settings, 3160 callback=params.get('callback'), 3161 _return_http_data_only=params.get('_return_http_data_only'), 3162 _preload_content=params.get('_preload_content', True), 3163 _request_timeout=params.get('_request_timeout'), 3164 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)
3166 def create_template_workflow_step_definition(self, account_id, template_id, **kwargs): 3167 """ 3168 Creates and adds a new workflow step definition for a template's workflow 3169 This method makes a synchronous HTTP request by default. To make an 3170 asynchronous HTTP request, please define a `callback` function 3171 to be invoked when receiving the response. 3172 >>> def callback_function(response): 3173 >>> pprint(response) 3174 >>> 3175 >>> thread = api.create_template_workflow_step_definition(account_id, template_id, callback=callback_function) 3176 3177 :param callback function: The callback function 3178 for asynchronous request. (optional) 3179 :param str account_id: The external account number (int) or account ID Guid. (required) 3180 :param str template_id: The ID of the template being accessed. (required) 3181 :param WorkflowStep workflow_step: 3182 :return: WorkflowStep 3183 If the method is called asynchronously, 3184 returns the request thread. 3185 """ 3186 kwargs['_return_http_data_only'] = True 3187 if kwargs.get('callback'): 3188 return self.create_template_workflow_step_definition_with_http_info(account_id, template_id, **kwargs) 3189 else: 3190 (data) = self.create_template_workflow_step_definition_with_http_info(account_id, template_id, **kwargs) 3191 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)
3193 def create_template_workflow_step_definition_with_http_info(self, account_id, template_id, **kwargs): 3194 """ 3195 Creates and adds a new workflow step definition for a template's workflow 3196 This method makes a synchronous HTTP request by default. To make an 3197 asynchronous HTTP request, please define a `callback` function 3198 to be invoked when receiving the response. 3199 >>> def callback_function(response): 3200 >>> pprint(response) 3201 >>> 3202 >>> thread = api.create_template_workflow_step_definition_with_http_info(account_id, template_id, callback=callback_function) 3203 3204 :param callback function: The callback function 3205 for asynchronous request. (optional) 3206 :param str account_id: The external account number (int) or account ID Guid. (required) 3207 :param str template_id: The ID of the template being accessed. (required) 3208 :param WorkflowStep workflow_step: 3209 :return: WorkflowStep 3210 If the method is called asynchronously, 3211 returns the request thread. 3212 """ 3213 3214 all_params = ['account_id', 'template_id', 'workflow_step'] 3215 all_params.append('callback') 3216 all_params.append('_return_http_data_only') 3217 all_params.append('_preload_content') 3218 all_params.append('_request_timeout') 3219 3220 params = locals() 3221 for key, val in iteritems(params['kwargs']): 3222 if key not in all_params: 3223 raise TypeError( 3224 "Got an unexpected keyword argument '%s'" 3225 " to method create_template_workflow_step_definition" % key 3226 ) 3227 params[key] = val 3228 del params['kwargs'] 3229 # verify the required parameter 'account_id' is set 3230 if ('account_id' not in params) or (params['account_id'] is None): 3231 raise ValueError("Missing the required parameter `account_id` when calling `create_template_workflow_step_definition`") 3232 # verify the required parameter 'template_id' is set 3233 if ('template_id' not in params) or (params['template_id'] is None): 3234 raise ValueError("Missing the required parameter `template_id` when calling `create_template_workflow_step_definition`") 3235 3236 3237 collection_formats = {} 3238 3239 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps'.replace('{format}', 'json') 3240 path_params = {} 3241 if 'account_id' in params: 3242 path_params['accountId'] = params['account_id'] 3243 if 'template_id' in params: 3244 path_params['templateId'] = params['template_id'] 3245 3246 query_params = {} 3247 3248 header_params = {} 3249 3250 form_params = [] 3251 local_var_files = {} 3252 3253 body_params = None 3254 if 'workflow_step' in params: 3255 body_params = params['workflow_step'] 3256 # HTTP header `Accept` 3257 header_params['Accept'] = self.api_client.\ 3258 select_header_accept(['application/json']) 3259 3260 # Authentication setting 3261 auth_settings = [] 3262 3263 return self.api_client.call_api(resource_path, 'POST', 3264 path_params, 3265 query_params, 3266 header_params, 3267 body=body_params, 3268 post_params=form_params, 3269 files=local_var_files, 3270 response_type='WorkflowStep', 3271 auth_settings=auth_settings, 3272 callback=params.get('callback'), 3273 _return_http_data_only=params.get('_return_http_data_only'), 3274 _preload_content=params.get('_preload_content', True), 3275 _request_timeout=params.get('_request_timeout'), 3276 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)
3278 def delete_attachments(self, account_id, envelope_id, **kwargs): 3279 """ 3280 Delete one or more attachments from a DRAFT envelope. 3281 Deletes one or more attachments from a draft envelope. 3282 This method makes a synchronous HTTP request by default. To make an 3283 asynchronous HTTP request, please define a `callback` function 3284 to be invoked when receiving the response. 3285 >>> def callback_function(response): 3286 >>> pprint(response) 3287 >>> 3288 >>> thread = api.delete_attachments(account_id, envelope_id, callback=callback_function) 3289 3290 :param callback function: The callback function 3291 for asynchronous request. (optional) 3292 :param str account_id: The external account number (int) or account ID Guid. (required) 3293 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3294 :param EnvelopeAttachmentsRequest envelope_attachments_request: 3295 :return: EnvelopeAttachmentsResult 3296 If the method is called asynchronously, 3297 returns the request thread. 3298 """ 3299 kwargs['_return_http_data_only'] = True 3300 if kwargs.get('callback'): 3301 return self.delete_attachments_with_http_info(account_id, envelope_id, **kwargs) 3302 else: 3303 (data) = self.delete_attachments_with_http_info(account_id, envelope_id, **kwargs) 3304 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)
3306 def delete_attachments_with_http_info(self, account_id, envelope_id, **kwargs): 3307 """ 3308 Delete one or more attachments from a DRAFT envelope. 3309 Deletes one or more attachments from a draft envelope. 3310 This method makes a synchronous HTTP request by default. To make an 3311 asynchronous HTTP request, please define a `callback` function 3312 to be invoked when receiving the response. 3313 >>> def callback_function(response): 3314 >>> pprint(response) 3315 >>> 3316 >>> thread = api.delete_attachments_with_http_info(account_id, envelope_id, callback=callback_function) 3317 3318 :param callback function: The callback function 3319 for asynchronous request. (optional) 3320 :param str account_id: The external account number (int) or account ID Guid. (required) 3321 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3322 :param EnvelopeAttachmentsRequest envelope_attachments_request: 3323 :return: EnvelopeAttachmentsResult 3324 If the method is called asynchronously, 3325 returns the request thread. 3326 """ 3327 3328 all_params = ['account_id', 'envelope_id', 'envelope_attachments_request'] 3329 all_params.append('callback') 3330 all_params.append('_return_http_data_only') 3331 all_params.append('_preload_content') 3332 all_params.append('_request_timeout') 3333 3334 params = locals() 3335 for key, val in iteritems(params['kwargs']): 3336 if key not in all_params: 3337 raise TypeError( 3338 "Got an unexpected keyword argument '%s'" 3339 " to method delete_attachments" % key 3340 ) 3341 params[key] = val 3342 del params['kwargs'] 3343 # verify the required parameter 'account_id' is set 3344 if ('account_id' not in params) or (params['account_id'] is None): 3345 raise ValueError("Missing the required parameter `account_id` when calling `delete_attachments`") 3346 # verify the required parameter 'envelope_id' is set 3347 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3348 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_attachments`") 3349 3350 3351 collection_formats = {} 3352 3353 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments'.replace('{format}', 'json') 3354 path_params = {} 3355 if 'account_id' in params: 3356 path_params['accountId'] = params['account_id'] 3357 if 'envelope_id' in params: 3358 path_params['envelopeId'] = params['envelope_id'] 3359 3360 query_params = {} 3361 3362 header_params = {} 3363 3364 form_params = [] 3365 local_var_files = {} 3366 3367 body_params = None 3368 if 'envelope_attachments_request' in params: 3369 body_params = params['envelope_attachments_request'] 3370 # HTTP header `Accept` 3371 header_params['Accept'] = self.api_client.\ 3372 select_header_accept(['application/json']) 3373 3374 # Authentication setting 3375 auth_settings = [] 3376 3377 return self.api_client.call_api(resource_path, 'DELETE', 3378 path_params, 3379 query_params, 3380 header_params, 3381 body=body_params, 3382 post_params=form_params, 3383 files=local_var_files, 3384 response_type='EnvelopeAttachmentsResult', 3385 auth_settings=auth_settings, 3386 callback=params.get('callback'), 3387 _return_http_data_only=params.get('_return_http_data_only'), 3388 _preload_content=params.get('_preload_content', True), 3389 _request_timeout=params.get('_request_timeout'), 3390 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)
3392 def delete_chunked_upload(self, account_id, chunked_upload_id, **kwargs): 3393 """ 3394 Delete an existing ChunkedUpload. 3395 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. 3396 This method makes a synchronous HTTP request by default. To make an 3397 asynchronous HTTP request, please define a `callback` function 3398 to be invoked when receiving the response. 3399 >>> def callback_function(response): 3400 >>> pprint(response) 3401 >>> 3402 >>> thread = api.delete_chunked_upload(account_id, chunked_upload_id, callback=callback_function) 3403 3404 :param callback function: The callback function 3405 for asynchronous request. (optional) 3406 :param str account_id: The external account number (int) or account ID Guid. (required) 3407 :param str chunked_upload_id: (required) 3408 :return: ChunkedUploadResponse 3409 If the method is called asynchronously, 3410 returns the request thread. 3411 """ 3412 kwargs['_return_http_data_only'] = True 3413 if kwargs.get('callback'): 3414 return self.delete_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 3415 else: 3416 (data) = self.delete_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 3417 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)
3419 def delete_chunked_upload_with_http_info(self, account_id, chunked_upload_id, **kwargs): 3420 """ 3421 Delete an existing ChunkedUpload. 3422 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. 3423 This method makes a synchronous HTTP request by default. To make an 3424 asynchronous HTTP request, please define a `callback` function 3425 to be invoked when receiving the response. 3426 >>> def callback_function(response): 3427 >>> pprint(response) 3428 >>> 3429 >>> thread = api.delete_chunked_upload_with_http_info(account_id, chunked_upload_id, callback=callback_function) 3430 3431 :param callback function: The callback function 3432 for asynchronous request. (optional) 3433 :param str account_id: The external account number (int) or account ID Guid. (required) 3434 :param str chunked_upload_id: (required) 3435 :return: ChunkedUploadResponse 3436 If the method is called asynchronously, 3437 returns the request thread. 3438 """ 3439 3440 all_params = ['account_id', 'chunked_upload_id'] 3441 all_params.append('callback') 3442 all_params.append('_return_http_data_only') 3443 all_params.append('_preload_content') 3444 all_params.append('_request_timeout') 3445 3446 params = locals() 3447 for key, val in iteritems(params['kwargs']): 3448 if key not in all_params: 3449 raise TypeError( 3450 "Got an unexpected keyword argument '%s'" 3451 " to method delete_chunked_upload" % key 3452 ) 3453 params[key] = val 3454 del params['kwargs'] 3455 # verify the required parameter 'account_id' is set 3456 if ('account_id' not in params) or (params['account_id'] is None): 3457 raise ValueError("Missing the required parameter `account_id` when calling `delete_chunked_upload`") 3458 # verify the required parameter 'chunked_upload_id' is set 3459 if ('chunked_upload_id' not in params) or (params['chunked_upload_id'] is None): 3460 raise ValueError("Missing the required parameter `chunked_upload_id` when calling `delete_chunked_upload`") 3461 3462 3463 collection_formats = {} 3464 3465 resource_path = '/v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}'.replace('{format}', 'json') 3466 path_params = {} 3467 if 'account_id' in params: 3468 path_params['accountId'] = params['account_id'] 3469 if 'chunked_upload_id' in params: 3470 path_params['chunkedUploadId'] = params['chunked_upload_id'] 3471 3472 query_params = {} 3473 3474 header_params = {} 3475 3476 form_params = [] 3477 local_var_files = {} 3478 3479 body_params = None 3480 # HTTP header `Accept` 3481 header_params['Accept'] = self.api_client.\ 3482 select_header_accept(['application/json']) 3483 3484 # Authentication setting 3485 auth_settings = [] 3486 3487 return self.api_client.call_api(resource_path, 'DELETE', 3488 path_params, 3489 query_params, 3490 header_params, 3491 body=body_params, 3492 post_params=form_params, 3493 files=local_var_files, 3494 response_type='ChunkedUploadResponse', 3495 auth_settings=auth_settings, 3496 callback=params.get('callback'), 3497 _return_http_data_only=params.get('_return_http_data_only'), 3498 _preload_content=params.get('_preload_content', True), 3499 _request_timeout=params.get('_request_timeout'), 3500 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)
3502 def delete_custom_fields(self, account_id, envelope_id, **kwargs): 3503 """ 3504 Deletes envelope custom fields for draft and in-process envelopes. 3505 Deletes envelope custom fields for draft and in-process envelopes. 3506 This method makes a synchronous HTTP request by default. To make an 3507 asynchronous HTTP request, please define a `callback` function 3508 to be invoked when receiving the response. 3509 >>> def callback_function(response): 3510 >>> pprint(response) 3511 >>> 3512 >>> thread = api.delete_custom_fields(account_id, envelope_id, callback=callback_function) 3513 3514 :param callback function: The callback function 3515 for asynchronous request. (optional) 3516 :param str account_id: The external account number (int) or account ID Guid. (required) 3517 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3518 :param CustomFields custom_fields: 3519 :return: CustomFields 3520 If the method is called asynchronously, 3521 returns the request thread. 3522 """ 3523 kwargs['_return_http_data_only'] = True 3524 if kwargs.get('callback'): 3525 return self.delete_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 3526 else: 3527 (data) = self.delete_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 3528 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)
3530 def delete_custom_fields_with_http_info(self, account_id, envelope_id, **kwargs): 3531 """ 3532 Deletes envelope custom fields for draft and in-process envelopes. 3533 Deletes envelope custom fields for draft and in-process envelopes. 3534 This method makes a synchronous HTTP request by default. To make an 3535 asynchronous HTTP request, please define a `callback` function 3536 to be invoked when receiving the response. 3537 >>> def callback_function(response): 3538 >>> pprint(response) 3539 >>> 3540 >>> thread = api.delete_custom_fields_with_http_info(account_id, envelope_id, callback=callback_function) 3541 3542 :param callback function: The callback function 3543 for asynchronous request. (optional) 3544 :param str account_id: The external account number (int) or account ID Guid. (required) 3545 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3546 :param CustomFields custom_fields: 3547 :return: CustomFields 3548 If the method is called asynchronously, 3549 returns the request thread. 3550 """ 3551 3552 all_params = ['account_id', 'envelope_id', 'custom_fields'] 3553 all_params.append('callback') 3554 all_params.append('_return_http_data_only') 3555 all_params.append('_preload_content') 3556 all_params.append('_request_timeout') 3557 3558 params = locals() 3559 for key, val in iteritems(params['kwargs']): 3560 if key not in all_params: 3561 raise TypeError( 3562 "Got an unexpected keyword argument '%s'" 3563 " to method delete_custom_fields" % key 3564 ) 3565 params[key] = val 3566 del params['kwargs'] 3567 # verify the required parameter 'account_id' is set 3568 if ('account_id' not in params) or (params['account_id'] is None): 3569 raise ValueError("Missing the required parameter `account_id` when calling `delete_custom_fields`") 3570 # verify the required parameter 'envelope_id' is set 3571 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3572 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_custom_fields`") 3573 3574 3575 collection_formats = {} 3576 3577 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/custom_fields'.replace('{format}', 'json') 3578 path_params = {} 3579 if 'account_id' in params: 3580 path_params['accountId'] = params['account_id'] 3581 if 'envelope_id' in params: 3582 path_params['envelopeId'] = params['envelope_id'] 3583 3584 query_params = {} 3585 3586 header_params = {} 3587 3588 form_params = [] 3589 local_var_files = {} 3590 3591 body_params = None 3592 if 'custom_fields' in params: 3593 body_params = params['custom_fields'] 3594 # HTTP header `Accept` 3595 header_params['Accept'] = self.api_client.\ 3596 select_header_accept(['application/json']) 3597 3598 # Authentication setting 3599 auth_settings = [] 3600 3601 return self.api_client.call_api(resource_path, 'DELETE', 3602 path_params, 3603 query_params, 3604 header_params, 3605 body=body_params, 3606 post_params=form_params, 3607 files=local_var_files, 3608 response_type='CustomFields', 3609 auth_settings=auth_settings, 3610 callback=params.get('callback'), 3611 _return_http_data_only=params.get('_return_http_data_only'), 3612 _preload_content=params.get('_preload_content', True), 3613 _request_timeout=params.get('_request_timeout'), 3614 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)
3616 def delete_document_fields(self, account_id, document_id, envelope_id, **kwargs): 3617 """ 3618 Deletes custom document fields from an existing envelope document. 3619 Deletes custom document fields from an existing envelope document. 3620 This method makes a synchronous HTTP request by default. To make an 3621 asynchronous HTTP request, please define a `callback` function 3622 to be invoked when receiving the response. 3623 >>> def callback_function(response): 3624 >>> pprint(response) 3625 >>> 3626 >>> thread = api.delete_document_fields(account_id, document_id, envelope_id, callback=callback_function) 3627 3628 :param callback function: The callback function 3629 for asynchronous request. (optional) 3630 :param str account_id: The external account number (int) or account ID Guid. (required) 3631 :param str document_id: The ID of the document being accessed. (required) 3632 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3633 :param DocumentFieldsInformation document_fields_information: 3634 :return: DocumentFieldsInformation 3635 If the method is called asynchronously, 3636 returns the request thread. 3637 """ 3638 kwargs['_return_http_data_only'] = True 3639 if kwargs.get('callback'): 3640 return self.delete_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 3641 else: 3642 (data) = self.delete_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 3643 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)
3645 def delete_document_fields_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 3646 """ 3647 Deletes custom document fields from an existing envelope document. 3648 Deletes custom document fields from an existing envelope document. 3649 This method makes a synchronous HTTP request by default. To make an 3650 asynchronous HTTP request, please define a `callback` function 3651 to be invoked when receiving the response. 3652 >>> def callback_function(response): 3653 >>> pprint(response) 3654 >>> 3655 >>> thread = api.delete_document_fields_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 3656 3657 :param callback function: The callback function 3658 for asynchronous request. (optional) 3659 :param str account_id: The external account number (int) or account ID Guid. (required) 3660 :param str document_id: The ID of the document being accessed. (required) 3661 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3662 :param DocumentFieldsInformation document_fields_information: 3663 :return: DocumentFieldsInformation 3664 If the method is called asynchronously, 3665 returns the request thread. 3666 """ 3667 3668 all_params = ['account_id', 'document_id', 'envelope_id', 'document_fields_information'] 3669 all_params.append('callback') 3670 all_params.append('_return_http_data_only') 3671 all_params.append('_preload_content') 3672 all_params.append('_request_timeout') 3673 3674 params = locals() 3675 for key, val in iteritems(params['kwargs']): 3676 if key not in all_params: 3677 raise TypeError( 3678 "Got an unexpected keyword argument '%s'" 3679 " to method delete_document_fields" % key 3680 ) 3681 params[key] = val 3682 del params['kwargs'] 3683 # verify the required parameter 'account_id' is set 3684 if ('account_id' not in params) or (params['account_id'] is None): 3685 raise ValueError("Missing the required parameter `account_id` when calling `delete_document_fields`") 3686 # verify the required parameter 'document_id' is set 3687 if ('document_id' not in params) or (params['document_id'] is None): 3688 raise ValueError("Missing the required parameter `document_id` when calling `delete_document_fields`") 3689 # verify the required parameter 'envelope_id' is set 3690 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3691 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_document_fields`") 3692 3693 3694 collection_formats = {} 3695 3696 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/fields'.replace('{format}', 'json') 3697 path_params = {} 3698 if 'account_id' in params: 3699 path_params['accountId'] = params['account_id'] 3700 if 'document_id' in params: 3701 path_params['documentId'] = params['document_id'] 3702 if 'envelope_id' in params: 3703 path_params['envelopeId'] = params['envelope_id'] 3704 3705 query_params = {} 3706 3707 header_params = {} 3708 3709 form_params = [] 3710 local_var_files = {} 3711 3712 body_params = None 3713 if 'document_fields_information' in params: 3714 body_params = params['document_fields_information'] 3715 # HTTP header `Accept` 3716 header_params['Accept'] = self.api_client.\ 3717 select_header_accept(['application/json']) 3718 3719 # Authentication setting 3720 auth_settings = [] 3721 3722 return self.api_client.call_api(resource_path, 'DELETE', 3723 path_params, 3724 query_params, 3725 header_params, 3726 body=body_params, 3727 post_params=form_params, 3728 files=local_var_files, 3729 response_type='DocumentFieldsInformation', 3730 auth_settings=auth_settings, 3731 callback=params.get('callback'), 3732 _return_http_data_only=params.get('_return_http_data_only'), 3733 _preload_content=params.get('_preload_content', True), 3734 _request_timeout=params.get('_request_timeout'), 3735 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)
3737 def delete_document_page(self, account_id, document_id, envelope_id, page_number, **kwargs): 3738 """ 3739 Deletes a page from a document in an envelope. 3740 Deletes a page from a document in an envelope based on the page number. 3741 This method makes a synchronous HTTP request by default. To make an 3742 asynchronous HTTP request, please define a `callback` function 3743 to be invoked when receiving the response. 3744 >>> def callback_function(response): 3745 >>> pprint(response) 3746 >>> 3747 >>> thread = api.delete_document_page(account_id, document_id, envelope_id, page_number, callback=callback_function) 3748 3749 :param callback function: The callback function 3750 for asynchronous request. (optional) 3751 :param str account_id: The external account number (int) or account ID Guid. (required) 3752 :param str document_id: The ID of the document being accessed. (required) 3753 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3754 :param str page_number: The page number being accessed. (required) 3755 :return: None 3756 If the method is called asynchronously, 3757 returns the request thread. 3758 """ 3759 kwargs['_return_http_data_only'] = True 3760 if kwargs.get('callback'): 3761 return self.delete_document_page_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 3762 else: 3763 (data) = self.delete_document_page_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 3764 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)
3766 def delete_document_page_with_http_info(self, account_id, document_id, envelope_id, page_number, **kwargs): 3767 """ 3768 Deletes a page from a document in an envelope. 3769 Deletes a page from a document in an envelope based on the page number. 3770 This method makes a synchronous HTTP request by default. To make an 3771 asynchronous HTTP request, please define a `callback` function 3772 to be invoked when receiving the response. 3773 >>> def callback_function(response): 3774 >>> pprint(response) 3775 >>> 3776 >>> thread = api.delete_document_page_with_http_info(account_id, document_id, envelope_id, page_number, callback=callback_function) 3777 3778 :param callback function: The callback function 3779 for asynchronous request. (optional) 3780 :param str account_id: The external account number (int) or account ID Guid. (required) 3781 :param str document_id: The ID of the document being accessed. (required) 3782 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3783 :param str page_number: The page number being accessed. (required) 3784 :return: None 3785 If the method is called asynchronously, 3786 returns the request thread. 3787 """ 3788 3789 all_params = ['account_id', 'document_id', 'envelope_id', 'page_number'] 3790 all_params.append('callback') 3791 all_params.append('_return_http_data_only') 3792 all_params.append('_preload_content') 3793 all_params.append('_request_timeout') 3794 3795 params = locals() 3796 for key, val in iteritems(params['kwargs']): 3797 if key not in all_params: 3798 raise TypeError( 3799 "Got an unexpected keyword argument '%s'" 3800 " to method delete_document_page" % key 3801 ) 3802 params[key] = val 3803 del params['kwargs'] 3804 # verify the required parameter 'account_id' is set 3805 if ('account_id' not in params) or (params['account_id'] is None): 3806 raise ValueError("Missing the required parameter `account_id` when calling `delete_document_page`") 3807 # verify the required parameter 'document_id' is set 3808 if ('document_id' not in params) or (params['document_id'] is None): 3809 raise ValueError("Missing the required parameter `document_id` when calling `delete_document_page`") 3810 # verify the required parameter 'envelope_id' is set 3811 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3812 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_document_page`") 3813 # verify the required parameter 'page_number' is set 3814 if ('page_number' not in params) or (params['page_number'] is None): 3815 raise ValueError("Missing the required parameter `page_number` when calling `delete_document_page`") 3816 3817 3818 collection_formats = {} 3819 3820 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/pages/{pageNumber}'.replace('{format}', 'json') 3821 path_params = {} 3822 if 'account_id' in params: 3823 path_params['accountId'] = params['account_id'] 3824 if 'document_id' in params: 3825 path_params['documentId'] = params['document_id'] 3826 if 'envelope_id' in params: 3827 path_params['envelopeId'] = params['envelope_id'] 3828 if 'page_number' in params: 3829 path_params['pageNumber'] = params['page_number'] 3830 3831 query_params = {} 3832 3833 header_params = {} 3834 3835 form_params = [] 3836 local_var_files = {} 3837 3838 body_params = None 3839 # HTTP header `Accept` 3840 header_params['Accept'] = self.api_client.\ 3841 select_header_accept(['application/json']) 3842 3843 # Authentication setting 3844 auth_settings = [] 3845 3846 return self.api_client.call_api(resource_path, 'DELETE', 3847 path_params, 3848 query_params, 3849 header_params, 3850 body=body_params, 3851 post_params=form_params, 3852 files=local_var_files, 3853 response_type=None, 3854 auth_settings=auth_settings, 3855 callback=params.get('callback'), 3856 _return_http_data_only=params.get('_return_http_data_only'), 3857 _preload_content=params.get('_preload_content', True), 3858 _request_timeout=params.get('_request_timeout'), 3859 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)
3861 def delete_document_tabs(self, account_id, document_id, envelope_id, **kwargs): 3862 """ 3863 Deletes tabs from an envelope document 3864 Deletes tabs from the document specified by `documentId` in the envelope specified by `envelopeId`. 3865 This method makes a synchronous HTTP request by default. To make an 3866 asynchronous HTTP request, please define a `callback` function 3867 to be invoked when receiving the response. 3868 >>> def callback_function(response): 3869 >>> pprint(response) 3870 >>> 3871 >>> thread = api.delete_document_tabs(account_id, document_id, envelope_id, callback=callback_function) 3872 3873 :param callback function: The callback function 3874 for asynchronous request. (optional) 3875 :param str account_id: The external account number (int) or account ID Guid. (required) 3876 :param str document_id: The ID of the document being accessed. (required) 3877 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3878 :param Tabs tabs: 3879 :return: Tabs 3880 If the method is called asynchronously, 3881 returns the request thread. 3882 """ 3883 kwargs['_return_http_data_only'] = True 3884 if kwargs.get('callback'): 3885 return self.delete_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 3886 else: 3887 (data) = self.delete_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 3888 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)
3890 def delete_document_tabs_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 3891 """ 3892 Deletes tabs from an envelope document 3893 Deletes tabs from the document specified by `documentId` in the envelope specified by `envelopeId`. 3894 This method makes a synchronous HTTP request by default. To make an 3895 asynchronous HTTP request, please define a `callback` function 3896 to be invoked when receiving the response. 3897 >>> def callback_function(response): 3898 >>> pprint(response) 3899 >>> 3900 >>> thread = api.delete_document_tabs_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 3901 3902 :param callback function: The callback function 3903 for asynchronous request. (optional) 3904 :param str account_id: The external account number (int) or account ID Guid. (required) 3905 :param str document_id: The ID of the document being accessed. (required) 3906 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3907 :param Tabs tabs: 3908 :return: Tabs 3909 If the method is called asynchronously, 3910 returns the request thread. 3911 """ 3912 3913 all_params = ['account_id', 'document_id', 'envelope_id', 'tabs'] 3914 all_params.append('callback') 3915 all_params.append('_return_http_data_only') 3916 all_params.append('_preload_content') 3917 all_params.append('_request_timeout') 3918 3919 params = locals() 3920 for key, val in iteritems(params['kwargs']): 3921 if key not in all_params: 3922 raise TypeError( 3923 "Got an unexpected keyword argument '%s'" 3924 " to method delete_document_tabs" % key 3925 ) 3926 params[key] = val 3927 del params['kwargs'] 3928 # verify the required parameter 'account_id' is set 3929 if ('account_id' not in params) or (params['account_id'] is None): 3930 raise ValueError("Missing the required parameter `account_id` when calling `delete_document_tabs`") 3931 # verify the required parameter 'document_id' is set 3932 if ('document_id' not in params) or (params['document_id'] is None): 3933 raise ValueError("Missing the required parameter `document_id` when calling `delete_document_tabs`") 3934 # verify the required parameter 'envelope_id' is set 3935 if ('envelope_id' not in params) or (params['envelope_id'] is None): 3936 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_document_tabs`") 3937 3938 3939 collection_formats = {} 3940 3941 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/tabs'.replace('{format}', 'json') 3942 path_params = {} 3943 if 'account_id' in params: 3944 path_params['accountId'] = params['account_id'] 3945 if 'document_id' in params: 3946 path_params['documentId'] = params['document_id'] 3947 if 'envelope_id' in params: 3948 path_params['envelopeId'] = params['envelope_id'] 3949 3950 query_params = {} 3951 3952 header_params = {} 3953 3954 form_params = [] 3955 local_var_files = {} 3956 3957 body_params = None 3958 if 'tabs' in params: 3959 body_params = params['tabs'] 3960 # HTTP header `Accept` 3961 header_params['Accept'] = self.api_client.\ 3962 select_header_accept(['application/json']) 3963 3964 # Authentication setting 3965 auth_settings = [] 3966 3967 return self.api_client.call_api(resource_path, 'DELETE', 3968 path_params, 3969 query_params, 3970 header_params, 3971 body=body_params, 3972 post_params=form_params, 3973 files=local_var_files, 3974 response_type='Tabs', 3975 auth_settings=auth_settings, 3976 callback=params.get('callback'), 3977 _return_http_data_only=params.get('_return_http_data_only'), 3978 _preload_content=params.get('_preload_content', True), 3979 _request_timeout=params.get('_request_timeout'), 3980 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)
3982 def delete_documents(self, account_id, envelope_id, **kwargs): 3983 """ 3984 Deletes documents from a draft envelope. 3985 Deletes one or more documents from an existing draft envelope. 3986 This method makes a synchronous HTTP request by default. To make an 3987 asynchronous HTTP request, please define a `callback` function 3988 to be invoked when receiving the response. 3989 >>> def callback_function(response): 3990 >>> pprint(response) 3991 >>> 3992 >>> thread = api.delete_documents(account_id, envelope_id, callback=callback_function) 3993 3994 :param callback function: The callback function 3995 for asynchronous request. (optional) 3996 :param str account_id: The external account number (int) or account ID Guid. (required) 3997 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 3998 :param EnvelopeDefinition envelope_definition: 3999 :return: EnvelopeDocumentsResult 4000 If the method is called asynchronously, 4001 returns the request thread. 4002 """ 4003 kwargs['_return_http_data_only'] = True 4004 if kwargs.get('callback'): 4005 return self.delete_documents_with_http_info(account_id, envelope_id, **kwargs) 4006 else: 4007 (data) = self.delete_documents_with_http_info(account_id, envelope_id, **kwargs) 4008 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)
4010 def delete_documents_with_http_info(self, account_id, envelope_id, **kwargs): 4011 """ 4012 Deletes documents from a draft envelope. 4013 Deletes one or more documents from an existing draft envelope. 4014 This method makes a synchronous HTTP request by default. To make an 4015 asynchronous HTTP request, please define a `callback` function 4016 to be invoked when receiving the response. 4017 >>> def callback_function(response): 4018 >>> pprint(response) 4019 >>> 4020 >>> thread = api.delete_documents_with_http_info(account_id, envelope_id, callback=callback_function) 4021 4022 :param callback function: The callback function 4023 for asynchronous request. (optional) 4024 :param str account_id: The external account number (int) or account ID Guid. (required) 4025 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4026 :param EnvelopeDefinition envelope_definition: 4027 :return: EnvelopeDocumentsResult 4028 If the method is called asynchronously, 4029 returns the request thread. 4030 """ 4031 4032 all_params = ['account_id', 'envelope_id', 'envelope_definition'] 4033 all_params.append('callback') 4034 all_params.append('_return_http_data_only') 4035 all_params.append('_preload_content') 4036 all_params.append('_request_timeout') 4037 4038 params = locals() 4039 for key, val in iteritems(params['kwargs']): 4040 if key not in all_params: 4041 raise TypeError( 4042 "Got an unexpected keyword argument '%s'" 4043 " to method delete_documents" % key 4044 ) 4045 params[key] = val 4046 del params['kwargs'] 4047 # verify the required parameter 'account_id' is set 4048 if ('account_id' not in params) or (params['account_id'] is None): 4049 raise ValueError("Missing the required parameter `account_id` when calling `delete_documents`") 4050 # verify the required parameter 'envelope_id' is set 4051 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4052 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_documents`") 4053 4054 4055 collection_formats = {} 4056 4057 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents'.replace('{format}', 'json') 4058 path_params = {} 4059 if 'account_id' in params: 4060 path_params['accountId'] = params['account_id'] 4061 if 'envelope_id' in params: 4062 path_params['envelopeId'] = params['envelope_id'] 4063 4064 query_params = {} 4065 4066 header_params = {} 4067 4068 form_params = [] 4069 local_var_files = {} 4070 4071 body_params = None 4072 if 'envelope_definition' in params: 4073 body_params = params['envelope_definition'] 4074 # HTTP header `Accept` 4075 header_params['Accept'] = self.api_client.\ 4076 select_header_accept(['application/json']) 4077 4078 # Authentication setting 4079 auth_settings = [] 4080 4081 return self.api_client.call_api(resource_path, 'DELETE', 4082 path_params, 4083 query_params, 4084 header_params, 4085 body=body_params, 4086 post_params=form_params, 4087 files=local_var_files, 4088 response_type='EnvelopeDocumentsResult', 4089 auth_settings=auth_settings, 4090 callback=params.get('callback'), 4091 _return_http_data_only=params.get('_return_http_data_only'), 4092 _preload_content=params.get('_preload_content', True), 4093 _request_timeout=params.get('_request_timeout'), 4094 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)
4096 def delete_email_settings(self, account_id, envelope_id, **kwargs): 4097 """ 4098 Deletes the email setting overrides for an envelope. 4099 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. 4100 This method makes a synchronous HTTP request by default. To make an 4101 asynchronous HTTP request, please define a `callback` function 4102 to be invoked when receiving the response. 4103 >>> def callback_function(response): 4104 >>> pprint(response) 4105 >>> 4106 >>> thread = api.delete_email_settings(account_id, envelope_id, callback=callback_function) 4107 4108 :param callback function: The callback function 4109 for asynchronous request. (optional) 4110 :param str account_id: The external account number (int) or account ID Guid. (required) 4111 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4112 :return: EmailSettings 4113 If the method is called asynchronously, 4114 returns the request thread. 4115 """ 4116 kwargs['_return_http_data_only'] = True 4117 if kwargs.get('callback'): 4118 return self.delete_email_settings_with_http_info(account_id, envelope_id, **kwargs) 4119 else: 4120 (data) = self.delete_email_settings_with_http_info(account_id, envelope_id, **kwargs) 4121 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)
4123 def delete_email_settings_with_http_info(self, account_id, envelope_id, **kwargs): 4124 """ 4125 Deletes the email setting overrides for an envelope. 4126 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. 4127 This method makes a synchronous HTTP request by default. To make an 4128 asynchronous HTTP request, please define a `callback` function 4129 to be invoked when receiving the response. 4130 >>> def callback_function(response): 4131 >>> pprint(response) 4132 >>> 4133 >>> thread = api.delete_email_settings_with_http_info(account_id, envelope_id, callback=callback_function) 4134 4135 :param callback function: The callback function 4136 for asynchronous request. (optional) 4137 :param str account_id: The external account number (int) or account ID Guid. (required) 4138 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4139 :return: EmailSettings 4140 If the method is called asynchronously, 4141 returns the request thread. 4142 """ 4143 4144 all_params = ['account_id', 'envelope_id'] 4145 all_params.append('callback') 4146 all_params.append('_return_http_data_only') 4147 all_params.append('_preload_content') 4148 all_params.append('_request_timeout') 4149 4150 params = locals() 4151 for key, val in iteritems(params['kwargs']): 4152 if key not in all_params: 4153 raise TypeError( 4154 "Got an unexpected keyword argument '%s'" 4155 " to method delete_email_settings" % key 4156 ) 4157 params[key] = val 4158 del params['kwargs'] 4159 # verify the required parameter 'account_id' is set 4160 if ('account_id' not in params) or (params['account_id'] is None): 4161 raise ValueError("Missing the required parameter `account_id` when calling `delete_email_settings`") 4162 # verify the required parameter 'envelope_id' is set 4163 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4164 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_email_settings`") 4165 4166 4167 collection_formats = {} 4168 4169 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/email_settings'.replace('{format}', 'json') 4170 path_params = {} 4171 if 'account_id' in params: 4172 path_params['accountId'] = params['account_id'] 4173 if 'envelope_id' in params: 4174 path_params['envelopeId'] = params['envelope_id'] 4175 4176 query_params = {} 4177 4178 header_params = {} 4179 4180 form_params = [] 4181 local_var_files = {} 4182 4183 body_params = None 4184 # HTTP header `Accept` 4185 header_params['Accept'] = self.api_client.\ 4186 select_header_accept(['application/json']) 4187 4188 # Authentication setting 4189 auth_settings = [] 4190 4191 return self.api_client.call_api(resource_path, 'DELETE', 4192 path_params, 4193 query_params, 4194 header_params, 4195 body=body_params, 4196 post_params=form_params, 4197 files=local_var_files, 4198 response_type='EmailSettings', 4199 auth_settings=auth_settings, 4200 callback=params.get('callback'), 4201 _return_http_data_only=params.get('_return_http_data_only'), 4202 _preload_content=params.get('_preload_content', True), 4203 _request_timeout=params.get('_request_timeout'), 4204 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)
4206 def delete_envelope_correct_view(self, account_id, envelope_id, **kwargs): 4207 """ 4208 Revokes the correction view URL to the Envelope UI 4209 Revokes the correction view URL to the Envelope UI. 4210 This method makes a synchronous HTTP request by default. To make an 4211 asynchronous HTTP request, please define a `callback` function 4212 to be invoked when receiving the response. 4213 >>> def callback_function(response): 4214 >>> pprint(response) 4215 >>> 4216 >>> thread = api.delete_envelope_correct_view(account_id, envelope_id, callback=callback_function) 4217 4218 :param callback function: The callback function 4219 for asynchronous request. (optional) 4220 :param str account_id: The external account number (int) or account ID Guid. (required) 4221 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4222 :param CorrectViewRequest correct_view_request: 4223 :return: None 4224 If the method is called asynchronously, 4225 returns the request thread. 4226 """ 4227 kwargs['_return_http_data_only'] = True 4228 if kwargs.get('callback'): 4229 return self.delete_envelope_correct_view_with_http_info(account_id, envelope_id, **kwargs) 4230 else: 4231 (data) = self.delete_envelope_correct_view_with_http_info(account_id, envelope_id, **kwargs) 4232 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)
4234 def delete_envelope_correct_view_with_http_info(self, account_id, envelope_id, **kwargs): 4235 """ 4236 Revokes the correction view URL to the Envelope UI 4237 Revokes the correction view URL to the Envelope UI. 4238 This method makes a synchronous HTTP request by default. To make an 4239 asynchronous HTTP request, please define a `callback` function 4240 to be invoked when receiving the response. 4241 >>> def callback_function(response): 4242 >>> pprint(response) 4243 >>> 4244 >>> thread = api.delete_envelope_correct_view_with_http_info(account_id, envelope_id, callback=callback_function) 4245 4246 :param callback function: The callback function 4247 for asynchronous request. (optional) 4248 :param str account_id: The external account number (int) or account ID Guid. (required) 4249 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4250 :param CorrectViewRequest correct_view_request: 4251 :return: None 4252 If the method is called asynchronously, 4253 returns the request thread. 4254 """ 4255 4256 all_params = ['account_id', 'envelope_id', 'correct_view_request'] 4257 all_params.append('callback') 4258 all_params.append('_return_http_data_only') 4259 all_params.append('_preload_content') 4260 all_params.append('_request_timeout') 4261 4262 params = locals() 4263 for key, val in iteritems(params['kwargs']): 4264 if key not in all_params: 4265 raise TypeError( 4266 "Got an unexpected keyword argument '%s'" 4267 " to method delete_envelope_correct_view" % key 4268 ) 4269 params[key] = val 4270 del params['kwargs'] 4271 # verify the required parameter 'account_id' is set 4272 if ('account_id' not in params) or (params['account_id'] is None): 4273 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_correct_view`") 4274 # verify the required parameter 'envelope_id' is set 4275 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4276 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_envelope_correct_view`") 4277 4278 4279 collection_formats = {} 4280 4281 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/correct'.replace('{format}', 'json') 4282 path_params = {} 4283 if 'account_id' in params: 4284 path_params['accountId'] = params['account_id'] 4285 if 'envelope_id' in params: 4286 path_params['envelopeId'] = params['envelope_id'] 4287 4288 query_params = {} 4289 4290 header_params = {} 4291 4292 form_params = [] 4293 local_var_files = {} 4294 4295 body_params = None 4296 if 'correct_view_request' in params: 4297 body_params = params['correct_view_request'] 4298 # HTTP header `Accept` 4299 header_params['Accept'] = self.api_client.\ 4300 select_header_accept(['application/json']) 4301 4302 # Authentication setting 4303 auth_settings = [] 4304 4305 return self.api_client.call_api(resource_path, 'DELETE', 4306 path_params, 4307 query_params, 4308 header_params, 4309 body=body_params, 4310 post_params=form_params, 4311 files=local_var_files, 4312 response_type=None, 4313 auth_settings=auth_settings, 4314 callback=params.get('callback'), 4315 _return_http_data_only=params.get('_return_http_data_only'), 4316 _preload_content=params.get('_preload_content', True), 4317 _request_timeout=params.get('_request_timeout'), 4318 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)
4320 def delete_envelope_delayed_routing_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 4321 """ 4322 Deletes the delayed routing rules for the specified envelope workflow step. 4323 This method makes a synchronous HTTP request by default. To make an 4324 asynchronous HTTP request, please define a `callback` function 4325 to be invoked when receiving the response. 4326 >>> def callback_function(response): 4327 >>> pprint(response) 4328 >>> 4329 >>> thread = api.delete_envelope_delayed_routing_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 4330 4331 :param callback function: The callback function 4332 for asynchronous request. (optional) 4333 :param str account_id: The external account number (int) or account ID Guid. (required) 4334 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4335 :param str workflow_step_id: (required) 4336 :return: None 4337 If the method is called asynchronously, 4338 returns the request thread. 4339 """ 4340 kwargs['_return_http_data_only'] = True 4341 if kwargs.get('callback'): 4342 return self.delete_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 4343 else: 4344 (data) = self.delete_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 4345 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)
4347 def delete_envelope_delayed_routing_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 4348 """ 4349 Deletes the delayed routing rules for the specified envelope workflow step. 4350 This method makes a synchronous HTTP request by default. To make an 4351 asynchronous HTTP request, please define a `callback` function 4352 to be invoked when receiving the response. 4353 >>> def callback_function(response): 4354 >>> pprint(response) 4355 >>> 4356 >>> thread = api.delete_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 4357 4358 :param callback function: The callback function 4359 for asynchronous request. (optional) 4360 :param str account_id: The external account number (int) or account ID Guid. (required) 4361 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4362 :param str workflow_step_id: (required) 4363 :return: None 4364 If the method is called asynchronously, 4365 returns the request thread. 4366 """ 4367 4368 all_params = ['account_id', 'envelope_id', 'workflow_step_id'] 4369 all_params.append('callback') 4370 all_params.append('_return_http_data_only') 4371 all_params.append('_preload_content') 4372 all_params.append('_request_timeout') 4373 4374 params = locals() 4375 for key, val in iteritems(params['kwargs']): 4376 if key not in all_params: 4377 raise TypeError( 4378 "Got an unexpected keyword argument '%s'" 4379 " to method delete_envelope_delayed_routing_definition" % key 4380 ) 4381 params[key] = val 4382 del params['kwargs'] 4383 # verify the required parameter 'account_id' is set 4384 if ('account_id' not in params) or (params['account_id'] is None): 4385 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_delayed_routing_definition`") 4386 # verify the required parameter 'envelope_id' is set 4387 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4388 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_envelope_delayed_routing_definition`") 4389 # verify the required parameter 'workflow_step_id' is set 4390 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 4391 raise ValueError("Missing the required parameter `workflow_step_id` when calling `delete_envelope_delayed_routing_definition`") 4392 4393 4394 collection_formats = {} 4395 4396 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 4397 path_params = {} 4398 if 'account_id' in params: 4399 path_params['accountId'] = params['account_id'] 4400 if 'envelope_id' in params: 4401 path_params['envelopeId'] = params['envelope_id'] 4402 if 'workflow_step_id' in params: 4403 path_params['workflowStepId'] = params['workflow_step_id'] 4404 4405 query_params = {} 4406 4407 header_params = {} 4408 4409 form_params = [] 4410 local_var_files = {} 4411 4412 body_params = None 4413 # HTTP header `Accept` 4414 header_params['Accept'] = self.api_client.\ 4415 select_header_accept(['application/json']) 4416 4417 # Authentication setting 4418 auth_settings = [] 4419 4420 return self.api_client.call_api(resource_path, 'DELETE', 4421 path_params, 4422 query_params, 4423 header_params, 4424 body=body_params, 4425 post_params=form_params, 4426 files=local_var_files, 4427 response_type=None, 4428 auth_settings=auth_settings, 4429 callback=params.get('callback'), 4430 _return_http_data_only=params.get('_return_http_data_only'), 4431 _preload_content=params.get('_preload_content', True), 4432 _request_timeout=params.get('_request_timeout'), 4433 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)
4435 def delete_envelope_scheduled_sending_definition(self, account_id, envelope_id, **kwargs): 4436 """ 4437 Deletes the scheduled sending rules for the envelope's workflow. 4438 This method makes a synchronous HTTP request by default. To make an 4439 asynchronous HTTP request, please define a `callback` function 4440 to be invoked when receiving the response. 4441 >>> def callback_function(response): 4442 >>> pprint(response) 4443 >>> 4444 >>> thread = api.delete_envelope_scheduled_sending_definition(account_id, envelope_id, callback=callback_function) 4445 4446 :param callback function: The callback function 4447 for asynchronous request. (optional) 4448 :param str account_id: The external account number (int) or account ID Guid. (required) 4449 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4450 :return: None 4451 If the method is called asynchronously, 4452 returns the request thread. 4453 """ 4454 kwargs['_return_http_data_only'] = True 4455 if kwargs.get('callback'): 4456 return self.delete_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 4457 else: 4458 (data) = self.delete_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 4459 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)
4461 def delete_envelope_scheduled_sending_definition_with_http_info(self, account_id, envelope_id, **kwargs): 4462 """ 4463 Deletes the scheduled sending rules for the envelope's workflow. 4464 This method makes a synchronous HTTP request by default. To make an 4465 asynchronous HTTP request, please define a `callback` function 4466 to be invoked when receiving the response. 4467 >>> def callback_function(response): 4468 >>> pprint(response) 4469 >>> 4470 >>> thread = api.delete_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, callback=callback_function) 4471 4472 :param callback function: The callback function 4473 for asynchronous request. (optional) 4474 :param str account_id: The external account number (int) or account ID Guid. (required) 4475 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4476 :return: None 4477 If the method is called asynchronously, 4478 returns the request thread. 4479 """ 4480 4481 all_params = ['account_id', 'envelope_id'] 4482 all_params.append('callback') 4483 all_params.append('_return_http_data_only') 4484 all_params.append('_preload_content') 4485 all_params.append('_request_timeout') 4486 4487 params = locals() 4488 for key, val in iteritems(params['kwargs']): 4489 if key not in all_params: 4490 raise TypeError( 4491 "Got an unexpected keyword argument '%s'" 4492 " to method delete_envelope_scheduled_sending_definition" % key 4493 ) 4494 params[key] = val 4495 del params['kwargs'] 4496 # verify the required parameter 'account_id' is set 4497 if ('account_id' not in params) or (params['account_id'] is None): 4498 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_scheduled_sending_definition`") 4499 # verify the required parameter 'envelope_id' is set 4500 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4501 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_envelope_scheduled_sending_definition`") 4502 4503 4504 collection_formats = {} 4505 4506 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/scheduledSending'.replace('{format}', 'json') 4507 path_params = {} 4508 if 'account_id' in params: 4509 path_params['accountId'] = params['account_id'] 4510 if 'envelope_id' in params: 4511 path_params['envelopeId'] = params['envelope_id'] 4512 4513 query_params = {} 4514 4515 header_params = {} 4516 4517 form_params = [] 4518 local_var_files = {} 4519 4520 body_params = None 4521 # HTTP header `Accept` 4522 header_params['Accept'] = self.api_client.\ 4523 select_header_accept(['application/json']) 4524 4525 # Authentication setting 4526 auth_settings = [] 4527 4528 return self.api_client.call_api(resource_path, 'DELETE', 4529 path_params, 4530 query_params, 4531 header_params, 4532 body=body_params, 4533 post_params=form_params, 4534 files=local_var_files, 4535 response_type=None, 4536 auth_settings=auth_settings, 4537 callback=params.get('callback'), 4538 _return_http_data_only=params.get('_return_http_data_only'), 4539 _preload_content=params.get('_preload_content', True), 4540 _request_timeout=params.get('_request_timeout'), 4541 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)
4543 def delete_envelope_transfer_rules(self, account_id, envelope_transfer_rule_id, **kwargs): 4544 """ 4545 Delete envelope transfer rules for an account. 4546 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. 4547 This method makes a synchronous HTTP request by default. To make an 4548 asynchronous HTTP request, please define a `callback` function 4549 to be invoked when receiving the response. 4550 >>> def callback_function(response): 4551 >>> pprint(response) 4552 >>> 4553 >>> thread = api.delete_envelope_transfer_rules(account_id, envelope_transfer_rule_id, callback=callback_function) 4554 4555 :param callback function: The callback function 4556 for asynchronous request. (optional) 4557 :param str account_id: The external account number (int) or account ID Guid. (required) 4558 :param str envelope_transfer_rule_id: (required) 4559 :return: None 4560 If the method is called asynchronously, 4561 returns the request thread. 4562 """ 4563 kwargs['_return_http_data_only'] = True 4564 if kwargs.get('callback'): 4565 return self.delete_envelope_transfer_rules_with_http_info(account_id, envelope_transfer_rule_id, **kwargs) 4566 else: 4567 (data) = self.delete_envelope_transfer_rules_with_http_info(account_id, envelope_transfer_rule_id, **kwargs) 4568 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)
4570 def delete_envelope_transfer_rules_with_http_info(self, account_id, envelope_transfer_rule_id, **kwargs): 4571 """ 4572 Delete envelope transfer rules for an account. 4573 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. 4574 This method makes a synchronous HTTP request by default. To make an 4575 asynchronous HTTP request, please define a `callback` function 4576 to be invoked when receiving the response. 4577 >>> def callback_function(response): 4578 >>> pprint(response) 4579 >>> 4580 >>> thread = api.delete_envelope_transfer_rules_with_http_info(account_id, envelope_transfer_rule_id, callback=callback_function) 4581 4582 :param callback function: The callback function 4583 for asynchronous request. (optional) 4584 :param str account_id: The external account number (int) or account ID Guid. (required) 4585 :param str envelope_transfer_rule_id: (required) 4586 :return: None 4587 If the method is called asynchronously, 4588 returns the request thread. 4589 """ 4590 4591 all_params = ['account_id', 'envelope_transfer_rule_id'] 4592 all_params.append('callback') 4593 all_params.append('_return_http_data_only') 4594 all_params.append('_preload_content') 4595 all_params.append('_request_timeout') 4596 4597 params = locals() 4598 for key, val in iteritems(params['kwargs']): 4599 if key not in all_params: 4600 raise TypeError( 4601 "Got an unexpected keyword argument '%s'" 4602 " to method delete_envelope_transfer_rules" % key 4603 ) 4604 params[key] = val 4605 del params['kwargs'] 4606 # verify the required parameter 'account_id' is set 4607 if ('account_id' not in params) or (params['account_id'] is None): 4608 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_transfer_rules`") 4609 # verify the required parameter 'envelope_transfer_rule_id' is set 4610 if ('envelope_transfer_rule_id' not in params) or (params['envelope_transfer_rule_id'] is None): 4611 raise ValueError("Missing the required parameter `envelope_transfer_rule_id` when calling `delete_envelope_transfer_rules`") 4612 4613 4614 collection_formats = {} 4615 4616 resource_path = '/v2.1/accounts/{accountId}/envelopes/transfer_rules/{envelopeTransferRuleId}'.replace('{format}', 'json') 4617 path_params = {} 4618 if 'account_id' in params: 4619 path_params['accountId'] = params['account_id'] 4620 if 'envelope_transfer_rule_id' in params: 4621 path_params['envelopeTransferRuleId'] = params['envelope_transfer_rule_id'] 4622 4623 query_params = {} 4624 4625 header_params = {} 4626 4627 form_params = [] 4628 local_var_files = {} 4629 4630 body_params = None 4631 # HTTP header `Accept` 4632 header_params['Accept'] = self.api_client.\ 4633 select_header_accept(['application/json']) 4634 4635 # Authentication setting 4636 auth_settings = [] 4637 4638 return self.api_client.call_api(resource_path, 'DELETE', 4639 path_params, 4640 query_params, 4641 header_params, 4642 body=body_params, 4643 post_params=form_params, 4644 files=local_var_files, 4645 response_type=None, 4646 auth_settings=auth_settings, 4647 callback=params.get('callback'), 4648 _return_http_data_only=params.get('_return_http_data_only'), 4649 _preload_content=params.get('_preload_content', True), 4650 _request_timeout=params.get('_request_timeout'), 4651 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)
4653 def delete_envelope_workflow_definition(self, account_id, envelope_id, **kwargs): 4654 """ 4655 Delete the workflow definition for an envelope. 4656 Deletes the specified envelope's workflow definition if it has one. 4657 This method makes a synchronous HTTP request by default. To make an 4658 asynchronous HTTP request, please define a `callback` function 4659 to be invoked when receiving the response. 4660 >>> def callback_function(response): 4661 >>> pprint(response) 4662 >>> 4663 >>> thread = api.delete_envelope_workflow_definition(account_id, envelope_id, callback=callback_function) 4664 4665 :param callback function: The callback function 4666 for asynchronous request. (optional) 4667 :param str account_id: The external account number (int) or account ID Guid. (required) 4668 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4669 :return: None 4670 If the method is called asynchronously, 4671 returns the request thread. 4672 """ 4673 kwargs['_return_http_data_only'] = True 4674 if kwargs.get('callback'): 4675 return self.delete_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 4676 else: 4677 (data) = self.delete_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 4678 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)
4680 def delete_envelope_workflow_definition_with_http_info(self, account_id, envelope_id, **kwargs): 4681 """ 4682 Delete the workflow definition for an envelope. 4683 Deletes the specified envelope's workflow definition if it has one. 4684 This method makes a synchronous HTTP request by default. To make an 4685 asynchronous HTTP request, please define a `callback` function 4686 to be invoked when receiving the response. 4687 >>> def callback_function(response): 4688 >>> pprint(response) 4689 >>> 4690 >>> thread = api.delete_envelope_workflow_definition_with_http_info(account_id, envelope_id, callback=callback_function) 4691 4692 :param callback function: The callback function 4693 for asynchronous request. (optional) 4694 :param str account_id: The external account number (int) or account ID Guid. (required) 4695 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4696 :return: None 4697 If the method is called asynchronously, 4698 returns the request thread. 4699 """ 4700 4701 all_params = ['account_id', 'envelope_id'] 4702 all_params.append('callback') 4703 all_params.append('_return_http_data_only') 4704 all_params.append('_preload_content') 4705 all_params.append('_request_timeout') 4706 4707 params = locals() 4708 for key, val in iteritems(params['kwargs']): 4709 if key not in all_params: 4710 raise TypeError( 4711 "Got an unexpected keyword argument '%s'" 4712 " to method delete_envelope_workflow_definition" % key 4713 ) 4714 params[key] = val 4715 del params['kwargs'] 4716 # verify the required parameter 'account_id' is set 4717 if ('account_id' not in params) or (params['account_id'] is None): 4718 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_workflow_definition`") 4719 # verify the required parameter 'envelope_id' is set 4720 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4721 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_envelope_workflow_definition`") 4722 4723 4724 collection_formats = {} 4725 4726 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow'.replace('{format}', 'json') 4727 path_params = {} 4728 if 'account_id' in params: 4729 path_params['accountId'] = params['account_id'] 4730 if 'envelope_id' in params: 4731 path_params['envelopeId'] = params['envelope_id'] 4732 4733 query_params = {} 4734 4735 header_params = {} 4736 4737 form_params = [] 4738 local_var_files = {} 4739 4740 body_params = None 4741 # HTTP header `Accept` 4742 header_params['Accept'] = self.api_client.\ 4743 select_header_accept(['application/json']) 4744 4745 # Authentication setting 4746 auth_settings = [] 4747 4748 return self.api_client.call_api(resource_path, 'DELETE', 4749 path_params, 4750 query_params, 4751 header_params, 4752 body=body_params, 4753 post_params=form_params, 4754 files=local_var_files, 4755 response_type=None, 4756 auth_settings=auth_settings, 4757 callback=params.get('callback'), 4758 _return_http_data_only=params.get('_return_http_data_only'), 4759 _preload_content=params.get('_preload_content', True), 4760 _request_timeout=params.get('_request_timeout'), 4761 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)
4763 def delete_envelope_workflow_step_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 4764 """ 4765 Deletes the envelope workflow step definition for an envelope's workflow by step id. 4766 This method makes a synchronous HTTP request by default. To make an 4767 asynchronous HTTP request, please define a `callback` function 4768 to be invoked when receiving the response. 4769 >>> def callback_function(response): 4770 >>> pprint(response) 4771 >>> 4772 >>> thread = api.delete_envelope_workflow_step_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 4773 4774 :param callback function: The callback function 4775 for asynchronous request. (optional) 4776 :param str account_id: The external account number (int) or account ID Guid. (required) 4777 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4778 :param str workflow_step_id: (required) 4779 :return: None 4780 If the method is called asynchronously, 4781 returns the request thread. 4782 """ 4783 kwargs['_return_http_data_only'] = True 4784 if kwargs.get('callback'): 4785 return self.delete_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 4786 else: 4787 (data) = self.delete_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 4788 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)
4790 def delete_envelope_workflow_step_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 4791 """ 4792 Deletes the envelope workflow step definition for an envelope's workflow by step id. 4793 This method makes a synchronous HTTP request by default. To make an 4794 asynchronous HTTP request, please define a `callback` function 4795 to be invoked when receiving the response. 4796 >>> def callback_function(response): 4797 >>> pprint(response) 4798 >>> 4799 >>> thread = api.delete_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 4800 4801 :param callback function: The callback function 4802 for asynchronous request. (optional) 4803 :param str account_id: The external account number (int) or account ID Guid. (required) 4804 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4805 :param str workflow_step_id: (required) 4806 :return: None 4807 If the method is called asynchronously, 4808 returns the request thread. 4809 """ 4810 4811 all_params = ['account_id', 'envelope_id', 'workflow_step_id'] 4812 all_params.append('callback') 4813 all_params.append('_return_http_data_only') 4814 all_params.append('_preload_content') 4815 all_params.append('_request_timeout') 4816 4817 params = locals() 4818 for key, val in iteritems(params['kwargs']): 4819 if key not in all_params: 4820 raise TypeError( 4821 "Got an unexpected keyword argument '%s'" 4822 " to method delete_envelope_workflow_step_definition" % key 4823 ) 4824 params[key] = val 4825 del params['kwargs'] 4826 # verify the required parameter 'account_id' is set 4827 if ('account_id' not in params) or (params['account_id'] is None): 4828 raise ValueError("Missing the required parameter `account_id` when calling `delete_envelope_workflow_step_definition`") 4829 # verify the required parameter 'envelope_id' is set 4830 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4831 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_envelope_workflow_step_definition`") 4832 # verify the required parameter 'workflow_step_id' is set 4833 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 4834 raise ValueError("Missing the required parameter `workflow_step_id` when calling `delete_envelope_workflow_step_definition`") 4835 4836 4837 collection_formats = {} 4838 4839 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 4840 path_params = {} 4841 if 'account_id' in params: 4842 path_params['accountId'] = params['account_id'] 4843 if 'envelope_id' in params: 4844 path_params['envelopeId'] = params['envelope_id'] 4845 if 'workflow_step_id' in params: 4846 path_params['workflowStepId'] = params['workflow_step_id'] 4847 4848 query_params = {} 4849 4850 header_params = {} 4851 4852 form_params = [] 4853 local_var_files = {} 4854 4855 body_params = None 4856 # HTTP header `Accept` 4857 header_params['Accept'] = self.api_client.\ 4858 select_header_accept(['application/json']) 4859 4860 # Authentication setting 4861 auth_settings = [] 4862 4863 return self.api_client.call_api(resource_path, 'DELETE', 4864 path_params, 4865 query_params, 4866 header_params, 4867 body=body_params, 4868 post_params=form_params, 4869 files=local_var_files, 4870 response_type=None, 4871 auth_settings=auth_settings, 4872 callback=params.get('callback'), 4873 _return_http_data_only=params.get('_return_http_data_only'), 4874 _preload_content=params.get('_preload_content', True), 4875 _request_timeout=params.get('_request_timeout'), 4876 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)
4878 def delete_lock(self, account_id, envelope_id, **kwargs): 4879 """ 4880 Deletes an envelope lock. 4881 Deletes the lock from the specified envelope. The `X-DocuSign-Edit` header must be included in the request. 4882 This method makes a synchronous HTTP request by default. To make an 4883 asynchronous HTTP request, please define a `callback` function 4884 to be invoked when receiving the response. 4885 >>> def callback_function(response): 4886 >>> pprint(response) 4887 >>> 4888 >>> thread = api.delete_lock(account_id, envelope_id, callback=callback_function) 4889 4890 :param callback function: The callback function 4891 for asynchronous request. (optional) 4892 :param str account_id: The external account number (int) or account ID Guid. (required) 4893 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4894 :return: LockInformation 4895 If the method is called asynchronously, 4896 returns the request thread. 4897 """ 4898 kwargs['_return_http_data_only'] = True 4899 if kwargs.get('callback'): 4900 return self.delete_lock_with_http_info(account_id, envelope_id, **kwargs) 4901 else: 4902 (data) = self.delete_lock_with_http_info(account_id, envelope_id, **kwargs) 4903 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)
4905 def delete_lock_with_http_info(self, account_id, envelope_id, **kwargs): 4906 """ 4907 Deletes an envelope lock. 4908 Deletes the lock from the specified envelope. The `X-DocuSign-Edit` header must be included in the request. 4909 This method makes a synchronous HTTP request by default. To make an 4910 asynchronous HTTP request, please define a `callback` function 4911 to be invoked when receiving the response. 4912 >>> def callback_function(response): 4913 >>> pprint(response) 4914 >>> 4915 >>> thread = api.delete_lock_with_http_info(account_id, envelope_id, callback=callback_function) 4916 4917 :param callback function: The callback function 4918 for asynchronous request. (optional) 4919 :param str account_id: The external account number (int) or account ID Guid. (required) 4920 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 4921 :return: LockInformation 4922 If the method is called asynchronously, 4923 returns the request thread. 4924 """ 4925 4926 all_params = ['account_id', 'envelope_id'] 4927 all_params.append('callback') 4928 all_params.append('_return_http_data_only') 4929 all_params.append('_preload_content') 4930 all_params.append('_request_timeout') 4931 4932 params = locals() 4933 for key, val in iteritems(params['kwargs']): 4934 if key not in all_params: 4935 raise TypeError( 4936 "Got an unexpected keyword argument '%s'" 4937 " to method delete_lock" % key 4938 ) 4939 params[key] = val 4940 del params['kwargs'] 4941 # verify the required parameter 'account_id' is set 4942 if ('account_id' not in params) or (params['account_id'] is None): 4943 raise ValueError("Missing the required parameter `account_id` when calling `delete_lock`") 4944 # verify the required parameter 'envelope_id' is set 4945 if ('envelope_id' not in params) or (params['envelope_id'] is None): 4946 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_lock`") 4947 4948 4949 collection_formats = {} 4950 4951 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/lock'.replace('{format}', 'json') 4952 path_params = {} 4953 if 'account_id' in params: 4954 path_params['accountId'] = params['account_id'] 4955 if 'envelope_id' in params: 4956 path_params['envelopeId'] = params['envelope_id'] 4957 4958 query_params = {} 4959 4960 header_params = {} 4961 4962 form_params = [] 4963 local_var_files = {} 4964 4965 body_params = None 4966 # HTTP header `Accept` 4967 header_params['Accept'] = self.api_client.\ 4968 select_header_accept(['application/json']) 4969 4970 # Authentication setting 4971 auth_settings = [] 4972 4973 return self.api_client.call_api(resource_path, 'DELETE', 4974 path_params, 4975 query_params, 4976 header_params, 4977 body=body_params, 4978 post_params=form_params, 4979 files=local_var_files, 4980 response_type='LockInformation', 4981 auth_settings=auth_settings, 4982 callback=params.get('callback'), 4983 _return_http_data_only=params.get('_return_http_data_only'), 4984 _preload_content=params.get('_preload_content', True), 4985 _request_timeout=params.get('_request_timeout'), 4986 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)
4988 def delete_recipient(self, account_id, envelope_id, recipient_id, **kwargs): 4989 """ 4990 Deletes a recipient from an envelope. 4991 Deletes the specified recipient file from the specified envelope. This cannot be used if the envelope has been sent. 4992 This method makes a synchronous HTTP request by default. To make an 4993 asynchronous HTTP request, please define a `callback` function 4994 to be invoked when receiving the response. 4995 >>> def callback_function(response): 4996 >>> pprint(response) 4997 >>> 4998 >>> thread = api.delete_recipient(account_id, envelope_id, recipient_id, callback=callback_function) 4999 5000 :param callback function: The callback function 5001 for asynchronous request. (optional) 5002 :param str account_id: The external account number (int) or account ID Guid. (required) 5003 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5004 :param str recipient_id: The ID of the recipient being accessed. (required) 5005 :return: Recipients 5006 If the method is called asynchronously, 5007 returns the request thread. 5008 """ 5009 kwargs['_return_http_data_only'] = True 5010 if kwargs.get('callback'): 5011 return self.delete_recipient_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 5012 else: 5013 (data) = self.delete_recipient_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 5014 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)
5016 def delete_recipient_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 5017 """ 5018 Deletes a recipient from an envelope. 5019 Deletes the specified recipient file from the specified envelope. This cannot be used if the envelope has been sent. 5020 This method makes a synchronous HTTP request by default. To make an 5021 asynchronous HTTP request, please define a `callback` function 5022 to be invoked when receiving the response. 5023 >>> def callback_function(response): 5024 >>> pprint(response) 5025 >>> 5026 >>> thread = api.delete_recipient_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 5027 5028 :param callback function: The callback function 5029 for asynchronous request. (optional) 5030 :param str account_id: The external account number (int) or account ID Guid. (required) 5031 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5032 :param str recipient_id: The ID of the recipient being accessed. (required) 5033 :return: Recipients 5034 If the method is called asynchronously, 5035 returns the request thread. 5036 """ 5037 5038 all_params = ['account_id', 'envelope_id', 'recipient_id'] 5039 all_params.append('callback') 5040 all_params.append('_return_http_data_only') 5041 all_params.append('_preload_content') 5042 all_params.append('_request_timeout') 5043 5044 params = locals() 5045 for key, val in iteritems(params['kwargs']): 5046 if key not in all_params: 5047 raise TypeError( 5048 "Got an unexpected keyword argument '%s'" 5049 " to method delete_recipient" % key 5050 ) 5051 params[key] = val 5052 del params['kwargs'] 5053 # verify the required parameter 'account_id' is set 5054 if ('account_id' not in params) or (params['account_id'] is None): 5055 raise ValueError("Missing the required parameter `account_id` when calling `delete_recipient`") 5056 # verify the required parameter 'envelope_id' is set 5057 if ('envelope_id' not in params) or (params['envelope_id'] is None): 5058 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_recipient`") 5059 # verify the required parameter 'recipient_id' is set 5060 if ('recipient_id' not in params) or (params['recipient_id'] is None): 5061 raise ValueError("Missing the required parameter `recipient_id` when calling `delete_recipient`") 5062 5063 5064 collection_formats = {} 5065 5066 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}'.replace('{format}', 'json') 5067 path_params = {} 5068 if 'account_id' in params: 5069 path_params['accountId'] = params['account_id'] 5070 if 'envelope_id' in params: 5071 path_params['envelopeId'] = params['envelope_id'] 5072 if 'recipient_id' in params: 5073 path_params['recipientId'] = params['recipient_id'] 5074 5075 query_params = {} 5076 5077 header_params = {} 5078 5079 form_params = [] 5080 local_var_files = {} 5081 5082 body_params = None 5083 # HTTP header `Accept` 5084 header_params['Accept'] = self.api_client.\ 5085 select_header_accept(['application/json']) 5086 5087 # Authentication setting 5088 auth_settings = [] 5089 5090 return self.api_client.call_api(resource_path, 'DELETE', 5091 path_params, 5092 query_params, 5093 header_params, 5094 body=body_params, 5095 post_params=form_params, 5096 files=local_var_files, 5097 response_type='Recipients', 5098 auth_settings=auth_settings, 5099 callback=params.get('callback'), 5100 _return_http_data_only=params.get('_return_http_data_only'), 5101 _preload_content=params.get('_preload_content', True), 5102 _request_timeout=params.get('_request_timeout'), 5103 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)
5105 def delete_recipients(self, account_id, envelope_id, **kwargs): 5106 """ 5107 Deletes recipients from an envelope. 5108 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. 5109 This method makes a synchronous HTTP request by default. To make an 5110 asynchronous HTTP request, please define a `callback` function 5111 to be invoked when receiving the response. 5112 >>> def callback_function(response): 5113 >>> pprint(response) 5114 >>> 5115 >>> thread = api.delete_recipients(account_id, envelope_id, callback=callback_function) 5116 5117 :param callback function: The callback function 5118 for asynchronous request. (optional) 5119 :param str account_id: The external account number (int) or account ID Guid. (required) 5120 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5121 :param Recipients recipients: 5122 :return: Recipients 5123 If the method is called asynchronously, 5124 returns the request thread. 5125 """ 5126 kwargs['_return_http_data_only'] = True 5127 if kwargs.get('callback'): 5128 return self.delete_recipients_with_http_info(account_id, envelope_id, **kwargs) 5129 else: 5130 (data) = self.delete_recipients_with_http_info(account_id, envelope_id, **kwargs) 5131 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)
5133 def delete_recipients_with_http_info(self, account_id, envelope_id, **kwargs): 5134 """ 5135 Deletes recipients from an envelope. 5136 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. 5137 This method makes a synchronous HTTP request by default. To make an 5138 asynchronous HTTP request, please define a `callback` function 5139 to be invoked when receiving the response. 5140 >>> def callback_function(response): 5141 >>> pprint(response) 5142 >>> 5143 >>> thread = api.delete_recipients_with_http_info(account_id, envelope_id, callback=callback_function) 5144 5145 :param callback function: The callback function 5146 for asynchronous request. (optional) 5147 :param str account_id: The external account number (int) or account ID Guid. (required) 5148 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5149 :param Recipients recipients: 5150 :return: Recipients 5151 If the method is called asynchronously, 5152 returns the request thread. 5153 """ 5154 5155 all_params = ['account_id', 'envelope_id', 'recipients'] 5156 all_params.append('callback') 5157 all_params.append('_return_http_data_only') 5158 all_params.append('_preload_content') 5159 all_params.append('_request_timeout') 5160 5161 params = locals() 5162 for key, val in iteritems(params['kwargs']): 5163 if key not in all_params: 5164 raise TypeError( 5165 "Got an unexpected keyword argument '%s'" 5166 " to method delete_recipients" % key 5167 ) 5168 params[key] = val 5169 del params['kwargs'] 5170 # verify the required parameter 'account_id' is set 5171 if ('account_id' not in params) or (params['account_id'] is None): 5172 raise ValueError("Missing the required parameter `account_id` when calling `delete_recipients`") 5173 # verify the required parameter 'envelope_id' is set 5174 if ('envelope_id' not in params) or (params['envelope_id'] is None): 5175 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_recipients`") 5176 5177 5178 collection_formats = {} 5179 5180 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients'.replace('{format}', 'json') 5181 path_params = {} 5182 if 'account_id' in params: 5183 path_params['accountId'] = params['account_id'] 5184 if 'envelope_id' in params: 5185 path_params['envelopeId'] = params['envelope_id'] 5186 5187 query_params = {} 5188 5189 header_params = {} 5190 5191 form_params = [] 5192 local_var_files = {} 5193 5194 body_params = None 5195 if 'recipients' in params: 5196 body_params = params['recipients'] 5197 # HTTP header `Accept` 5198 header_params['Accept'] = self.api_client.\ 5199 select_header_accept(['application/json']) 5200 5201 # Authentication setting 5202 auth_settings = [] 5203 5204 return self.api_client.call_api(resource_path, 'DELETE', 5205 path_params, 5206 query_params, 5207 header_params, 5208 body=body_params, 5209 post_params=form_params, 5210 files=local_var_files, 5211 response_type='Recipients', 5212 auth_settings=auth_settings, 5213 callback=params.get('callback'), 5214 _return_http_data_only=params.get('_return_http_data_only'), 5215 _preload_content=params.get('_preload_content', True), 5216 _request_timeout=params.get('_request_timeout'), 5217 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)
5219 def delete_tabs(self, account_id, envelope_id, recipient_id, **kwargs): 5220 """ 5221 Deletes the tabs associated with a recipient. 5222 Deletes one or more tabs associated with a recipient in a draft envelope. 5223 This method makes a synchronous HTTP request by default. To make an 5224 asynchronous HTTP request, please define a `callback` function 5225 to be invoked when receiving the response. 5226 >>> def callback_function(response): 5227 >>> pprint(response) 5228 >>> 5229 >>> thread = api.delete_tabs(account_id, envelope_id, recipient_id, callback=callback_function) 5230 5231 :param callback function: The callback function 5232 for asynchronous request. (optional) 5233 :param str account_id: The external account number (int) or account ID Guid. (required) 5234 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5235 :param str recipient_id: The ID of the recipient being accessed. (required) 5236 :param Tabs tabs: 5237 :return: Tabs 5238 If the method is called asynchronously, 5239 returns the request thread. 5240 """ 5241 kwargs['_return_http_data_only'] = True 5242 if kwargs.get('callback'): 5243 return self.delete_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 5244 else: 5245 (data) = self.delete_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 5246 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)
5248 def delete_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 5249 """ 5250 Deletes the tabs associated with a recipient. 5251 Deletes one or more tabs associated with a recipient in a draft envelope. 5252 This method makes a synchronous HTTP request by default. To make an 5253 asynchronous HTTP request, please define a `callback` function 5254 to be invoked when receiving the response. 5255 >>> def callback_function(response): 5256 >>> pprint(response) 5257 >>> 5258 >>> thread = api.delete_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 5259 5260 :param callback function: The callback function 5261 for asynchronous request. (optional) 5262 :param str account_id: The external account number (int) or account ID Guid. (required) 5263 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5264 :param str recipient_id: The ID of the recipient being accessed. (required) 5265 :param Tabs tabs: 5266 :return: Tabs 5267 If the method is called asynchronously, 5268 returns the request thread. 5269 """ 5270 5271 all_params = ['account_id', 'envelope_id', 'recipient_id', 'tabs'] 5272 all_params.append('callback') 5273 all_params.append('_return_http_data_only') 5274 all_params.append('_preload_content') 5275 all_params.append('_request_timeout') 5276 5277 params = locals() 5278 for key, val in iteritems(params['kwargs']): 5279 if key not in all_params: 5280 raise TypeError( 5281 "Got an unexpected keyword argument '%s'" 5282 " to method delete_tabs" % key 5283 ) 5284 params[key] = val 5285 del params['kwargs'] 5286 # verify the required parameter 'account_id' is set 5287 if ('account_id' not in params) or (params['account_id'] is None): 5288 raise ValueError("Missing the required parameter `account_id` when calling `delete_tabs`") 5289 # verify the required parameter 'envelope_id' is set 5290 if ('envelope_id' not in params) or (params['envelope_id'] is None): 5291 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_tabs`") 5292 # verify the required parameter 'recipient_id' is set 5293 if ('recipient_id' not in params) or (params['recipient_id'] is None): 5294 raise ValueError("Missing the required parameter `recipient_id` when calling `delete_tabs`") 5295 5296 5297 collection_formats = {} 5298 5299 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/tabs'.replace('{format}', 'json') 5300 path_params = {} 5301 if 'account_id' in params: 5302 path_params['accountId'] = params['account_id'] 5303 if 'envelope_id' in params: 5304 path_params['envelopeId'] = params['envelope_id'] 5305 if 'recipient_id' in params: 5306 path_params['recipientId'] = params['recipient_id'] 5307 5308 query_params = {} 5309 5310 header_params = {} 5311 5312 form_params = [] 5313 local_var_files = {} 5314 5315 body_params = None 5316 if 'tabs' in params: 5317 body_params = params['tabs'] 5318 # HTTP header `Accept` 5319 header_params['Accept'] = self.api_client.\ 5320 select_header_accept(['application/json']) 5321 5322 # Authentication setting 5323 auth_settings = [] 5324 5325 return self.api_client.call_api(resource_path, 'DELETE', 5326 path_params, 5327 query_params, 5328 header_params, 5329 body=body_params, 5330 post_params=form_params, 5331 files=local_var_files, 5332 response_type='Tabs', 5333 auth_settings=auth_settings, 5334 callback=params.get('callback'), 5335 _return_http_data_only=params.get('_return_http_data_only'), 5336 _preload_content=params.get('_preload_content', True), 5337 _request_timeout=params.get('_request_timeout'), 5338 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)
5340 def delete_template_delayed_routing_definition(self, account_id, template_id, workflow_step_id, **kwargs): 5341 """ 5342 Deletes the delayed routing rules for the specified template workflow step. 5343 This method makes a synchronous HTTP request by default. To make an 5344 asynchronous HTTP request, please define a `callback` function 5345 to be invoked when receiving the response. 5346 >>> def callback_function(response): 5347 >>> pprint(response) 5348 >>> 5349 >>> thread = api.delete_template_delayed_routing_definition(account_id, template_id, workflow_step_id, callback=callback_function) 5350 5351 :param callback function: The callback function 5352 for asynchronous request. (optional) 5353 :param str account_id: The external account number (int) or account ID Guid. (required) 5354 :param str template_id: The ID of the template being accessed. (required) 5355 :param str workflow_step_id: (required) 5356 :return: None 5357 If the method is called asynchronously, 5358 returns the request thread. 5359 """ 5360 kwargs['_return_http_data_only'] = True 5361 if kwargs.get('callback'): 5362 return self.delete_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 5363 else: 5364 (data) = self.delete_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 5365 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)
5367 def delete_template_delayed_routing_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 5368 """ 5369 Deletes the delayed routing rules for the specified template workflow step. 5370 This method makes a synchronous HTTP request by default. To make an 5371 asynchronous HTTP request, please define a `callback` function 5372 to be invoked when receiving the response. 5373 >>> def callback_function(response): 5374 >>> pprint(response) 5375 >>> 5376 >>> thread = api.delete_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 5377 5378 :param callback function: The callback function 5379 for asynchronous request. (optional) 5380 :param str account_id: The external account number (int) or account ID Guid. (required) 5381 :param str template_id: The ID of the template being accessed. (required) 5382 :param str workflow_step_id: (required) 5383 :return: None 5384 If the method is called asynchronously, 5385 returns the request thread. 5386 """ 5387 5388 all_params = ['account_id', 'template_id', 'workflow_step_id'] 5389 all_params.append('callback') 5390 all_params.append('_return_http_data_only') 5391 all_params.append('_preload_content') 5392 all_params.append('_request_timeout') 5393 5394 params = locals() 5395 for key, val in iteritems(params['kwargs']): 5396 if key not in all_params: 5397 raise TypeError( 5398 "Got an unexpected keyword argument '%s'" 5399 " to method delete_template_delayed_routing_definition" % key 5400 ) 5401 params[key] = val 5402 del params['kwargs'] 5403 # verify the required parameter 'account_id' is set 5404 if ('account_id' not in params) or (params['account_id'] is None): 5405 raise ValueError("Missing the required parameter `account_id` when calling `delete_template_delayed_routing_definition`") 5406 # verify the required parameter 'template_id' is set 5407 if ('template_id' not in params) or (params['template_id'] is None): 5408 raise ValueError("Missing the required parameter `template_id` when calling `delete_template_delayed_routing_definition`") 5409 # verify the required parameter 'workflow_step_id' is set 5410 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 5411 raise ValueError("Missing the required parameter `workflow_step_id` when calling `delete_template_delayed_routing_definition`") 5412 5413 5414 collection_formats = {} 5415 5416 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 5417 path_params = {} 5418 if 'account_id' in params: 5419 path_params['accountId'] = params['account_id'] 5420 if 'template_id' in params: 5421 path_params['templateId'] = params['template_id'] 5422 if 'workflow_step_id' in params: 5423 path_params['workflowStepId'] = params['workflow_step_id'] 5424 5425 query_params = {} 5426 5427 header_params = {} 5428 5429 form_params = [] 5430 local_var_files = {} 5431 5432 body_params = None 5433 # HTTP header `Accept` 5434 header_params['Accept'] = self.api_client.\ 5435 select_header_accept(['application/json']) 5436 5437 # Authentication setting 5438 auth_settings = [] 5439 5440 return self.api_client.call_api(resource_path, 'DELETE', 5441 path_params, 5442 query_params, 5443 header_params, 5444 body=body_params, 5445 post_params=form_params, 5446 files=local_var_files, 5447 response_type=None, 5448 auth_settings=auth_settings, 5449 callback=params.get('callback'), 5450 _return_http_data_only=params.get('_return_http_data_only'), 5451 _preload_content=params.get('_preload_content', True), 5452 _request_timeout=params.get('_request_timeout'), 5453 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)
5455 def delete_template_scheduled_sending_definition(self, account_id, template_id, **kwargs): 5456 """ 5457 Deletes the scheduled sending rules for the template's workflow. 5458 This method makes a synchronous HTTP request by default. To make an 5459 asynchronous HTTP request, please define a `callback` function 5460 to be invoked when receiving the response. 5461 >>> def callback_function(response): 5462 >>> pprint(response) 5463 >>> 5464 >>> thread = api.delete_template_scheduled_sending_definition(account_id, template_id, callback=callback_function) 5465 5466 :param callback function: The callback function 5467 for asynchronous request. (optional) 5468 :param str account_id: The external account number (int) or account ID Guid. (required) 5469 :param str template_id: The ID of the template being accessed. (required) 5470 :return: None 5471 If the method is called asynchronously, 5472 returns the request thread. 5473 """ 5474 kwargs['_return_http_data_only'] = True 5475 if kwargs.get('callback'): 5476 return self.delete_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 5477 else: 5478 (data) = self.delete_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 5479 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)
5481 def delete_template_scheduled_sending_definition_with_http_info(self, account_id, template_id, **kwargs): 5482 """ 5483 Deletes the scheduled sending rules for the template's workflow. 5484 This method makes a synchronous HTTP request by default. To make an 5485 asynchronous HTTP request, please define a `callback` function 5486 to be invoked when receiving the response. 5487 >>> def callback_function(response): 5488 >>> pprint(response) 5489 >>> 5490 >>> thread = api.delete_template_scheduled_sending_definition_with_http_info(account_id, template_id, callback=callback_function) 5491 5492 :param callback function: The callback function 5493 for asynchronous request. (optional) 5494 :param str account_id: The external account number (int) or account ID Guid. (required) 5495 :param str template_id: The ID of the template being accessed. (required) 5496 :return: None 5497 If the method is called asynchronously, 5498 returns the request thread. 5499 """ 5500 5501 all_params = ['account_id', 'template_id'] 5502 all_params.append('callback') 5503 all_params.append('_return_http_data_only') 5504 all_params.append('_preload_content') 5505 all_params.append('_request_timeout') 5506 5507 params = locals() 5508 for key, val in iteritems(params['kwargs']): 5509 if key not in all_params: 5510 raise TypeError( 5511 "Got an unexpected keyword argument '%s'" 5512 " to method delete_template_scheduled_sending_definition" % key 5513 ) 5514 params[key] = val 5515 del params['kwargs'] 5516 # verify the required parameter 'account_id' is set 5517 if ('account_id' not in params) or (params['account_id'] is None): 5518 raise ValueError("Missing the required parameter `account_id` when calling `delete_template_scheduled_sending_definition`") 5519 # verify the required parameter 'template_id' is set 5520 if ('template_id' not in params) or (params['template_id'] is None): 5521 raise ValueError("Missing the required parameter `template_id` when calling `delete_template_scheduled_sending_definition`") 5522 5523 5524 collection_formats = {} 5525 5526 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/scheduledSending'.replace('{format}', 'json') 5527 path_params = {} 5528 if 'account_id' in params: 5529 path_params['accountId'] = params['account_id'] 5530 if 'template_id' in params: 5531 path_params['templateId'] = params['template_id'] 5532 5533 query_params = {} 5534 5535 header_params = {} 5536 5537 form_params = [] 5538 local_var_files = {} 5539 5540 body_params = None 5541 # HTTP header `Accept` 5542 header_params['Accept'] = self.api_client.\ 5543 select_header_accept(['application/json']) 5544 5545 # Authentication setting 5546 auth_settings = [] 5547 5548 return self.api_client.call_api(resource_path, 'DELETE', 5549 path_params, 5550 query_params, 5551 header_params, 5552 body=body_params, 5553 post_params=form_params, 5554 files=local_var_files, 5555 response_type=None, 5556 auth_settings=auth_settings, 5557 callback=params.get('callback'), 5558 _return_http_data_only=params.get('_return_http_data_only'), 5559 _preload_content=params.get('_preload_content', True), 5560 _request_timeout=params.get('_request_timeout'), 5561 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)
5563 def delete_template_workflow_definition(self, account_id, template_id, **kwargs): 5564 """ 5565 Delete the workflow definition for a template. 5566 Deletes the specified template's workflow definition if it has one. 5567 This method makes a synchronous HTTP request by default. To make an 5568 asynchronous HTTP request, please define a `callback` function 5569 to be invoked when receiving the response. 5570 >>> def callback_function(response): 5571 >>> pprint(response) 5572 >>> 5573 >>> thread = api.delete_template_workflow_definition(account_id, template_id, callback=callback_function) 5574 5575 :param callback function: The callback function 5576 for asynchronous request. (optional) 5577 :param str account_id: The external account number (int) or account ID Guid. (required) 5578 :param str template_id: The ID of the template being accessed. (required) 5579 :return: None 5580 If the method is called asynchronously, 5581 returns the request thread. 5582 """ 5583 kwargs['_return_http_data_only'] = True 5584 if kwargs.get('callback'): 5585 return self.delete_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 5586 else: 5587 (data) = self.delete_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 5588 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)
5590 def delete_template_workflow_definition_with_http_info(self, account_id, template_id, **kwargs): 5591 """ 5592 Delete the workflow definition for a template. 5593 Deletes the specified template's workflow definition if it has one. 5594 This method makes a synchronous HTTP request by default. To make an 5595 asynchronous HTTP request, please define a `callback` function 5596 to be invoked when receiving the response. 5597 >>> def callback_function(response): 5598 >>> pprint(response) 5599 >>> 5600 >>> thread = api.delete_template_workflow_definition_with_http_info(account_id, template_id, callback=callback_function) 5601 5602 :param callback function: The callback function 5603 for asynchronous request. (optional) 5604 :param str account_id: The external account number (int) or account ID Guid. (required) 5605 :param str template_id: The ID of the template being accessed. (required) 5606 :return: None 5607 If the method is called asynchronously, 5608 returns the request thread. 5609 """ 5610 5611 all_params = ['account_id', 'template_id'] 5612 all_params.append('callback') 5613 all_params.append('_return_http_data_only') 5614 all_params.append('_preload_content') 5615 all_params.append('_request_timeout') 5616 5617 params = locals() 5618 for key, val in iteritems(params['kwargs']): 5619 if key not in all_params: 5620 raise TypeError( 5621 "Got an unexpected keyword argument '%s'" 5622 " to method delete_template_workflow_definition" % key 5623 ) 5624 params[key] = val 5625 del params['kwargs'] 5626 # verify the required parameter 'account_id' is set 5627 if ('account_id' not in params) or (params['account_id'] is None): 5628 raise ValueError("Missing the required parameter `account_id` when calling `delete_template_workflow_definition`") 5629 # verify the required parameter 'template_id' is set 5630 if ('template_id' not in params) or (params['template_id'] is None): 5631 raise ValueError("Missing the required parameter `template_id` when calling `delete_template_workflow_definition`") 5632 5633 5634 collection_formats = {} 5635 5636 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow'.replace('{format}', 'json') 5637 path_params = {} 5638 if 'account_id' in params: 5639 path_params['accountId'] = params['account_id'] 5640 if 'template_id' in params: 5641 path_params['templateId'] = params['template_id'] 5642 5643 query_params = {} 5644 5645 header_params = {} 5646 5647 form_params = [] 5648 local_var_files = {} 5649 5650 body_params = None 5651 # HTTP header `Accept` 5652 header_params['Accept'] = self.api_client.\ 5653 select_header_accept(['application/json']) 5654 5655 # Authentication setting 5656 auth_settings = [] 5657 5658 return self.api_client.call_api(resource_path, 'DELETE', 5659 path_params, 5660 query_params, 5661 header_params, 5662 body=body_params, 5663 post_params=form_params, 5664 files=local_var_files, 5665 response_type=None, 5666 auth_settings=auth_settings, 5667 callback=params.get('callback'), 5668 _return_http_data_only=params.get('_return_http_data_only'), 5669 _preload_content=params.get('_preload_content', True), 5670 _request_timeout=params.get('_request_timeout'), 5671 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)
5673 def delete_template_workflow_step_definition(self, account_id, template_id, workflow_step_id, **kwargs): 5674 """ 5675 Deletes the workflow step definition for an template's workflow by step id. 5676 This method makes a synchronous HTTP request by default. To make an 5677 asynchronous HTTP request, please define a `callback` function 5678 to be invoked when receiving the response. 5679 >>> def callback_function(response): 5680 >>> pprint(response) 5681 >>> 5682 >>> thread = api.delete_template_workflow_step_definition(account_id, template_id, workflow_step_id, callback=callback_function) 5683 5684 :param callback function: The callback function 5685 for asynchronous request. (optional) 5686 :param str account_id: The external account number (int) or account ID Guid. (required) 5687 :param str template_id: The ID of the template being accessed. (required) 5688 :param str workflow_step_id: (required) 5689 :return: None 5690 If the method is called asynchronously, 5691 returns the request thread. 5692 """ 5693 kwargs['_return_http_data_only'] = True 5694 if kwargs.get('callback'): 5695 return self.delete_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 5696 else: 5697 (data) = self.delete_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 5698 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)
5700 def delete_template_workflow_step_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 5701 """ 5702 Deletes the workflow step definition for an template's workflow by step id. 5703 This method makes a synchronous HTTP request by default. To make an 5704 asynchronous HTTP request, please define a `callback` function 5705 to be invoked when receiving the response. 5706 >>> def callback_function(response): 5707 >>> pprint(response) 5708 >>> 5709 >>> thread = api.delete_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 5710 5711 :param callback function: The callback function 5712 for asynchronous request. (optional) 5713 :param str account_id: The external account number (int) or account ID Guid. (required) 5714 :param str template_id: The ID of the template being accessed. (required) 5715 :param str workflow_step_id: (required) 5716 :return: None 5717 If the method is called asynchronously, 5718 returns the request thread. 5719 """ 5720 5721 all_params = ['account_id', 'template_id', 'workflow_step_id'] 5722 all_params.append('callback') 5723 all_params.append('_return_http_data_only') 5724 all_params.append('_preload_content') 5725 all_params.append('_request_timeout') 5726 5727 params = locals() 5728 for key, val in iteritems(params['kwargs']): 5729 if key not in all_params: 5730 raise TypeError( 5731 "Got an unexpected keyword argument '%s'" 5732 " to method delete_template_workflow_step_definition" % key 5733 ) 5734 params[key] = val 5735 del params['kwargs'] 5736 # verify the required parameter 'account_id' is set 5737 if ('account_id' not in params) or (params['account_id'] is None): 5738 raise ValueError("Missing the required parameter `account_id` when calling `delete_template_workflow_step_definition`") 5739 # verify the required parameter 'template_id' is set 5740 if ('template_id' not in params) or (params['template_id'] is None): 5741 raise ValueError("Missing the required parameter `template_id` when calling `delete_template_workflow_step_definition`") 5742 # verify the required parameter 'workflow_step_id' is set 5743 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 5744 raise ValueError("Missing the required parameter `workflow_step_id` when calling `delete_template_workflow_step_definition`") 5745 5746 5747 collection_formats = {} 5748 5749 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 5750 path_params = {} 5751 if 'account_id' in params: 5752 path_params['accountId'] = params['account_id'] 5753 if 'template_id' in params: 5754 path_params['templateId'] = params['template_id'] 5755 if 'workflow_step_id' in params: 5756 path_params['workflowStepId'] = params['workflow_step_id'] 5757 5758 query_params = {} 5759 5760 header_params = {} 5761 5762 form_params = [] 5763 local_var_files = {} 5764 5765 body_params = None 5766 # HTTP header `Accept` 5767 header_params['Accept'] = self.api_client.\ 5768 select_header_accept(['application/json']) 5769 5770 # Authentication setting 5771 auth_settings = [] 5772 5773 return self.api_client.call_api(resource_path, 'DELETE', 5774 path_params, 5775 query_params, 5776 header_params, 5777 body=body_params, 5778 post_params=form_params, 5779 files=local_var_files, 5780 response_type=None, 5781 auth_settings=auth_settings, 5782 callback=params.get('callback'), 5783 _return_http_data_only=params.get('_return_http_data_only'), 5784 _preload_content=params.get('_preload_content', True), 5785 _request_timeout=params.get('_request_timeout'), 5786 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)
5788 def delete_templates_from_document(self, account_id, document_id, envelope_id, template_id, **kwargs): 5789 """ 5790 Deletes a template from a document in an existing envelope. 5791 Deletes the specified template from a document in an existing envelope. 5792 This method makes a synchronous HTTP request by default. To make an 5793 asynchronous HTTP request, please define a `callback` function 5794 to be invoked when receiving the response. 5795 >>> def callback_function(response): 5796 >>> pprint(response) 5797 >>> 5798 >>> thread = api.delete_templates_from_document(account_id, document_id, envelope_id, template_id, callback=callback_function) 5799 5800 :param callback function: The callback function 5801 for asynchronous request. (optional) 5802 :param str account_id: The external account number (int) or account ID Guid. (required) 5803 :param str document_id: The ID of the document being accessed. (required) 5804 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5805 :param str template_id: The ID of the template being accessed. (required) 5806 :return: None 5807 If the method is called asynchronously, 5808 returns the request thread. 5809 """ 5810 kwargs['_return_http_data_only'] = True 5811 if kwargs.get('callback'): 5812 return self.delete_templates_from_document_with_http_info(account_id, document_id, envelope_id, template_id, **kwargs) 5813 else: 5814 (data) = self.delete_templates_from_document_with_http_info(account_id, document_id, envelope_id, template_id, **kwargs) 5815 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)
5817 def delete_templates_from_document_with_http_info(self, account_id, document_id, envelope_id, template_id, **kwargs): 5818 """ 5819 Deletes a template from a document in an existing envelope. 5820 Deletes the specified template from a document in an existing envelope. 5821 This method makes a synchronous HTTP request by default. To make an 5822 asynchronous HTTP request, please define a `callback` function 5823 to be invoked when receiving the response. 5824 >>> def callback_function(response): 5825 >>> pprint(response) 5826 >>> 5827 >>> thread = api.delete_templates_from_document_with_http_info(account_id, document_id, envelope_id, template_id, callback=callback_function) 5828 5829 :param callback function: The callback function 5830 for asynchronous request. (optional) 5831 :param str account_id: The external account number (int) or account ID Guid. (required) 5832 :param str document_id: The ID of the document being accessed. (required) 5833 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5834 :param str template_id: The ID of the template being accessed. (required) 5835 :return: None 5836 If the method is called asynchronously, 5837 returns the request thread. 5838 """ 5839 5840 all_params = ['account_id', 'document_id', 'envelope_id', 'template_id'] 5841 all_params.append('callback') 5842 all_params.append('_return_http_data_only') 5843 all_params.append('_preload_content') 5844 all_params.append('_request_timeout') 5845 5846 params = locals() 5847 for key, val in iteritems(params['kwargs']): 5848 if key not in all_params: 5849 raise TypeError( 5850 "Got an unexpected keyword argument '%s'" 5851 " to method delete_templates_from_document" % key 5852 ) 5853 params[key] = val 5854 del params['kwargs'] 5855 # verify the required parameter 'account_id' is set 5856 if ('account_id' not in params) or (params['account_id'] is None): 5857 raise ValueError("Missing the required parameter `account_id` when calling `delete_templates_from_document`") 5858 # verify the required parameter 'document_id' is set 5859 if ('document_id' not in params) or (params['document_id'] is None): 5860 raise ValueError("Missing the required parameter `document_id` when calling `delete_templates_from_document`") 5861 # verify the required parameter 'envelope_id' is set 5862 if ('envelope_id' not in params) or (params['envelope_id'] is None): 5863 raise ValueError("Missing the required parameter `envelope_id` when calling `delete_templates_from_document`") 5864 # verify the required parameter 'template_id' is set 5865 if ('template_id' not in params) or (params['template_id'] is None): 5866 raise ValueError("Missing the required parameter `template_id` when calling `delete_templates_from_document`") 5867 5868 5869 collection_formats = {} 5870 5871 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/templates/{templateId}'.replace('{format}', 'json') 5872 path_params = {} 5873 if 'account_id' in params: 5874 path_params['accountId'] = params['account_id'] 5875 if 'document_id' in params: 5876 path_params['documentId'] = params['document_id'] 5877 if 'envelope_id' in params: 5878 path_params['envelopeId'] = params['envelope_id'] 5879 if 'template_id' in params: 5880 path_params['templateId'] = params['template_id'] 5881 5882 query_params = {} 5883 5884 header_params = {} 5885 5886 form_params = [] 5887 local_var_files = {} 5888 5889 body_params = None 5890 # HTTP header `Accept` 5891 header_params['Accept'] = self.api_client.\ 5892 select_header_accept(['application/json']) 5893 5894 # Authentication setting 5895 auth_settings = [] 5896 5897 return self.api_client.call_api(resource_path, 'DELETE', 5898 path_params, 5899 query_params, 5900 header_params, 5901 body=body_params, 5902 post_params=form_params, 5903 files=local_var_files, 5904 response_type=None, 5905 auth_settings=auth_settings, 5906 callback=params.get('callback'), 5907 _return_http_data_only=params.get('_return_http_data_only'), 5908 _preload_content=params.get('_preload_content', True), 5909 _request_timeout=params.get('_request_timeout'), 5910 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)
5912 def get_attachment(self, account_id, attachment_id, envelope_id, **kwargs): 5913 """ 5914 Retrieves an attachment from the envelope. 5915 Retrieves an attachment from an envelope. 5916 This method makes a synchronous HTTP request by default. To make an 5917 asynchronous HTTP request, please define a `callback` function 5918 to be invoked when receiving the response. 5919 >>> def callback_function(response): 5920 >>> pprint(response) 5921 >>> 5922 >>> thread = api.get_attachment(account_id, attachment_id, envelope_id, callback=callback_function) 5923 5924 :param callback function: The callback function 5925 for asynchronous request. (optional) 5926 :param str account_id: The external account number (int) or account ID Guid. (required) 5927 :param str attachment_id: (required) 5928 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5929 :return: None 5930 If the method is called asynchronously, 5931 returns the request thread. 5932 """ 5933 kwargs['_return_http_data_only'] = True 5934 if kwargs.get('callback'): 5935 return self.get_attachment_with_http_info(account_id, attachment_id, envelope_id, **kwargs) 5936 else: 5937 (data) = self.get_attachment_with_http_info(account_id, attachment_id, envelope_id, **kwargs) 5938 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
None If the method is called asynchronously, returns the request thread.
def
get_attachment_with_http_info(self, account_id, attachment_id, envelope_id, **kwargs)
5940 def get_attachment_with_http_info(self, account_id, attachment_id, envelope_id, **kwargs): 5941 """ 5942 Retrieves an attachment from the envelope. 5943 Retrieves an attachment from an envelope. 5944 This method makes a synchronous HTTP request by default. To make an 5945 asynchronous HTTP request, please define a `callback` function 5946 to be invoked when receiving the response. 5947 >>> def callback_function(response): 5948 >>> pprint(response) 5949 >>> 5950 >>> thread = api.get_attachment_with_http_info(account_id, attachment_id, envelope_id, callback=callback_function) 5951 5952 :param callback function: The callback function 5953 for asynchronous request. (optional) 5954 :param str account_id: The external account number (int) or account ID Guid. (required) 5955 :param str attachment_id: (required) 5956 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 5957 :return: None 5958 If the method is called asynchronously, 5959 returns the request thread. 5960 """ 5961 5962 all_params = ['account_id', 'attachment_id', 'envelope_id'] 5963 all_params.append('callback') 5964 all_params.append('_return_http_data_only') 5965 all_params.append('_preload_content') 5966 all_params.append('_request_timeout') 5967 5968 params = locals() 5969 for key, val in iteritems(params['kwargs']): 5970 if key not in all_params: 5971 raise TypeError( 5972 "Got an unexpected keyword argument '%s'" 5973 " to method get_attachment" % key 5974 ) 5975 params[key] = val 5976 del params['kwargs'] 5977 # verify the required parameter 'account_id' is set 5978 if ('account_id' not in params) or (params['account_id'] is None): 5979 raise ValueError("Missing the required parameter `account_id` when calling `get_attachment`") 5980 # verify the required parameter 'attachment_id' is set 5981 if ('attachment_id' not in params) or (params['attachment_id'] is None): 5982 raise ValueError("Missing the required parameter `attachment_id` when calling `get_attachment`") 5983 # verify the required parameter 'envelope_id' is set 5984 if ('envelope_id' not in params) or (params['envelope_id'] is None): 5985 raise ValueError("Missing the required parameter `envelope_id` when calling `get_attachment`") 5986 5987 5988 collection_formats = {} 5989 5990 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments/{attachmentId}'.replace('{format}', 'json') 5991 path_params = {} 5992 if 'account_id' in params: 5993 path_params['accountId'] = params['account_id'] 5994 if 'attachment_id' in params: 5995 path_params['attachmentId'] = params['attachment_id'] 5996 if 'envelope_id' in params: 5997 path_params['envelopeId'] = params['envelope_id'] 5998 5999 query_params = {} 6000 6001 header_params = {} 6002 6003 form_params = [] 6004 local_var_files = {} 6005 6006 body_params = None 6007 # HTTP header `Accept` 6008 header_params['Accept'] = self.api_client.\ 6009 select_header_accept(['application/json']) 6010 6011 # Authentication setting 6012 auth_settings = [] 6013 6014 return self.api_client.call_api(resource_path, 'GET', 6015 path_params, 6016 query_params, 6017 header_params, 6018 body=body_params, 6019 post_params=form_params, 6020 files=local_var_files, 6021 response_type=None, 6022 auth_settings=auth_settings, 6023 callback=params.get('callback'), 6024 _return_http_data_only=params.get('_return_http_data_only'), 6025 _preload_content=params.get('_preload_content', True), 6026 _request_timeout=params.get('_request_timeout'), 6027 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
None If the method is called asynchronously, returns the request thread.
def
get_attachments(self, account_id, envelope_id, **kwargs)
6029 def get_attachments(self, account_id, envelope_id, **kwargs): 6030 """ 6031 Returns a list of attachments associated with the specified envelope 6032 Returns a list of attachments associated with a specified envelope 6033 This method makes a synchronous HTTP request by default. To make an 6034 asynchronous HTTP request, please define a `callback` function 6035 to be invoked when receiving the response. 6036 >>> def callback_function(response): 6037 >>> pprint(response) 6038 >>> 6039 >>> thread = api.get_attachments(account_id, envelope_id, callback=callback_function) 6040 6041 :param callback function: The callback function 6042 for asynchronous request. (optional) 6043 :param str account_id: The external account number (int) or account ID Guid. (required) 6044 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6045 :return: EnvelopeAttachmentsResult 6046 If the method is called asynchronously, 6047 returns the request thread. 6048 """ 6049 kwargs['_return_http_data_only'] = True 6050 if kwargs.get('callback'): 6051 return self.get_attachments_with_http_info(account_id, envelope_id, **kwargs) 6052 else: 6053 (data) = self.get_attachments_with_http_info(account_id, envelope_id, **kwargs) 6054 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)
6056 def get_attachments_with_http_info(self, account_id, envelope_id, **kwargs): 6057 """ 6058 Returns a list of attachments associated with the specified envelope 6059 Returns a list of attachments associated with a specified envelope 6060 This method makes a synchronous HTTP request by default. To make an 6061 asynchronous HTTP request, please define a `callback` function 6062 to be invoked when receiving the response. 6063 >>> def callback_function(response): 6064 >>> pprint(response) 6065 >>> 6066 >>> thread = api.get_attachments_with_http_info(account_id, envelope_id, callback=callback_function) 6067 6068 :param callback function: The callback function 6069 for asynchronous request. (optional) 6070 :param str account_id: The external account number (int) or account ID Guid. (required) 6071 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6072 :return: EnvelopeAttachmentsResult 6073 If the method is called asynchronously, 6074 returns the request thread. 6075 """ 6076 6077 all_params = ['account_id', 'envelope_id'] 6078 all_params.append('callback') 6079 all_params.append('_return_http_data_only') 6080 all_params.append('_preload_content') 6081 all_params.append('_request_timeout') 6082 6083 params = locals() 6084 for key, val in iteritems(params['kwargs']): 6085 if key not in all_params: 6086 raise TypeError( 6087 "Got an unexpected keyword argument '%s'" 6088 " to method get_attachments" % key 6089 ) 6090 params[key] = val 6091 del params['kwargs'] 6092 # verify the required parameter 'account_id' is set 6093 if ('account_id' not in params) or (params['account_id'] is None): 6094 raise ValueError("Missing the required parameter `account_id` when calling `get_attachments`") 6095 # verify the required parameter 'envelope_id' is set 6096 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6097 raise ValueError("Missing the required parameter `envelope_id` when calling `get_attachments`") 6098 6099 6100 collection_formats = {} 6101 6102 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments'.replace('{format}', 'json') 6103 path_params = {} 6104 if 'account_id' in params: 6105 path_params['accountId'] = params['account_id'] 6106 if 'envelope_id' in params: 6107 path_params['envelopeId'] = params['envelope_id'] 6108 6109 query_params = {} 6110 6111 header_params = {} 6112 6113 form_params = [] 6114 local_var_files = {} 6115 6116 body_params = None 6117 # HTTP header `Accept` 6118 header_params['Accept'] = self.api_client.\ 6119 select_header_accept(['application/json']) 6120 6121 # Authentication setting 6122 auth_settings = [] 6123 6124 return self.api_client.call_api(resource_path, 'GET', 6125 path_params, 6126 query_params, 6127 header_params, 6128 body=body_params, 6129 post_params=form_params, 6130 files=local_var_files, 6131 response_type='EnvelopeAttachmentsResult', 6132 auth_settings=auth_settings, 6133 callback=params.get('callback'), 6134 _return_http_data_only=params.get('_return_http_data_only'), 6135 _preload_content=params.get('_preload_content', True), 6136 _request_timeout=params.get('_request_timeout'), 6137 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)
6139 def get_chunked_upload(self, account_id, chunked_upload_id, **kwargs): 6140 """ 6141 Retrieves the current metadata of a ChunkedUpload. 6142 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. 6143 This method makes a synchronous HTTP request by default. To make an 6144 asynchronous HTTP request, please define a `callback` function 6145 to be invoked when receiving the response. 6146 >>> def callback_function(response): 6147 >>> pprint(response) 6148 >>> 6149 >>> thread = api.get_chunked_upload(account_id, chunked_upload_id, callback=callback_function) 6150 6151 :param callback function: The callback function 6152 for asynchronous request. (optional) 6153 :param str account_id: The external account number (int) or account ID Guid. (required) 6154 :param str chunked_upload_id: (required) 6155 :param str include: 6156 :return: ChunkedUploadResponse 6157 If the method is called asynchronously, 6158 returns the request thread. 6159 """ 6160 kwargs['_return_http_data_only'] = True 6161 if kwargs.get('callback'): 6162 return self.get_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 6163 else: 6164 (data) = self.get_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 6165 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)
6167 def get_chunked_upload_with_http_info(self, account_id, chunked_upload_id, **kwargs): 6168 """ 6169 Retrieves the current metadata of a ChunkedUpload. 6170 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. 6171 This method makes a synchronous HTTP request by default. To make an 6172 asynchronous HTTP request, please define a `callback` function 6173 to be invoked when receiving the response. 6174 >>> def callback_function(response): 6175 >>> pprint(response) 6176 >>> 6177 >>> thread = api.get_chunked_upload_with_http_info(account_id, chunked_upload_id, callback=callback_function) 6178 6179 :param callback function: The callback function 6180 for asynchronous request. (optional) 6181 :param str account_id: The external account number (int) or account ID Guid. (required) 6182 :param str chunked_upload_id: (required) 6183 :param str include: 6184 :return: ChunkedUploadResponse 6185 If the method is called asynchronously, 6186 returns the request thread. 6187 """ 6188 6189 all_params = ['account_id', 'chunked_upload_id', 'include'] 6190 all_params.append('callback') 6191 all_params.append('_return_http_data_only') 6192 all_params.append('_preload_content') 6193 all_params.append('_request_timeout') 6194 6195 params = locals() 6196 for key, val in iteritems(params['kwargs']): 6197 if key not in all_params: 6198 raise TypeError( 6199 "Got an unexpected keyword argument '%s'" 6200 " to method get_chunked_upload" % key 6201 ) 6202 params[key] = val 6203 del params['kwargs'] 6204 # verify the required parameter 'account_id' is set 6205 if ('account_id' not in params) or (params['account_id'] is None): 6206 raise ValueError("Missing the required parameter `account_id` when calling `get_chunked_upload`") 6207 # verify the required parameter 'chunked_upload_id' is set 6208 if ('chunked_upload_id' not in params) or (params['chunked_upload_id'] is None): 6209 raise ValueError("Missing the required parameter `chunked_upload_id` when calling `get_chunked_upload`") 6210 6211 6212 collection_formats = {} 6213 6214 resource_path = '/v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}'.replace('{format}', 'json') 6215 path_params = {} 6216 if 'account_id' in params: 6217 path_params['accountId'] = params['account_id'] 6218 if 'chunked_upload_id' in params: 6219 path_params['chunkedUploadId'] = params['chunked_upload_id'] 6220 6221 query_params = {} 6222 if 'include' in params: 6223 query_params['include'] = params['include'] 6224 6225 header_params = {} 6226 6227 form_params = [] 6228 local_var_files = {} 6229 6230 body_params = None 6231 # HTTP header `Accept` 6232 header_params['Accept'] = self.api_client.\ 6233 select_header_accept(['application/json']) 6234 6235 # Authentication setting 6236 auth_settings = [] 6237 6238 return self.api_client.call_api(resource_path, 'GET', 6239 path_params, 6240 query_params, 6241 header_params, 6242 body=body_params, 6243 post_params=form_params, 6244 files=local_var_files, 6245 response_type='ChunkedUploadResponse', 6246 auth_settings=auth_settings, 6247 callback=params.get('callback'), 6248 _return_http_data_only=params.get('_return_http_data_only'), 6249 _preload_content=params.get('_preload_content', True), 6250 _request_timeout=params.get('_request_timeout'), 6251 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)
6253 def get_comments_transcript(self, account_id, envelope_id, **kwargs): 6254 """ 6255 Gets comment transcript for envelope and user 6256 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**). 6257 This method makes a synchronous HTTP request by default. To make an 6258 asynchronous HTTP request, please define a `callback` function 6259 to be invoked when receiving the response. 6260 >>> def callback_function(response): 6261 >>> pprint(response) 6262 >>> 6263 >>> thread = api.get_comments_transcript(account_id, envelope_id, callback=callback_function) 6264 6265 :param callback function: The callback function 6266 for asynchronous request. (optional) 6267 :param str account_id: The external account number (int) or account ID Guid. (required) 6268 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6269 :param str encoding: 6270 :return: file 6271 If the method is called asynchronously, 6272 returns the request thread. 6273 """ 6274 kwargs['_return_http_data_only'] = True 6275 if kwargs.get('callback'): 6276 return self.get_comments_transcript_with_http_info(account_id, envelope_id, **kwargs) 6277 else: 6278 (data) = self.get_comments_transcript_with_http_info(account_id, envelope_id, **kwargs) 6279 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)
6281 def get_comments_transcript_with_http_info(self, account_id, envelope_id, **kwargs): 6282 """ 6283 Gets comment transcript for envelope and user 6284 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**). 6285 This method makes a synchronous HTTP request by default. To make an 6286 asynchronous HTTP request, please define a `callback` function 6287 to be invoked when receiving the response. 6288 >>> def callback_function(response): 6289 >>> pprint(response) 6290 >>> 6291 >>> thread = api.get_comments_transcript_with_http_info(account_id, envelope_id, callback=callback_function) 6292 6293 :param callback function: The callback function 6294 for asynchronous request. (optional) 6295 :param str account_id: The external account number (int) or account ID Guid. (required) 6296 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6297 :param str encoding: 6298 :return: file 6299 If the method is called asynchronously, 6300 returns the request thread. 6301 """ 6302 6303 all_params = ['account_id', 'envelope_id', 'encoding'] 6304 all_params.append('callback') 6305 all_params.append('_return_http_data_only') 6306 all_params.append('_preload_content') 6307 all_params.append('_request_timeout') 6308 6309 params = locals() 6310 for key, val in iteritems(params['kwargs']): 6311 if key not in all_params: 6312 raise TypeError( 6313 "Got an unexpected keyword argument '%s'" 6314 " to method get_comments_transcript" % key 6315 ) 6316 params[key] = val 6317 del params['kwargs'] 6318 # verify the required parameter 'account_id' is set 6319 if ('account_id' not in params) or (params['account_id'] is None): 6320 raise ValueError("Missing the required parameter `account_id` when calling `get_comments_transcript`") 6321 # verify the required parameter 'envelope_id' is set 6322 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6323 raise ValueError("Missing the required parameter `envelope_id` when calling `get_comments_transcript`") 6324 6325 6326 collection_formats = {} 6327 6328 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/comments/transcript'.replace('{format}', 'json') 6329 path_params = {} 6330 if 'account_id' in params: 6331 path_params['accountId'] = params['account_id'] 6332 if 'envelope_id' in params: 6333 path_params['envelopeId'] = params['envelope_id'] 6334 6335 query_params = {} 6336 if 'encoding' in params: 6337 query_params['encoding'] = params['encoding'] 6338 6339 header_params = {} 6340 6341 form_params = [] 6342 local_var_files = {} 6343 6344 body_params = None 6345 # HTTP header `Accept` 6346 header_params['Accept'] = self.api_client.\ 6347 select_header_accept(['application/pdf']) 6348 6349 # Authentication setting 6350 auth_settings = [] 6351 6352 return self.api_client.call_api(resource_path, 'GET', 6353 path_params, 6354 query_params, 6355 header_params, 6356 body=body_params, 6357 post_params=form_params, 6358 files=local_var_files, 6359 response_type='file', 6360 auth_settings=auth_settings, 6361 callback=params.get('callback'), 6362 _return_http_data_only=params.get('_return_http_data_only'), 6363 _preload_content=params.get('_preload_content', True), 6364 _request_timeout=params.get('_request_timeout'), 6365 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)
6367 def get_consumer_disclosure(self, account_id, envelope_id, lang_code, recipient_id, **kwargs): 6368 """ 6369 Reserved: Gets the Electronic Record and Signature Disclosure associated with the account. 6370 Reserved: Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, associated with the account. 6371 This method makes a synchronous HTTP request by default. To make an 6372 asynchronous HTTP request, please define a `callback` function 6373 to be invoked when receiving the response. 6374 >>> def callback_function(response): 6375 >>> pprint(response) 6376 >>> 6377 >>> thread = api.get_consumer_disclosure(account_id, envelope_id, lang_code, recipient_id, callback=callback_function) 6378 6379 :param callback function: The callback function 6380 for asynchronous request. (optional) 6381 :param str account_id: The external account number (int) or account ID Guid. (required) 6382 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6383 :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), 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) 6384 :param str recipient_id: The ID of the recipient being accessed. (required) 6385 :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. 6386 :return: ConsumerDisclosure 6387 If the method is called asynchronously, 6388 returns the request thread. 6389 """ 6390 kwargs['_return_http_data_only'] = True 6391 if kwargs.get('callback'): 6392 return self.get_consumer_disclosure_with_http_info(account_id, envelope_id, lang_code, recipient_id, **kwargs) 6393 else: 6394 (data) = self.get_consumer_disclosure_with_http_info(account_id, envelope_id, lang_code, recipient_id, **kwargs) 6395 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), 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)
6397 def get_consumer_disclosure_with_http_info(self, account_id, envelope_id, lang_code, recipient_id, **kwargs): 6398 """ 6399 Reserved: Gets the Electronic Record and Signature Disclosure associated with the account. 6400 Reserved: Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, associated with the account. 6401 This method makes a synchronous HTTP request by default. To make an 6402 asynchronous HTTP request, please define a `callback` function 6403 to be invoked when receiving the response. 6404 >>> def callback_function(response): 6405 >>> pprint(response) 6406 >>> 6407 >>> thread = api.get_consumer_disclosure_with_http_info(account_id, envelope_id, lang_code, recipient_id, callback=callback_function) 6408 6409 :param callback function: The callback function 6410 for asynchronous request. (optional) 6411 :param str account_id: The external account number (int) or account ID Guid. (required) 6412 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6413 :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), 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) 6414 :param str recipient_id: The ID of the recipient being accessed. (required) 6415 :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. 6416 :return: ConsumerDisclosure 6417 If the method is called asynchronously, 6418 returns the request thread. 6419 """ 6420 6421 all_params = ['account_id', 'envelope_id', 'lang_code', 'recipient_id', 'lang_code2'] 6422 all_params.append('callback') 6423 all_params.append('_return_http_data_only') 6424 all_params.append('_preload_content') 6425 all_params.append('_request_timeout') 6426 6427 params = locals() 6428 for key, val in iteritems(params['kwargs']): 6429 if key not in all_params: 6430 raise TypeError( 6431 "Got an unexpected keyword argument '%s'" 6432 " to method get_consumer_disclosure" % key 6433 ) 6434 params[key] = val 6435 del params['kwargs'] 6436 # verify the required parameter 'account_id' is set 6437 if ('account_id' not in params) or (params['account_id'] is None): 6438 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure`") 6439 # verify the required parameter 'envelope_id' is set 6440 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6441 raise ValueError("Missing the required parameter `envelope_id` when calling `get_consumer_disclosure`") 6442 # verify the required parameter 'lang_code' is set 6443 if ('lang_code' not in params) or (params['lang_code'] is None): 6444 raise ValueError("Missing the required parameter `lang_code` when calling `get_consumer_disclosure`") 6445 # verify the required parameter 'recipient_id' is set 6446 if ('recipient_id' not in params) or (params['recipient_id'] is None): 6447 raise ValueError("Missing the required parameter `recipient_id` when calling `get_consumer_disclosure`") 6448 6449 6450 collection_formats = {} 6451 6452 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 6453 path_params = {} 6454 if 'account_id' in params: 6455 path_params['accountId'] = params['account_id'] 6456 if 'envelope_id' in params: 6457 path_params['envelopeId'] = params['envelope_id'] 6458 if 'lang_code' in params: 6459 path_params['langCode'] = params['lang_code'] 6460 if 'recipient_id' in params: 6461 path_params['recipientId'] = params['recipient_id'] 6462 6463 query_params = {} 6464 if 'lang_code2' in params: 6465 query_params['langCode'] = params['lang_code2'] 6466 6467 header_params = {} 6468 6469 form_params = [] 6470 local_var_files = {} 6471 6472 body_params = None 6473 # HTTP header `Accept` 6474 header_params['Accept'] = self.api_client.\ 6475 select_header_accept(['application/json']) 6476 6477 # Authentication setting 6478 auth_settings = [] 6479 6480 return self.api_client.call_api(resource_path, 'GET', 6481 path_params, 6482 query_params, 6483 header_params, 6484 body=body_params, 6485 post_params=form_params, 6486 files=local_var_files, 6487 response_type='ConsumerDisclosure', 6488 auth_settings=auth_settings, 6489 callback=params.get('callback'), 6490 _return_http_data_only=params.get('_return_http_data_only'), 6491 _preload_content=params.get('_preload_content', True), 6492 _request_timeout=params.get('_request_timeout'), 6493 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), 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)
6495 def get_consumer_disclosure_default(self, account_id, envelope_id, recipient_id, **kwargs): 6496 """ 6497 Gets the Electronic Record and Signature Disclosure associated with the account. 6498 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. 6499 This method makes a synchronous HTTP request by default. To make an 6500 asynchronous HTTP request, please define a `callback` function 6501 to be invoked when receiving the response. 6502 >>> def callback_function(response): 6503 >>> pprint(response) 6504 >>> 6505 >>> thread = api.get_consumer_disclosure_default(account_id, envelope_id, recipient_id, callback=callback_function) 6506 6507 :param callback function: The callback function 6508 for asynchronous request. (optional) 6509 :param str account_id: The external account number (int) or account ID Guid. (required) 6510 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6511 :param str recipient_id: The ID of the recipient being accessed. (required) 6512 :param str lang_code: 6513 :return: ConsumerDisclosure 6514 If the method is called asynchronously, 6515 returns the request thread. 6516 """ 6517 kwargs['_return_http_data_only'] = True 6518 if kwargs.get('callback'): 6519 return self.get_consumer_disclosure_default_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 6520 else: 6521 (data) = self.get_consumer_disclosure_default_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 6522 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)
6524 def get_consumer_disclosure_default_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 6525 """ 6526 Gets the Electronic Record and Signature Disclosure associated with the account. 6527 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. 6528 This method makes a synchronous HTTP request by default. To make an 6529 asynchronous HTTP request, please define a `callback` function 6530 to be invoked when receiving the response. 6531 >>> def callback_function(response): 6532 >>> pprint(response) 6533 >>> 6534 >>> thread = api.get_consumer_disclosure_default_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 6535 6536 :param callback function: The callback function 6537 for asynchronous request. (optional) 6538 :param str account_id: The external account number (int) or account ID Guid. (required) 6539 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6540 :param str recipient_id: The ID of the recipient being accessed. (required) 6541 :param str lang_code: 6542 :return: ConsumerDisclosure 6543 If the method is called asynchronously, 6544 returns the request thread. 6545 """ 6546 6547 all_params = ['account_id', 'envelope_id', 'recipient_id', 'lang_code'] 6548 all_params.append('callback') 6549 all_params.append('_return_http_data_only') 6550 all_params.append('_preload_content') 6551 all_params.append('_request_timeout') 6552 6553 params = locals() 6554 for key, val in iteritems(params['kwargs']): 6555 if key not in all_params: 6556 raise TypeError( 6557 "Got an unexpected keyword argument '%s'" 6558 " to method get_consumer_disclosure_default" % key 6559 ) 6560 params[key] = val 6561 del params['kwargs'] 6562 # verify the required parameter 'account_id' is set 6563 if ('account_id' not in params) or (params['account_id'] is None): 6564 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure_default`") 6565 # verify the required parameter 'envelope_id' is set 6566 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6567 raise ValueError("Missing the required parameter `envelope_id` when calling `get_consumer_disclosure_default`") 6568 # verify the required parameter 'recipient_id' is set 6569 if ('recipient_id' not in params) or (params['recipient_id'] is None): 6570 raise ValueError("Missing the required parameter `recipient_id` when calling `get_consumer_disclosure_default`") 6571 6572 6573 collection_formats = {} 6574 6575 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/consumer_disclosure'.replace('{format}', 'json') 6576 path_params = {} 6577 if 'account_id' in params: 6578 path_params['accountId'] = params['account_id'] 6579 if 'envelope_id' in params: 6580 path_params['envelopeId'] = params['envelope_id'] 6581 if 'recipient_id' in params: 6582 path_params['recipientId'] = params['recipient_id'] 6583 6584 query_params = {} 6585 if 'lang_code' in params: 6586 query_params['langCode'] = params['lang_code'] 6587 6588 header_params = {} 6589 6590 form_params = [] 6591 local_var_files = {} 6592 6593 body_params = None 6594 # HTTP header `Accept` 6595 header_params['Accept'] = self.api_client.\ 6596 select_header_accept(['application/json']) 6597 6598 # Authentication setting 6599 auth_settings = [] 6600 6601 return self.api_client.call_api(resource_path, 'GET', 6602 path_params, 6603 query_params, 6604 header_params, 6605 body=body_params, 6606 post_params=form_params, 6607 files=local_var_files, 6608 response_type='ConsumerDisclosure', 6609 auth_settings=auth_settings, 6610 callback=params.get('callback'), 6611 _return_http_data_only=params.get('_return_http_data_only'), 6612 _preload_content=params.get('_preload_content', True), 6613 _request_timeout=params.get('_request_timeout'), 6614 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)
6616 def get_document(self, account_id, document_id, envelope_id, **kwargs): 6617 """ 6618 Gets a document from an envelope. 6619 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 6620 This method makes a synchronous HTTP request by default. To make an 6621 asynchronous HTTP request, please define a `callback` function 6622 to be invoked when receiving the response. 6623 >>> def callback_function(response): 6624 >>> pprint(response) 6625 >>> 6626 >>> thread = api.get_document(account_id, document_id, envelope_id, callback=callback_function) 6627 6628 :param callback function: The callback function 6629 for asynchronous request. (optional) 6630 :param str account_id: The external account number (int) or account ID Guid. (required) 6631 :param str document_id: The ID of the document being accessed. (required) 6632 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6633 :param str certificate: When set to **false**, the envelope signing certificate is removed from the download. 6634 :param str documents_by_userid: 6635 :param str encoding: 6636 :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. 6637 :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). 6638 :param str recipient_id: 6639 :param str shared_user_id: 6640 :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. 6641 :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. 6642 :return: file 6643 If the method is called asynchronously, 6644 returns the request thread. 6645 """ 6646 kwargs['_return_http_data_only'] = True 6647 if kwargs.get('callback'): 6648 return self.get_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 6649 else: 6650 (data) = self.get_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 6651 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)
6653 def get_document_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 6654 """ 6655 Gets a document from an envelope. 6656 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 6657 This method makes a synchronous HTTP request by default. To make an 6658 asynchronous HTTP request, please define a `callback` function 6659 to be invoked when receiving the response. 6660 >>> def callback_function(response): 6661 >>> pprint(response) 6662 >>> 6663 >>> thread = api.get_document_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 6664 6665 :param callback function: The callback function 6666 for asynchronous request. (optional) 6667 :param str account_id: The external account number (int) or account ID Guid. (required) 6668 :param str document_id: The ID of the document being accessed. (required) 6669 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6670 :param str certificate: When set to **false**, the envelope signing certificate is removed from the download. 6671 :param str documents_by_userid: 6672 :param str encoding: 6673 :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. 6674 :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). 6675 :param str recipient_id: 6676 :param str shared_user_id: 6677 :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. 6678 :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. 6679 :return: file 6680 If the method is called asynchronously, 6681 returns the request thread. 6682 """ 6683 6684 all_params = ['account_id', 'document_id', 'envelope_id', 'certificate', 'documents_by_userid', 'encoding', 'encrypt', 'language', 'recipient_id', 'shared_user_id', 'show_changes', 'watermark'] 6685 all_params.append('callback') 6686 all_params.append('_return_http_data_only') 6687 all_params.append('_preload_content') 6688 all_params.append('_request_timeout') 6689 6690 params = locals() 6691 for key, val in iteritems(params['kwargs']): 6692 if key not in all_params: 6693 raise TypeError( 6694 "Got an unexpected keyword argument '%s'" 6695 " to method get_document" % key 6696 ) 6697 params[key] = val 6698 del params['kwargs'] 6699 # verify the required parameter 'account_id' is set 6700 if ('account_id' not in params) or (params['account_id'] is None): 6701 raise ValueError("Missing the required parameter `account_id` when calling `get_document`") 6702 # verify the required parameter 'document_id' is set 6703 if ('document_id' not in params) or (params['document_id'] is None): 6704 raise ValueError("Missing the required parameter `document_id` when calling `get_document`") 6705 # verify the required parameter 'envelope_id' is set 6706 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6707 raise ValueError("Missing the required parameter `envelope_id` when calling `get_document`") 6708 6709 6710 collection_formats = {} 6711 6712 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}'.replace('{format}', 'json') 6713 path_params = {} 6714 if 'account_id' in params: 6715 path_params['accountId'] = params['account_id'] 6716 if 'document_id' in params: 6717 path_params['documentId'] = params['document_id'] 6718 if 'envelope_id' in params: 6719 path_params['envelopeId'] = params['envelope_id'] 6720 6721 query_params = {} 6722 if 'certificate' in params: 6723 query_params['certificate'] = params['certificate'] 6724 if 'documents_by_userid' in params: 6725 query_params['documents_by_userid'] = params['documents_by_userid'] 6726 if 'encoding' in params: 6727 query_params['encoding'] = params['encoding'] 6728 if 'encrypt' in params: 6729 query_params['encrypt'] = params['encrypt'] 6730 if 'language' in params: 6731 query_params['language'] = params['language'] 6732 if 'recipient_id' in params: 6733 query_params['recipient_id'] = params['recipient_id'] 6734 if 'shared_user_id' in params: 6735 query_params['shared_user_id'] = params['shared_user_id'] 6736 if 'show_changes' in params: 6737 query_params['show_changes'] = params['show_changes'] 6738 if 'watermark' in params: 6739 query_params['watermark'] = params['watermark'] 6740 6741 header_params = {} 6742 6743 form_params = [] 6744 local_var_files = {} 6745 6746 body_params = None 6747 # HTTP header `Accept` 6748 header_params['Accept'] = self.api_client.\ 6749 select_header_accept(['application/pdf']) 6750 6751 # Authentication setting 6752 auth_settings = [] 6753 6754 return self.api_client.call_api(resource_path, 'GET', 6755 path_params, 6756 query_params, 6757 header_params, 6758 body=body_params, 6759 post_params=form_params, 6760 files=local_var_files, 6761 response_type='file', 6762 auth_settings=auth_settings, 6763 callback=params.get('callback'), 6764 _return_http_data_only=params.get('_return_http_data_only'), 6765 _preload_content=params.get('_preload_content', True), 6766 _request_timeout=params.get('_request_timeout'), 6767 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)
6769 def get_document_page_image(self, account_id, document_id, envelope_id, page_number, **kwargs): 6770 """ 6771 Gets a page image from an envelope for display. 6772 Retrieves a page image for display from the specified envelope. 6773 This method makes a synchronous HTTP request by default. To make an 6774 asynchronous HTTP request, please define a `callback` function 6775 to be invoked when receiving the response. 6776 >>> def callback_function(response): 6777 >>> pprint(response) 6778 >>> 6779 >>> thread = api.get_document_page_image(account_id, document_id, envelope_id, page_number, callback=callback_function) 6780 6781 :param callback function: The callback function 6782 for asynchronous request. (optional) 6783 :param str account_id: The external account number (int) or account ID Guid. (required) 6784 :param str document_id: The ID of the document being accessed. (required) 6785 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6786 :param str page_number: The page number being accessed. (required) 6787 :param str dpi: Sets the dpi for the image. 6788 :param str max_height: Sets the maximum height for the page image in pixels. The dpi is recalculated based on this setting. 6789 :param str max_width: Sets the maximum width for the page image in pixels. The dpi is recalculated based on this setting. 6790 :param str show_changes: 6791 :return: file 6792 If the method is called asynchronously, 6793 returns the request thread. 6794 """ 6795 kwargs['_return_http_data_only'] = True 6796 if kwargs.get('callback'): 6797 return self.get_document_page_image_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 6798 else: 6799 (data) = self.get_document_page_image_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 6800 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)
6802 def get_document_page_image_with_http_info(self, account_id, document_id, envelope_id, page_number, **kwargs): 6803 """ 6804 Gets a page image from an envelope for display. 6805 Retrieves a page image for display from the specified envelope. 6806 This method makes a synchronous HTTP request by default. To make an 6807 asynchronous HTTP request, please define a `callback` function 6808 to be invoked when receiving the response. 6809 >>> def callback_function(response): 6810 >>> pprint(response) 6811 >>> 6812 >>> thread = api.get_document_page_image_with_http_info(account_id, document_id, envelope_id, page_number, callback=callback_function) 6813 6814 :param callback function: The callback function 6815 for asynchronous request. (optional) 6816 :param str account_id: The external account number (int) or account ID Guid. (required) 6817 :param str document_id: The ID of the document being accessed. (required) 6818 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6819 :param str page_number: The page number being accessed. (required) 6820 :param str dpi: Sets the dpi for the image. 6821 :param str max_height: Sets the maximum height for the page image in pixels. The dpi is recalculated based on this setting. 6822 :param str max_width: Sets the maximum width for the page image in pixels. The dpi is recalculated based on this setting. 6823 :param str show_changes: 6824 :return: file 6825 If the method is called asynchronously, 6826 returns the request thread. 6827 """ 6828 6829 all_params = ['account_id', 'document_id', 'envelope_id', 'page_number', 'dpi', 'max_height', 'max_width', 'show_changes'] 6830 all_params.append('callback') 6831 all_params.append('_return_http_data_only') 6832 all_params.append('_preload_content') 6833 all_params.append('_request_timeout') 6834 6835 params = locals() 6836 for key, val in iteritems(params['kwargs']): 6837 if key not in all_params: 6838 raise TypeError( 6839 "Got an unexpected keyword argument '%s'" 6840 " to method get_document_page_image" % key 6841 ) 6842 params[key] = val 6843 del params['kwargs'] 6844 # verify the required parameter 'account_id' is set 6845 if ('account_id' not in params) or (params['account_id'] is None): 6846 raise ValueError("Missing the required parameter `account_id` when calling `get_document_page_image`") 6847 # verify the required parameter 'document_id' is set 6848 if ('document_id' not in params) or (params['document_id'] is None): 6849 raise ValueError("Missing the required parameter `document_id` when calling `get_document_page_image`") 6850 # verify the required parameter 'envelope_id' is set 6851 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6852 raise ValueError("Missing the required parameter `envelope_id` when calling `get_document_page_image`") 6853 # verify the required parameter 'page_number' is set 6854 if ('page_number' not in params) or (params['page_number'] is None): 6855 raise ValueError("Missing the required parameter `page_number` when calling `get_document_page_image`") 6856 6857 6858 collection_formats = {} 6859 6860 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/pages/{pageNumber}/page_image'.replace('{format}', 'json') 6861 path_params = {} 6862 if 'account_id' in params: 6863 path_params['accountId'] = params['account_id'] 6864 if 'document_id' in params: 6865 path_params['documentId'] = params['document_id'] 6866 if 'envelope_id' in params: 6867 path_params['envelopeId'] = params['envelope_id'] 6868 if 'page_number' in params: 6869 path_params['pageNumber'] = params['page_number'] 6870 6871 query_params = {} 6872 if 'dpi' in params: 6873 query_params['dpi'] = params['dpi'] 6874 if 'max_height' in params: 6875 query_params['max_height'] = params['max_height'] 6876 if 'max_width' in params: 6877 query_params['max_width'] = params['max_width'] 6878 if 'show_changes' in params: 6879 query_params['show_changes'] = params['show_changes'] 6880 6881 header_params = {} 6882 6883 form_params = [] 6884 local_var_files = {} 6885 6886 body_params = None 6887 # HTTP header `Accept` 6888 header_params['Accept'] = self.api_client.\ 6889 select_header_accept(['image/png']) 6890 6891 # Authentication setting 6892 auth_settings = [] 6893 6894 return self.api_client.call_api(resource_path, 'GET', 6895 path_params, 6896 query_params, 6897 header_params, 6898 body=body_params, 6899 post_params=form_params, 6900 files=local_var_files, 6901 response_type='file', 6902 auth_settings=auth_settings, 6903 callback=params.get('callback'), 6904 _return_http_data_only=params.get('_return_http_data_only'), 6905 _preload_content=params.get('_preload_content', True), 6906 _request_timeout=params.get('_request_timeout'), 6907 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)
6909 def get_document_tabs(self, account_id, document_id, envelope_id, **kwargs): 6910 """ 6911 Returns tabs on the document. 6912 Returns the tabs on the document specified by `documentId` in the envelope specified by `envelopeId`. 6913 This method makes a synchronous HTTP request by default. To make an 6914 asynchronous HTTP request, please define a `callback` function 6915 to be invoked when receiving the response. 6916 >>> def callback_function(response): 6917 >>> pprint(response) 6918 >>> 6919 >>> thread = api.get_document_tabs(account_id, document_id, envelope_id, callback=callback_function) 6920 6921 :param callback function: The callback function 6922 for asynchronous request. (optional) 6923 :param str account_id: The external account number (int) or account ID Guid. (required) 6924 :param str document_id: The ID of the document being accessed. (required) 6925 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6926 :param str include_metadata: 6927 :param str page_numbers: 6928 :return: Tabs 6929 If the method is called asynchronously, 6930 returns the request thread. 6931 """ 6932 kwargs['_return_http_data_only'] = True 6933 if kwargs.get('callback'): 6934 return self.get_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 6935 else: 6936 (data) = self.get_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 6937 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)
6939 def get_document_tabs_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 6940 """ 6941 Returns tabs on the document. 6942 Returns the tabs on the document specified by `documentId` in the envelope specified by `envelopeId`. 6943 This method makes a synchronous HTTP request by default. To make an 6944 asynchronous HTTP request, please define a `callback` function 6945 to be invoked when receiving the response. 6946 >>> def callback_function(response): 6947 >>> pprint(response) 6948 >>> 6949 >>> thread = api.get_document_tabs_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 6950 6951 :param callback function: The callback function 6952 for asynchronous request. (optional) 6953 :param str account_id: The external account number (int) or account ID Guid. (required) 6954 :param str document_id: The ID of the document being accessed. (required) 6955 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 6956 :param str include_metadata: 6957 :param str page_numbers: 6958 :return: Tabs 6959 If the method is called asynchronously, 6960 returns the request thread. 6961 """ 6962 6963 all_params = ['account_id', 'document_id', 'envelope_id', 'include_metadata', 'page_numbers'] 6964 all_params.append('callback') 6965 all_params.append('_return_http_data_only') 6966 all_params.append('_preload_content') 6967 all_params.append('_request_timeout') 6968 6969 params = locals() 6970 for key, val in iteritems(params['kwargs']): 6971 if key not in all_params: 6972 raise TypeError( 6973 "Got an unexpected keyword argument '%s'" 6974 " to method get_document_tabs" % key 6975 ) 6976 params[key] = val 6977 del params['kwargs'] 6978 # verify the required parameter 'account_id' is set 6979 if ('account_id' not in params) or (params['account_id'] is None): 6980 raise ValueError("Missing the required parameter `account_id` when calling `get_document_tabs`") 6981 # verify the required parameter 'document_id' is set 6982 if ('document_id' not in params) or (params['document_id'] is None): 6983 raise ValueError("Missing the required parameter `document_id` when calling `get_document_tabs`") 6984 # verify the required parameter 'envelope_id' is set 6985 if ('envelope_id' not in params) or (params['envelope_id'] is None): 6986 raise ValueError("Missing the required parameter `envelope_id` when calling `get_document_tabs`") 6987 6988 6989 collection_formats = {} 6990 6991 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/tabs'.replace('{format}', 'json') 6992 path_params = {} 6993 if 'account_id' in params: 6994 path_params['accountId'] = params['account_id'] 6995 if 'document_id' in params: 6996 path_params['documentId'] = params['document_id'] 6997 if 'envelope_id' in params: 6998 path_params['envelopeId'] = params['envelope_id'] 6999 7000 query_params = {} 7001 if 'include_metadata' in params: 7002 query_params['include_metadata'] = params['include_metadata'] 7003 if 'page_numbers' in params: 7004 query_params['page_numbers'] = params['page_numbers'] 7005 7006 header_params = {} 7007 7008 form_params = [] 7009 local_var_files = {} 7010 7011 body_params = None 7012 # HTTP header `Accept` 7013 header_params['Accept'] = self.api_client.\ 7014 select_header_accept(['application/json']) 7015 7016 # Authentication setting 7017 auth_settings = [] 7018 7019 return self.api_client.call_api(resource_path, 'GET', 7020 path_params, 7021 query_params, 7022 header_params, 7023 body=body_params, 7024 post_params=form_params, 7025 files=local_var_files, 7026 response_type='Tabs', 7027 auth_settings=auth_settings, 7028 callback=params.get('callback'), 7029 _return_http_data_only=params.get('_return_http_data_only'), 7030 _preload_content=params.get('_preload_content', True), 7031 _request_timeout=params.get('_request_timeout'), 7032 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)
7034 def get_email_settings(self, account_id, envelope_id, **kwargs): 7035 """ 7036 Gets the email setting overrides for an envelope. 7037 Retrieves the email override settings for the specified envelope. 7038 This method makes a synchronous HTTP request by default. To make an 7039 asynchronous HTTP request, please define a `callback` function 7040 to be invoked when receiving the response. 7041 >>> def callback_function(response): 7042 >>> pprint(response) 7043 >>> 7044 >>> thread = api.get_email_settings(account_id, envelope_id, callback=callback_function) 7045 7046 :param callback function: The callback function 7047 for asynchronous request. (optional) 7048 :param str account_id: The external account number (int) or account ID Guid. (required) 7049 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7050 :return: EmailSettings 7051 If the method is called asynchronously, 7052 returns the request thread. 7053 """ 7054 kwargs['_return_http_data_only'] = True 7055 if kwargs.get('callback'): 7056 return self.get_email_settings_with_http_info(account_id, envelope_id, **kwargs) 7057 else: 7058 (data) = self.get_email_settings_with_http_info(account_id, envelope_id, **kwargs) 7059 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)
7061 def get_email_settings_with_http_info(self, account_id, envelope_id, **kwargs): 7062 """ 7063 Gets the email setting overrides for an envelope. 7064 Retrieves the email override settings for the specified envelope. 7065 This method makes a synchronous HTTP request by default. To make an 7066 asynchronous HTTP request, please define a `callback` function 7067 to be invoked when receiving the response. 7068 >>> def callback_function(response): 7069 >>> pprint(response) 7070 >>> 7071 >>> thread = api.get_email_settings_with_http_info(account_id, envelope_id, callback=callback_function) 7072 7073 :param callback function: The callback function 7074 for asynchronous request. (optional) 7075 :param str account_id: The external account number (int) or account ID Guid. (required) 7076 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7077 :return: EmailSettings 7078 If the method is called asynchronously, 7079 returns the request thread. 7080 """ 7081 7082 all_params = ['account_id', 'envelope_id'] 7083 all_params.append('callback') 7084 all_params.append('_return_http_data_only') 7085 all_params.append('_preload_content') 7086 all_params.append('_request_timeout') 7087 7088 params = locals() 7089 for key, val in iteritems(params['kwargs']): 7090 if key not in all_params: 7091 raise TypeError( 7092 "Got an unexpected keyword argument '%s'" 7093 " to method get_email_settings" % key 7094 ) 7095 params[key] = val 7096 del params['kwargs'] 7097 # verify the required parameter 'account_id' is set 7098 if ('account_id' not in params) or (params['account_id'] is None): 7099 raise ValueError("Missing the required parameter `account_id` when calling `get_email_settings`") 7100 # verify the required parameter 'envelope_id' is set 7101 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7102 raise ValueError("Missing the required parameter `envelope_id` when calling `get_email_settings`") 7103 7104 7105 collection_formats = {} 7106 7107 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/email_settings'.replace('{format}', 'json') 7108 path_params = {} 7109 if 'account_id' in params: 7110 path_params['accountId'] = params['account_id'] 7111 if 'envelope_id' in params: 7112 path_params['envelopeId'] = params['envelope_id'] 7113 7114 query_params = {} 7115 7116 header_params = {} 7117 7118 form_params = [] 7119 local_var_files = {} 7120 7121 body_params = None 7122 # HTTP header `Accept` 7123 header_params['Accept'] = self.api_client.\ 7124 select_header_accept(['application/json']) 7125 7126 # Authentication setting 7127 auth_settings = [] 7128 7129 return self.api_client.call_api(resource_path, 'GET', 7130 path_params, 7131 query_params, 7132 header_params, 7133 body=body_params, 7134 post_params=form_params, 7135 files=local_var_files, 7136 response_type='EmailSettings', 7137 auth_settings=auth_settings, 7138 callback=params.get('callback'), 7139 _return_http_data_only=params.get('_return_http_data_only'), 7140 _preload_content=params.get('_preload_content', True), 7141 _request_timeout=params.get('_request_timeout'), 7142 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)
7144 def get_envelope(self, account_id, envelope_id, **kwargs): 7145 """ 7146 Gets the status of a envelope. 7147 Retrieves the overall status for the specified envelope. 7148 This method makes a synchronous HTTP request by default. To make an 7149 asynchronous HTTP request, please define a `callback` function 7150 to be invoked when receiving the response. 7151 >>> def callback_function(response): 7152 >>> pprint(response) 7153 >>> 7154 >>> thread = api.get_envelope(account_id, envelope_id, callback=callback_function) 7155 7156 :param callback function: The callback function 7157 for asynchronous request. (optional) 7158 :param str account_id: The external account number (int) or account ID Guid. (required) 7159 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7160 :param str advanced_update: When true, envelope information can be added or modified. 7161 :param str include: 7162 :return: Envelope 7163 If the method is called asynchronously, 7164 returns the request thread. 7165 """ 7166 kwargs['_return_http_data_only'] = True 7167 if kwargs.get('callback'): 7168 return self.get_envelope_with_http_info(account_id, envelope_id, **kwargs) 7169 else: 7170 (data) = self.get_envelope_with_http_info(account_id, envelope_id, **kwargs) 7171 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:
Returns
Envelope If the method is called asynchronously, returns the request thread.
def
get_envelope_with_http_info(self, account_id, envelope_id, **kwargs)
7173 def get_envelope_with_http_info(self, account_id, envelope_id, **kwargs): 7174 """ 7175 Gets the status of a envelope. 7176 Retrieves the overall status for the specified envelope. 7177 This method makes a synchronous HTTP request by default. To make an 7178 asynchronous HTTP request, please define a `callback` function 7179 to be invoked when receiving the response. 7180 >>> def callback_function(response): 7181 >>> pprint(response) 7182 >>> 7183 >>> thread = api.get_envelope_with_http_info(account_id, envelope_id, callback=callback_function) 7184 7185 :param callback function: The callback function 7186 for asynchronous request. (optional) 7187 :param str account_id: The external account number (int) or account ID Guid. (required) 7188 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 7189 :param str advanced_update: When true, envelope information can be added or modified. 7190 :param str include: 7191 :return: Envelope 7192 If the method is called asynchronously, 7193 returns the request thread. 7194 """ 7195 7196 all_params = ['account_id', 'envelope_id', 'advanced_update', 'include'] 7197 all_params.append('callback') 7198 all_params.append('_return_http_data_only') 7199 all_params.append('_preload_content') 7200 all_params.append('_request_timeout') 7201 7202 params = locals() 7203 for key, val in iteritems(params['kwargs']): 7204 if key not in all_params: 7205 raise TypeError( 7206 "Got an unexpected keyword argument '%s'" 7207 " to method get_envelope" % key 7208 ) 7209 params[key] = val 7210 del params['kwargs'] 7211 # verify the required parameter 'account_id' is set 7212 if ('account_id' not in params) or (params['account_id'] is None): 7213 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope`") 7214 # verify the required parameter 'envelope_id' is set 7215 if ('envelope_id' not in params) or (params['envelope_id'] is None): 7216 raise ValueError("Missing the required parameter `envelope_id` when calling `get_envelope`") 7217 7218 7219 collection_formats = {} 7220 7221 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}'.replace('{format}', 'json') 7222 path_params = {} 7223 if 'account_id' in params: 7224 path_params['accountId'] = params['account_id'] 7225 if 'envelope_id' in params: 7226 path_params['envelopeId'] = params['envelope_id'] 7227 7228 query_params = {} 7229 if 'advanced_update' in params: 7230 query_params['advanced_update'] = params['advanced_update'] 7231 if 'include' in params: 7232 query_params['include'] = params['include'] 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)
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:
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)
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
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)
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)
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)
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
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)
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)
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)
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
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)
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)
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)
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
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)
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)
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)
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
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)
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)
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)
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
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)
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)
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)
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
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)
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)
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)
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
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)
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)
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)
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
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)
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)
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)
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
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)
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)
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)
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
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)
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)
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)
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
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)
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)
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)
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
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)
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)
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)
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
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)
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)
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)
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
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)
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)
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)
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
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)
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)
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)
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
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)
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)
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)
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
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)
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)
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)
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
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)
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)
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)
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
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)
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)
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)
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
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)
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)
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)
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
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)
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)
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)
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
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)
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)
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)
9906 def list_audit_events(self, account_id, envelope_id, **kwargs): 9907 """ 9908 Gets the envelope audit events for an envelope. 9909 Gets the envelope audit events for the specified envelope. 9910 This method makes a synchronous HTTP request by default. To make an 9911 asynchronous HTTP request, please define a `callback` function 9912 to be invoked when receiving the response. 9913 >>> def callback_function(response): 9914 >>> pprint(response) 9915 >>> 9916 >>> thread = api.list_audit_events(account_id, envelope_id, callback=callback_function) 9917 9918 :param callback function: The callback function 9919 for asynchronous request. (optional) 9920 :param str account_id: The external account number (int) or account ID Guid. (required) 9921 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9922 :return: EnvelopeAuditEventResponse 9923 If the method is called asynchronously, 9924 returns the request thread. 9925 """ 9926 kwargs['_return_http_data_only'] = True 9927 if kwargs.get('callback'): 9928 return self.list_audit_events_with_http_info(account_id, envelope_id, **kwargs) 9929 else: 9930 (data) = self.list_audit_events_with_http_info(account_id, envelope_id, **kwargs) 9931 return data
Gets the envelope audit events for an envelope.
Gets the envelope audit events for the specified envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_audit_events(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
EnvelopeAuditEventResponse If the method is called asynchronously, returns the request thread.
def
list_audit_events_with_http_info(self, account_id, envelope_id, **kwargs)
9933 def list_audit_events_with_http_info(self, account_id, envelope_id, **kwargs): 9934 """ 9935 Gets the envelope audit events for an envelope. 9936 Gets the envelope audit events for the specified envelope. 9937 This method makes a synchronous HTTP request by default. To make an 9938 asynchronous HTTP request, please define a `callback` function 9939 to be invoked when receiving the response. 9940 >>> def callback_function(response): 9941 >>> pprint(response) 9942 >>> 9943 >>> thread = api.list_audit_events_with_http_info(account_id, envelope_id, callback=callback_function) 9944 9945 :param callback function: The callback function 9946 for asynchronous request. (optional) 9947 :param str account_id: The external account number (int) or account ID Guid. (required) 9948 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 9949 :return: EnvelopeAuditEventResponse 9950 If the method is called asynchronously, 9951 returns the request thread. 9952 """ 9953 9954 all_params = ['account_id', 'envelope_id'] 9955 all_params.append('callback') 9956 all_params.append('_return_http_data_only') 9957 all_params.append('_preload_content') 9958 all_params.append('_request_timeout') 9959 9960 params = locals() 9961 for key, val in iteritems(params['kwargs']): 9962 if key not in all_params: 9963 raise TypeError( 9964 "Got an unexpected keyword argument '%s'" 9965 " to method list_audit_events" % key 9966 ) 9967 params[key] = val 9968 del params['kwargs'] 9969 # verify the required parameter 'account_id' is set 9970 if ('account_id' not in params) or (params['account_id'] is None): 9971 raise ValueError("Missing the required parameter `account_id` when calling `list_audit_events`") 9972 # verify the required parameter 'envelope_id' is set 9973 if ('envelope_id' not in params) or (params['envelope_id'] is None): 9974 raise ValueError("Missing the required parameter `envelope_id` when calling `list_audit_events`") 9975 9976 9977 collection_formats = {} 9978 9979 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/audit_events'.replace('{format}', 'json') 9980 path_params = {} 9981 if 'account_id' in params: 9982 path_params['accountId'] = params['account_id'] 9983 if 'envelope_id' in params: 9984 path_params['envelopeId'] = params['envelope_id'] 9985 9986 query_params = {} 9987 9988 header_params = {} 9989 9990 form_params = [] 9991 local_var_files = {} 9992 9993 body_params = None 9994 # HTTP header `Accept` 9995 header_params['Accept'] = self.api_client.\ 9996 select_header_accept(['application/json']) 9997 9998 # Authentication setting 9999 auth_settings = [] 10000 10001 return self.api_client.call_api(resource_path, 'GET', 10002 path_params, 10003 query_params, 10004 header_params, 10005 body=body_params, 10006 post_params=form_params, 10007 files=local_var_files, 10008 response_type='EnvelopeAuditEventResponse', 10009 auth_settings=auth_settings, 10010 callback=params.get('callback'), 10011 _return_http_data_only=params.get('_return_http_data_only'), 10012 _preload_content=params.get('_preload_content', True), 10013 _request_timeout=params.get('_request_timeout'), 10014 collection_formats=collection_formats)
Gets the envelope audit events for an envelope.
Gets the envelope audit events for the specified envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_audit_events_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
Returns
EnvelopeAuditEventResponse If the method is called asynchronously, returns the request thread.
def
list_custom_fields(self, account_id, envelope_id, **kwargs)
10016 def list_custom_fields(self, account_id, envelope_id, **kwargs): 10017 """ 10018 Gets the custom field information for the specified envelope. 10019 Retrieves the custom field information for the specified envelope. You can use these fields in the envelopes for your account to record information about the envelope, help search for envelopes, and track information. The envelope custom fields are shown in the Envelope Settings section when a user is creating an envelope in the DocuSign member console. The envelope custom fields are not seen by the envelope recipients. There are two types of envelope custom fields, text, and list. A text custom field lets the sender enter the value for the field. With a list custom field, the sender selects the value of the field from a pre-made list. 10020 This method makes a synchronous HTTP request by default. To make an 10021 asynchronous HTTP request, please define a `callback` function 10022 to be invoked when receiving the response. 10023 >>> def callback_function(response): 10024 >>> pprint(response) 10025 >>> 10026 >>> thread = api.list_custom_fields(account_id, envelope_id, callback=callback_function) 10027 10028 :param callback function: The callback function 10029 for asynchronous request. (optional) 10030 :param str account_id: The external account number (int) or account ID Guid. (required) 10031 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10032 :return: CustomFieldsEnvelope 10033 If the method is called asynchronously, 10034 returns the request thread. 10035 """ 10036 kwargs['_return_http_data_only'] = True 10037 if kwargs.get('callback'): 10038 return self.list_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 10039 else: 10040 (data) = self.list_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 10041 return data
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)
10043 def list_custom_fields_with_http_info(self, account_id, envelope_id, **kwargs): 10044 """ 10045 Gets the custom field information for the specified envelope. 10046 Retrieves the custom field information for the specified envelope. You can use these fields in the envelopes for your account to record information about the envelope, help search for envelopes, and track information. The envelope custom fields are shown in the Envelope Settings section when a user is creating an envelope in the DocuSign member console. The envelope custom fields are not seen by the envelope recipients. There are two types of envelope custom fields, text, and list. A text custom field lets the sender enter the value for the field. With a list custom field, the sender selects the value of the field from a pre-made list. 10047 This method makes a synchronous HTTP request by default. To make an 10048 asynchronous HTTP request, please define a `callback` function 10049 to be invoked when receiving the response. 10050 >>> def callback_function(response): 10051 >>> pprint(response) 10052 >>> 10053 >>> thread = api.list_custom_fields_with_http_info(account_id, envelope_id, callback=callback_function) 10054 10055 :param callback function: The callback function 10056 for asynchronous request. (optional) 10057 :param str account_id: The external account number (int) or account ID Guid. (required) 10058 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10059 :return: CustomFieldsEnvelope 10060 If the method is called asynchronously, 10061 returns the request thread. 10062 """ 10063 10064 all_params = ['account_id', 'envelope_id'] 10065 all_params.append('callback') 10066 all_params.append('_return_http_data_only') 10067 all_params.append('_preload_content') 10068 all_params.append('_request_timeout') 10069 10070 params = locals() 10071 for key, val in iteritems(params['kwargs']): 10072 if key not in all_params: 10073 raise TypeError( 10074 "Got an unexpected keyword argument '%s'" 10075 " to method list_custom_fields" % key 10076 ) 10077 params[key] = val 10078 del params['kwargs'] 10079 # verify the required parameter 'account_id' is set 10080 if ('account_id' not in params) or (params['account_id'] is None): 10081 raise ValueError("Missing the required parameter `account_id` when calling `list_custom_fields`") 10082 # verify the required parameter 'envelope_id' is set 10083 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10084 raise ValueError("Missing the required parameter `envelope_id` when calling `list_custom_fields`") 10085 10086 10087 collection_formats = {} 10088 10089 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/custom_fields'.replace('{format}', 'json') 10090 path_params = {} 10091 if 'account_id' in params: 10092 path_params['accountId'] = params['account_id'] 10093 if 'envelope_id' in params: 10094 path_params['envelopeId'] = params['envelope_id'] 10095 10096 query_params = {} 10097 10098 header_params = {} 10099 10100 form_params = [] 10101 local_var_files = {} 10102 10103 body_params = None 10104 # HTTP header `Accept` 10105 header_params['Accept'] = self.api_client.\ 10106 select_header_accept(['application/json']) 10107 10108 # Authentication setting 10109 auth_settings = [] 10110 10111 return self.api_client.call_api(resource_path, 'GET', 10112 path_params, 10113 query_params, 10114 header_params, 10115 body=body_params, 10116 post_params=form_params, 10117 files=local_var_files, 10118 response_type='CustomFieldsEnvelope', 10119 auth_settings=auth_settings, 10120 callback=params.get('callback'), 10121 _return_http_data_only=params.get('_return_http_data_only'), 10122 _preload_content=params.get('_preload_content', True), 10123 _request_timeout=params.get('_request_timeout'), 10124 collection_formats=collection_formats)
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)
10126 def list_document_fields(self, account_id, document_id, envelope_id, **kwargs): 10127 """ 10128 Gets the custom document fields from an existing envelope document. 10129 Retrieves the custom document field information from an existing envelope document. 10130 This method makes a synchronous HTTP request by default. To make an 10131 asynchronous HTTP request, please define a `callback` function 10132 to be invoked when receiving the response. 10133 >>> def callback_function(response): 10134 >>> pprint(response) 10135 >>> 10136 >>> thread = api.list_document_fields(account_id, document_id, envelope_id, callback=callback_function) 10137 10138 :param callback function: The callback function 10139 for asynchronous request. (optional) 10140 :param str account_id: The external account number (int) or account ID Guid. (required) 10141 :param str document_id: The ID of the document being accessed. (required) 10142 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10143 :return: DocumentFieldsInformation 10144 If the method is called asynchronously, 10145 returns the request thread. 10146 """ 10147 kwargs['_return_http_data_only'] = True 10148 if kwargs.get('callback'): 10149 return self.list_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 10150 else: 10151 (data) = self.list_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 10152 return data
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)
10154 def list_document_fields_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 10155 """ 10156 Gets the custom document fields from an existing envelope document. 10157 Retrieves the custom document field information from an existing envelope document. 10158 This method makes a synchronous HTTP request by default. To make an 10159 asynchronous HTTP request, please define a `callback` function 10160 to be invoked when receiving the response. 10161 >>> def callback_function(response): 10162 >>> pprint(response) 10163 >>> 10164 >>> thread = api.list_document_fields_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 10165 10166 :param callback function: The callback function 10167 for asynchronous request. (optional) 10168 :param str account_id: The external account number (int) or account ID Guid. (required) 10169 :param str document_id: The ID of the document being accessed. (required) 10170 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10171 :return: DocumentFieldsInformation 10172 If the method is called asynchronously, 10173 returns the request thread. 10174 """ 10175 10176 all_params = ['account_id', 'document_id', 'envelope_id'] 10177 all_params.append('callback') 10178 all_params.append('_return_http_data_only') 10179 all_params.append('_preload_content') 10180 all_params.append('_request_timeout') 10181 10182 params = locals() 10183 for key, val in iteritems(params['kwargs']): 10184 if key not in all_params: 10185 raise TypeError( 10186 "Got an unexpected keyword argument '%s'" 10187 " to method list_document_fields" % key 10188 ) 10189 params[key] = val 10190 del params['kwargs'] 10191 # verify the required parameter 'account_id' is set 10192 if ('account_id' not in params) or (params['account_id'] is None): 10193 raise ValueError("Missing the required parameter `account_id` when calling `list_document_fields`") 10194 # verify the required parameter 'document_id' is set 10195 if ('document_id' not in params) or (params['document_id'] is None): 10196 raise ValueError("Missing the required parameter `document_id` when calling `list_document_fields`") 10197 # verify the required parameter 'envelope_id' is set 10198 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10199 raise ValueError("Missing the required parameter `envelope_id` when calling `list_document_fields`") 10200 10201 10202 collection_formats = {} 10203 10204 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/fields'.replace('{format}', 'json') 10205 path_params = {} 10206 if 'account_id' in params: 10207 path_params['accountId'] = params['account_id'] 10208 if 'document_id' in params: 10209 path_params['documentId'] = params['document_id'] 10210 if 'envelope_id' in params: 10211 path_params['envelopeId'] = params['envelope_id'] 10212 10213 query_params = {} 10214 10215 header_params = {} 10216 10217 form_params = [] 10218 local_var_files = {} 10219 10220 body_params = None 10221 # HTTP header `Accept` 10222 header_params['Accept'] = self.api_client.\ 10223 select_header_accept(['application/json']) 10224 10225 # Authentication setting 10226 auth_settings = [] 10227 10228 return self.api_client.call_api(resource_path, 'GET', 10229 path_params, 10230 query_params, 10231 header_params, 10232 body=body_params, 10233 post_params=form_params, 10234 files=local_var_files, 10235 response_type='DocumentFieldsInformation', 10236 auth_settings=auth_settings, 10237 callback=params.get('callback'), 10238 _return_http_data_only=params.get('_return_http_data_only'), 10239 _preload_content=params.get('_preload_content', True), 10240 _request_timeout=params.get('_request_timeout'), 10241 collection_formats=collection_formats)
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)
10243 def list_documents(self, account_id, envelope_id, **kwargs): 10244 """ 10245 Gets a list of envelope documents. 10246 Retrieves a list of documents associated with the specified envelope. 10247 This method makes a synchronous HTTP request by default. To make an 10248 asynchronous HTTP request, please define a `callback` function 10249 to be invoked when receiving the response. 10250 >>> def callback_function(response): 10251 >>> pprint(response) 10252 >>> 10253 >>> thread = api.list_documents(account_id, envelope_id, callback=callback_function) 10254 10255 :param callback function: The callback function 10256 for asynchronous request. (optional) 10257 :param str account_id: The external account number (int) or account ID Guid. (required) 10258 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10259 :param str documents_by_userid: 10260 :param str include_docgen_formfields: 10261 :param str include_document_size: 10262 :param str include_metadata: 10263 :param str include_tabs: 10264 :param str recipient_id: 10265 :param str shared_user_id: 10266 :return: EnvelopeDocumentsResult 10267 If the method is called asynchronously, 10268 returns the request thread. 10269 """ 10270 kwargs['_return_http_data_only'] = True 10271 if kwargs.get('callback'): 10272 return self.list_documents_with_http_info(account_id, envelope_id, **kwargs) 10273 else: 10274 (data) = self.list_documents_with_http_info(account_id, envelope_id, **kwargs) 10275 return data
Gets a list of envelope documents.
Retrieves a list of documents associated with the specified envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_documents(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str documents_by_userid:
- str include_docgen_formfields:
- str include_document_size:
- str include_metadata:
- str include_tabs:
- str recipient_id:
- str shared_user_id:
Returns
EnvelopeDocumentsResult If the method is called asynchronously, returns the request thread.
def
list_documents_with_http_info(self, account_id, envelope_id, **kwargs)
10277 def list_documents_with_http_info(self, account_id, envelope_id, **kwargs): 10278 """ 10279 Gets a list of envelope documents. 10280 Retrieves a list of documents associated with the specified envelope. 10281 This method makes a synchronous HTTP request by default. To make an 10282 asynchronous HTTP request, please define a `callback` function 10283 to be invoked when receiving the response. 10284 >>> def callback_function(response): 10285 >>> pprint(response) 10286 >>> 10287 >>> thread = api.list_documents_with_http_info(account_id, envelope_id, callback=callback_function) 10288 10289 :param callback function: The callback function 10290 for asynchronous request. (optional) 10291 :param str account_id: The external account number (int) or account ID Guid. (required) 10292 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10293 :param str documents_by_userid: 10294 :param str include_docgen_formfields: 10295 :param str include_document_size: 10296 :param str include_metadata: 10297 :param str include_tabs: 10298 :param str recipient_id: 10299 :param str shared_user_id: 10300 :return: EnvelopeDocumentsResult 10301 If the method is called asynchronously, 10302 returns the request thread. 10303 """ 10304 10305 all_params = ['account_id', 'envelope_id', 'documents_by_userid', 'include_docgen_formfields', 'include_document_size', 'include_metadata', 'include_tabs', 'recipient_id', 'shared_user_id'] 10306 all_params.append('callback') 10307 all_params.append('_return_http_data_only') 10308 all_params.append('_preload_content') 10309 all_params.append('_request_timeout') 10310 10311 params = locals() 10312 for key, val in iteritems(params['kwargs']): 10313 if key not in all_params: 10314 raise TypeError( 10315 "Got an unexpected keyword argument '%s'" 10316 " to method list_documents" % key 10317 ) 10318 params[key] = val 10319 del params['kwargs'] 10320 # verify the required parameter 'account_id' is set 10321 if ('account_id' not in params) or (params['account_id'] is None): 10322 raise ValueError("Missing the required parameter `account_id` when calling `list_documents`") 10323 # verify the required parameter 'envelope_id' is set 10324 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10325 raise ValueError("Missing the required parameter `envelope_id` when calling `list_documents`") 10326 10327 10328 collection_formats = {} 10329 10330 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents'.replace('{format}', 'json') 10331 path_params = {} 10332 if 'account_id' in params: 10333 path_params['accountId'] = params['account_id'] 10334 if 'envelope_id' in params: 10335 path_params['envelopeId'] = params['envelope_id'] 10336 10337 query_params = {} 10338 if 'documents_by_userid' in params: 10339 query_params['documents_by_userid'] = params['documents_by_userid'] 10340 if 'include_docgen_formfields' in params: 10341 query_params['include_docgen_formfields'] = params['include_docgen_formfields'] 10342 if 'include_document_size' in params: 10343 query_params['include_document_size'] = params['include_document_size'] 10344 if 'include_metadata' in params: 10345 query_params['include_metadata'] = params['include_metadata'] 10346 if 'include_tabs' in params: 10347 query_params['include_tabs'] = params['include_tabs'] 10348 if 'recipient_id' in params: 10349 query_params['recipient_id'] = params['recipient_id'] 10350 if 'shared_user_id' in params: 10351 query_params['shared_user_id'] = params['shared_user_id'] 10352 10353 header_params = {} 10354 10355 form_params = [] 10356 local_var_files = {} 10357 10358 body_params = None 10359 # HTTP header `Accept` 10360 header_params['Accept'] = self.api_client.\ 10361 select_header_accept(['application/json']) 10362 10363 # Authentication setting 10364 auth_settings = [] 10365 10366 return self.api_client.call_api(resource_path, 'GET', 10367 path_params, 10368 query_params, 10369 header_params, 10370 body=body_params, 10371 post_params=form_params, 10372 files=local_var_files, 10373 response_type='EnvelopeDocumentsResult', 10374 auth_settings=auth_settings, 10375 callback=params.get('callback'), 10376 _return_http_data_only=params.get('_return_http_data_only'), 10377 _preload_content=params.get('_preload_content', True), 10378 _request_timeout=params.get('_request_timeout'), 10379 collection_formats=collection_formats)
Gets a list of envelope documents.
Retrieves a list of documents associated with the specified envelope.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_documents_with_http_info(account_id, envelope_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str envelope_id: The envelopeId Guid of the envelope being accessed. (required)
- str documents_by_userid:
- str include_docgen_formfields:
- str include_document_size:
- str include_metadata:
- str include_tabs:
- str recipient_id:
- str shared_user_id:
Returns
EnvelopeDocumentsResult If the method is called asynchronously, returns the request thread.
def
list_recipients(self, account_id, envelope_id, **kwargs)
10381 def list_recipients(self, account_id, envelope_id, **kwargs): 10382 """ 10383 Gets the status of recipients for an envelope. 10384 Retrieves the status of all recipients in a single envelope and identifies the current recipient in the routing list. The `currentRoutingOrder` property of the response contains the `routingOrder` value of the current recipient indicating that the envelope has been sent to the recipient, but the recipient has not completed their actions. 10385 This method makes a synchronous HTTP request by default. To make an 10386 asynchronous HTTP request, please define a `callback` function 10387 to be invoked when receiving the response. 10388 >>> def callback_function(response): 10389 >>> pprint(response) 10390 >>> 10391 >>> thread = api.list_recipients(account_id, envelope_id, callback=callback_function) 10392 10393 :param callback function: The callback function 10394 for asynchronous request. (optional) 10395 :param str account_id: The external account number (int) or account ID Guid. (required) 10396 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10397 :param str include_anchor_tab_locations: When set to **true** and `include_tabs` is set to **true**, all tabs with anchor tab properties are included in the response. 10398 :param str include_extended: When set to **true**, the extended properties are included in the response. 10399 :param str include_metadata: 10400 :param str include_tabs: When set to **true**, the tab information associated with the recipient is included in the response. 10401 :return: Recipients 10402 If the method is called asynchronously, 10403 returns the request thread. 10404 """ 10405 kwargs['_return_http_data_only'] = True 10406 if kwargs.get('callback'): 10407 return self.list_recipients_with_http_info(account_id, envelope_id, **kwargs) 10408 else: 10409 (data) = self.list_recipients_with_http_info(account_id, envelope_id, **kwargs) 10410 return data
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)
10412 def list_recipients_with_http_info(self, account_id, envelope_id, **kwargs): 10413 """ 10414 Gets the status of recipients for an envelope. 10415 Retrieves the status of all recipients in a single envelope and identifies the current recipient in the routing list. The `currentRoutingOrder` property of the response contains the `routingOrder` value of the current recipient indicating that the envelope has been sent to the recipient, but the recipient has not completed their actions. 10416 This method makes a synchronous HTTP request by default. To make an 10417 asynchronous HTTP request, please define a `callback` function 10418 to be invoked when receiving the response. 10419 >>> def callback_function(response): 10420 >>> pprint(response) 10421 >>> 10422 >>> thread = api.list_recipients_with_http_info(account_id, envelope_id, callback=callback_function) 10423 10424 :param callback function: The callback function 10425 for asynchronous request. (optional) 10426 :param str account_id: The external account number (int) or account ID Guid. (required) 10427 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10428 :param str include_anchor_tab_locations: When set to **true** and `include_tabs` is set to **true**, all tabs with anchor tab properties are included in the response. 10429 :param str include_extended: When set to **true**, the extended properties are included in the response. 10430 :param str include_metadata: 10431 :param str include_tabs: When set to **true**, the tab information associated with the recipient is included in the response. 10432 :return: Recipients 10433 If the method is called asynchronously, 10434 returns the request thread. 10435 """ 10436 10437 all_params = ['account_id', 'envelope_id', 'include_anchor_tab_locations', 'include_extended', 'include_metadata', 'include_tabs'] 10438 all_params.append('callback') 10439 all_params.append('_return_http_data_only') 10440 all_params.append('_preload_content') 10441 all_params.append('_request_timeout') 10442 10443 params = locals() 10444 for key, val in iteritems(params['kwargs']): 10445 if key not in all_params: 10446 raise TypeError( 10447 "Got an unexpected keyword argument '%s'" 10448 " to method list_recipients" % key 10449 ) 10450 params[key] = val 10451 del params['kwargs'] 10452 # verify the required parameter 'account_id' is set 10453 if ('account_id' not in params) or (params['account_id'] is None): 10454 raise ValueError("Missing the required parameter `account_id` when calling `list_recipients`") 10455 # verify the required parameter 'envelope_id' is set 10456 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10457 raise ValueError("Missing the required parameter `envelope_id` when calling `list_recipients`") 10458 10459 10460 collection_formats = {} 10461 10462 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients'.replace('{format}', 'json') 10463 path_params = {} 10464 if 'account_id' in params: 10465 path_params['accountId'] = params['account_id'] 10466 if 'envelope_id' in params: 10467 path_params['envelopeId'] = params['envelope_id'] 10468 10469 query_params = {} 10470 if 'include_anchor_tab_locations' in params: 10471 query_params['include_anchor_tab_locations'] = params['include_anchor_tab_locations'] 10472 if 'include_extended' in params: 10473 query_params['include_extended'] = params['include_extended'] 10474 if 'include_metadata' in params: 10475 query_params['include_metadata'] = params['include_metadata'] 10476 if 'include_tabs' in params: 10477 query_params['include_tabs'] = params['include_tabs'] 10478 10479 header_params = {} 10480 10481 form_params = [] 10482 local_var_files = {} 10483 10484 body_params = None 10485 # HTTP header `Accept` 10486 header_params['Accept'] = self.api_client.\ 10487 select_header_accept(['application/json']) 10488 10489 # Authentication setting 10490 auth_settings = [] 10491 10492 return self.api_client.call_api(resource_path, 'GET', 10493 path_params, 10494 query_params, 10495 header_params, 10496 body=body_params, 10497 post_params=form_params, 10498 files=local_var_files, 10499 response_type='Recipients', 10500 auth_settings=auth_settings, 10501 callback=params.get('callback'), 10502 _return_http_data_only=params.get('_return_http_data_only'), 10503 _preload_content=params.get('_preload_content', True), 10504 _request_timeout=params.get('_request_timeout'), 10505 collection_formats=collection_formats)
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)
10507 def list_status(self, account_id, **kwargs): 10508 """ 10509 Gets the envelope status for the specified envelopes. 10510 Retrieves the envelope status for the specified envelopes. 10511 This method makes a synchronous HTTP request by default. To make an 10512 asynchronous HTTP request, please define a `callback` function 10513 to be invoked when receiving the response. 10514 >>> def callback_function(response): 10515 >>> pprint(response) 10516 >>> 10517 >>> thread = api.list_status(account_id, callback=callback_function) 10518 10519 :param callback function: The callback function 10520 for asynchronous request. (optional) 10521 :param str account_id: The external account number (int) or account ID Guid. (required) 10522 :param str ac_status: 10523 :param str block: 10524 :param str count: 10525 :param str email: 10526 :param str envelope_ids: 10527 :param str from_date: 10528 :param str from_to_status: 10529 :param str start_position: 10530 :param str status: 10531 :param str to_date: 10532 :param str transaction_ids: 10533 :param str user_name: 10534 :param EnvelopeIdsRequest envelope_ids_request: 10535 :return: EnvelopesInformation 10536 If the method is called asynchronously, 10537 returns the request thread. 10538 """ 10539 kwargs['_return_http_data_only'] = True 10540 if kwargs.get('callback'): 10541 return self.list_status_with_http_info(account_id, **kwargs) 10542 else: 10543 (data) = self.list_status_with_http_info(account_id, **kwargs) 10544 return data
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)
10546 def list_status_with_http_info(self, account_id, **kwargs): 10547 """ 10548 Gets the envelope status for the specified envelopes. 10549 Retrieves the envelope status for the specified envelopes. 10550 This method makes a synchronous HTTP request by default. To make an 10551 asynchronous HTTP request, please define a `callback` function 10552 to be invoked when receiving the response. 10553 >>> def callback_function(response): 10554 >>> pprint(response) 10555 >>> 10556 >>> thread = api.list_status_with_http_info(account_id, callback=callback_function) 10557 10558 :param callback function: The callback function 10559 for asynchronous request. (optional) 10560 :param str account_id: The external account number (int) or account ID Guid. (required) 10561 :param str ac_status: 10562 :param str block: 10563 :param str count: 10564 :param str email: 10565 :param str envelope_ids: 10566 :param str from_date: 10567 :param str from_to_status: 10568 :param str start_position: 10569 :param str status: 10570 :param str to_date: 10571 :param str transaction_ids: 10572 :param str user_name: 10573 :param EnvelopeIdsRequest envelope_ids_request: 10574 :return: EnvelopesInformation 10575 If the method is called asynchronously, 10576 returns the request thread. 10577 """ 10578 10579 all_params = ['account_id', 'ac_status', 'block', 'count', 'email', 'envelope_ids', 'from_date', 'from_to_status', 'start_position', 'status', 'to_date', 'transaction_ids', 'user_name', 'envelope_ids_request'] 10580 all_params.append('callback') 10581 all_params.append('_return_http_data_only') 10582 all_params.append('_preload_content') 10583 all_params.append('_request_timeout') 10584 10585 params = locals() 10586 for key, val in iteritems(params['kwargs']): 10587 if key not in all_params: 10588 raise TypeError( 10589 "Got an unexpected keyword argument '%s'" 10590 " to method list_status" % key 10591 ) 10592 params[key] = val 10593 del params['kwargs'] 10594 # verify the required parameter 'account_id' is set 10595 if ('account_id' not in params) or (params['account_id'] is None): 10596 raise ValueError("Missing the required parameter `account_id` when calling `list_status`") 10597 10598 10599 collection_formats = {} 10600 10601 resource_path = '/v2.1/accounts/{accountId}/envelopes/status'.replace('{format}', 'json') 10602 path_params = {} 10603 if 'account_id' in params: 10604 path_params['accountId'] = params['account_id'] 10605 10606 query_params = {} 10607 if 'ac_status' in params: 10608 query_params['ac_status'] = params['ac_status'] 10609 if 'block' in params: 10610 query_params['block'] = params['block'] 10611 if 'count' in params: 10612 query_params['count'] = params['count'] 10613 if 'email' in params: 10614 query_params['email'] = params['email'] 10615 if 'envelope_ids' in params: 10616 query_params['envelope_ids'] = params['envelope_ids'] 10617 if 'from_date' in params: 10618 query_params['from_date'] = params['from_date'] 10619 if 'from_to_status' in params: 10620 query_params['from_to_status'] = params['from_to_status'] 10621 if 'start_position' in params: 10622 query_params['start_position'] = params['start_position'] 10623 if 'status' in params: 10624 query_params['status'] = params['status'] 10625 if 'to_date' in params: 10626 query_params['to_date'] = params['to_date'] 10627 if 'transaction_ids' in params: 10628 query_params['transaction_ids'] = params['transaction_ids'] 10629 if 'user_name' in params: 10630 query_params['user_name'] = params['user_name'] 10631 10632 header_params = {} 10633 10634 form_params = [] 10635 local_var_files = {} 10636 10637 body_params = None 10638 if 'envelope_ids_request' in params: 10639 body_params = params['envelope_ids_request'] 10640 # HTTP header `Accept` 10641 header_params['Accept'] = self.api_client.\ 10642 select_header_accept(['application/json']) 10643 10644 # Authentication setting 10645 auth_settings = [] 10646 10647 return self.api_client.call_api(resource_path, 'PUT', 10648 path_params, 10649 query_params, 10650 header_params, 10651 body=body_params, 10652 post_params=form_params, 10653 files=local_var_files, 10654 response_type='EnvelopesInformation', 10655 auth_settings=auth_settings, 10656 callback=params.get('callback'), 10657 _return_http_data_only=params.get('_return_http_data_only'), 10658 _preload_content=params.get('_preload_content', True), 10659 _request_timeout=params.get('_request_timeout'), 10660 collection_formats=collection_formats)
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)
10662 def list_status_changes(self, account_id, **kwargs): 10663 """ 10664 Gets status changes for one or more envelopes. 10665 Retrieves envelope status changes for all envelopes. You can modify the information returned by adding query strings to limit the request to check between certain dates and times, or for certain envelopes, or for certain status codes. It is recommended that you use one or more of the query strings in order to limit the size of the response. ### Important: Unless you are requesting the status for specific envelopes (using the `envelopeIds` or `transactionIds` properties), you must add a set the `from_date` property in the request. Getting envelope status using `transactionIds` is useful for offline signing situations where it can be used determine if an envelope was created or not, for the cases where a network connection was lost, before the envelope status could be returned. ### Request Envelope Status Notes ### The REST API GET /envelopes call uses certain filters to find results. In some cases requests are check for \"any status change\" instead of the just the single status requested. In these cases, more envelopes might be returned by the request than otherwise would be. For example, for a request with the begin date is set to Jan 1st, an end date set to Jan 7th and the status qualifier (`from_to_status`) set to `Delivered` — the response set might contain envelopes that were created during that time period, but not delivered during the time period. To avoid unnecessary database queries, the DocuSign system checks requests to ensure that the added filters will not result in a zero-size response before acting on the request. The following table shows the valid envelope statuses (in the Valid Current Statuses column) for the status qualifiers in the request. If the status and status qualifiers in the API request do not contain any of the values shown in the valid current statuses column, then an empty list is returned. For example, a request with a status qualifier (from_to_status) of `Delivered` and a status of \"`Created`,`Sent`\", DocuSign will always return an empty list. This is because the request essentially translates to: find the envelopes that were delivered between the begin and end dates that have a current status of `Created` or `Sent`, and since an envelope that has been delivered can never have a status of `Created` or `Sent`, a zero-size response would be generated. In this case, DocuSign does not run the request, but just returns the empty list. Client applications should check that the statuses they are requesting make sense for a given status qualifier. 10666 This method makes a synchronous HTTP request by default. To make an 10667 asynchronous HTTP request, please define a `callback` function 10668 to be invoked when receiving the response. 10669 >>> def callback_function(response): 10670 >>> pprint(response) 10671 >>> 10672 >>> thread = api.list_status_changes(account_id, callback=callback_function) 10673 10674 :param callback function: The callback function 10675 for asynchronous request. (optional) 10676 :param str account_id: The external account number (int) or account ID Guid. (required) 10677 :param str ac_status: Specifies the Authoritative Copy Status for the envelopes. The possible values are: Unknown, Original, Transferred, AuthoritativeCopy, AuthoritativeCopyExportPending, AuthoritativeCopyExported, DepositPending, Deposited, DepositedEO, or DepositFailed. 10678 :param str block: 10679 :param str cdse_mode: 10680 :param str continuation_token: 10681 :param str count: 10682 :param str custom_field: This specifies the envelope custom field name and value searched for in the envelope information. The value portion of the query can use partial strings by adding '%' (percent sign) around the custom field query value. Example 1: If you have an envelope custom field called \"Region\" and you want to search for all envelopes where the value is \"West\" you would use the query: `?custom_field=Region=West`. Example 2: To search for envelopes where the `ApplicationID` custom field has the value or partial value of \"DocuSign\" in field, the query would be: `?custom_field=ApplicationId=%DocuSign%` This would find envelopes where the custom field value is \"DocuSign for Salesforce\" or \"DocuSign envelope.\" 10683 :param str email: 10684 :param str envelope_ids: 10685 :param str exclude: 10686 :param str folder_ids: 10687 :param str folder_types: 10688 :param str from_date: The date/time setting that specifies the date/time when the request begins checking for status changes for envelopes in the account. This is required unless 'envelopeId's are used. 10689 :param str from_to_status: This is the status type checked for in the `from_date`/`to_date` period. If `changed` is specified, then envelopes that changed status during the period are found. If for example, `created` is specified, then envelopes created during the period are found. Default is `changed`. Possible values are: Voided, Changed, Created, Deleted, Sent, Delivered, Signed, Completed, Declined, TimedOut and Processing. 10690 :param str include: 10691 :param str include_purge_information: 10692 :param str intersecting_folder_ids: 10693 :param str last_queried_date: 10694 :param str order: 10695 :param str order_by: 10696 :param str powerformids: 10697 :param str query_budget: 10698 :param str requester_date_format: 10699 :param str search_text: 10700 :param str start_position: 10701 :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. 10702 :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`. 10703 :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. 10704 :param str user_filter: 10705 :param str user_id: 10706 :param str user_name: 10707 :return: EnvelopesInformation 10708 If the method is called asynchronously, 10709 returns the request thread. 10710 """ 10711 kwargs['_return_http_data_only'] = True 10712 if kwargs.get('callback'): 10713 return self.list_status_changes_with_http_info(account_id, **kwargs) 10714 else: 10715 (data) = self.list_status_changes_with_http_info(account_id, **kwargs) 10716 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_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)
10718 def list_status_changes_with_http_info(self, account_id, **kwargs): 10719 """ 10720 Gets status changes for one or more envelopes. 10721 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. 10722 This method makes a synchronous HTTP request by default. To make an 10723 asynchronous HTTP request, please define a `callback` function 10724 to be invoked when receiving the response. 10725 >>> def callback_function(response): 10726 >>> pprint(response) 10727 >>> 10728 >>> thread = api.list_status_changes_with_http_info(account_id, callback=callback_function) 10729 10730 :param callback function: The callback function 10731 for asynchronous request. (optional) 10732 :param str account_id: The external account number (int) or account ID Guid. (required) 10733 :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. 10734 :param str block: 10735 :param str cdse_mode: 10736 :param str continuation_token: 10737 :param str count: 10738 :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.\" 10739 :param str email: 10740 :param str envelope_ids: 10741 :param str exclude: 10742 :param str folder_ids: 10743 :param str folder_types: 10744 :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. 10745 :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. 10746 :param str include: 10747 :param str include_purge_information: 10748 :param str intersecting_folder_ids: 10749 :param str last_queried_date: 10750 :param str order: 10751 :param str order_by: 10752 :param str powerformids: 10753 :param str query_budget: 10754 :param str requester_date_format: 10755 :param str search_text: 10756 :param str start_position: 10757 :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. 10758 :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`. 10759 :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. 10760 :param str user_filter: 10761 :param str user_id: 10762 :param str user_name: 10763 :return: EnvelopesInformation 10764 If the method is called asynchronously, 10765 returns the request thread. 10766 """ 10767 10768 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_text', 'start_position', 'status', 'to_date', 'transaction_ids', 'user_filter', 'user_id', 'user_name'] 10769 all_params.append('callback') 10770 all_params.append('_return_http_data_only') 10771 all_params.append('_preload_content') 10772 all_params.append('_request_timeout') 10773 10774 params = locals() 10775 for key, val in iteritems(params['kwargs']): 10776 if key not in all_params: 10777 raise TypeError( 10778 "Got an unexpected keyword argument '%s'" 10779 " to method list_status_changes" % key 10780 ) 10781 params[key] = val 10782 del params['kwargs'] 10783 # verify the required parameter 'account_id' is set 10784 if ('account_id' not in params) or (params['account_id'] is None): 10785 raise ValueError("Missing the required parameter `account_id` when calling `list_status_changes`") 10786 10787 10788 collection_formats = {} 10789 10790 resource_path = '/v2.1/accounts/{accountId}/envelopes'.replace('{format}', 'json') 10791 path_params = {} 10792 if 'account_id' in params: 10793 path_params['accountId'] = params['account_id'] 10794 10795 query_params = {} 10796 if 'ac_status' in params: 10797 query_params['ac_status'] = params['ac_status'] 10798 if 'block' in params: 10799 query_params['block'] = params['block'] 10800 if 'cdse_mode' in params: 10801 query_params['cdse_mode'] = params['cdse_mode'] 10802 if 'continuation_token' in params: 10803 query_params['continuation_token'] = params['continuation_token'] 10804 if 'count' in params: 10805 query_params['count'] = params['count'] 10806 if 'custom_field' in params: 10807 query_params['custom_field'] = params['custom_field'] 10808 if 'email' in params: 10809 query_params['email'] = params['email'] 10810 if 'envelope_ids' in params: 10811 query_params['envelope_ids'] = params['envelope_ids'] 10812 if 'exclude' in params: 10813 query_params['exclude'] = params['exclude'] 10814 if 'folder_ids' in params: 10815 query_params['folder_ids'] = params['folder_ids'] 10816 if 'folder_types' in params: 10817 query_params['folder_types'] = params['folder_types'] 10818 if 'from_date' in params: 10819 query_params['from_date'] = params['from_date'] 10820 if 'from_to_status' in params: 10821 query_params['from_to_status'] = params['from_to_status'] 10822 if 'include' in params: 10823 query_params['include'] = params['include'] 10824 if 'include_purge_information' in params: 10825 query_params['include_purge_information'] = params['include_purge_information'] 10826 if 'intersecting_folder_ids' in params: 10827 query_params['intersecting_folder_ids'] = params['intersecting_folder_ids'] 10828 if 'last_queried_date' in params: 10829 query_params['last_queried_date'] = params['last_queried_date'] 10830 if 'order' in params: 10831 query_params['order'] = params['order'] 10832 if 'order_by' in params: 10833 query_params['order_by'] = params['order_by'] 10834 if 'powerformids' in params: 10835 query_params['powerformids'] = params['powerformids'] 10836 if 'query_budget' in params: 10837 query_params['query_budget'] = params['query_budget'] 10838 if 'requester_date_format' in params: 10839 query_params['requester_date_format'] = params['requester_date_format'] 10840 if 'search_text' in params: 10841 query_params['search_text'] = params['search_text'] 10842 if 'start_position' in params: 10843 query_params['start_position'] = params['start_position'] 10844 if 'status' in params: 10845 query_params['status'] = params['status'] 10846 if 'to_date' in params: 10847 query_params['to_date'] = params['to_date'] 10848 if 'transaction_ids' in params: 10849 query_params['transaction_ids'] = params['transaction_ids'] 10850 if 'user_filter' in params: 10851 query_params['user_filter'] = params['user_filter'] 10852 if 'user_id' in params: 10853 query_params['user_id'] = params['user_id'] 10854 if 'user_name' in params: 10855 query_params['user_name'] = params['user_name'] 10856 10857 header_params = {} 10858 10859 form_params = [] 10860 local_var_files = {} 10861 10862 body_params = None 10863 # HTTP header `Accept` 10864 header_params['Accept'] = self.api_client.\ 10865 select_header_accept(['application/json']) 10866 10867 # Authentication setting 10868 auth_settings = [] 10869 10870 return self.api_client.call_api(resource_path, 'GET', 10871 path_params, 10872 query_params, 10873 header_params, 10874 body=body_params, 10875 post_params=form_params, 10876 files=local_var_files, 10877 response_type='EnvelopesInformation', 10878 auth_settings=auth_settings, 10879 callback=params.get('callback'), 10880 _return_http_data_only=params.get('_return_http_data_only'), 10881 _preload_content=params.get('_preload_content', True), 10882 _request_timeout=params.get('_request_timeout'), 10883 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_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)
10885 def list_tabs(self, account_id, envelope_id, recipient_id, **kwargs): 10886 """ 10887 Gets the tabs information for a signer or sign-in-person recipient in an envelope. 10888 Retrieves information about the tabs associated with a recipient in a draft envelope. 10889 This method makes a synchronous HTTP request by default. To make an 10890 asynchronous HTTP request, please define a `callback` function 10891 to be invoked when receiving the response. 10892 >>> def callback_function(response): 10893 >>> pprint(response) 10894 >>> 10895 >>> thread = api.list_tabs(account_id, envelope_id, recipient_id, callback=callback_function) 10896 10897 :param callback function: The callback function 10898 for asynchronous request. (optional) 10899 :param str account_id: The external account number (int) or account ID Guid. (required) 10900 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10901 :param str recipient_id: The ID of the recipient being accessed. (required) 10902 :param str include_anchor_tab_locations: When set to **true**, all tabs with anchor tab properties are included in the response. 10903 :param str include_metadata: 10904 :return: Tabs 10905 If the method is called asynchronously, 10906 returns the request thread. 10907 """ 10908 kwargs['_return_http_data_only'] = True 10909 if kwargs.get('callback'): 10910 return self.list_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 10911 else: 10912 (data) = self.list_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 10913 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)
10915 def list_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 10916 """ 10917 Gets the tabs information for a signer or sign-in-person recipient in an envelope. 10918 Retrieves information about the tabs associated with a recipient in a draft envelope. 10919 This method makes a synchronous HTTP request by default. To make an 10920 asynchronous HTTP request, please define a `callback` function 10921 to be invoked when receiving the response. 10922 >>> def callback_function(response): 10923 >>> pprint(response) 10924 >>> 10925 >>> thread = api.list_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 10926 10927 :param callback function: The callback function 10928 for asynchronous request. (optional) 10929 :param str account_id: The external account number (int) or account ID Guid. (required) 10930 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 10931 :param str recipient_id: The ID of the recipient being accessed. (required) 10932 :param str include_anchor_tab_locations: When set to **true**, all tabs with anchor tab properties are included in the response. 10933 :param str include_metadata: 10934 :return: Tabs 10935 If the method is called asynchronously, 10936 returns the request thread. 10937 """ 10938 10939 all_params = ['account_id', 'envelope_id', 'recipient_id', 'include_anchor_tab_locations', 'include_metadata'] 10940 all_params.append('callback') 10941 all_params.append('_return_http_data_only') 10942 all_params.append('_preload_content') 10943 all_params.append('_request_timeout') 10944 10945 params = locals() 10946 for key, val in iteritems(params['kwargs']): 10947 if key not in all_params: 10948 raise TypeError( 10949 "Got an unexpected keyword argument '%s'" 10950 " to method list_tabs" % key 10951 ) 10952 params[key] = val 10953 del params['kwargs'] 10954 # verify the required parameter 'account_id' is set 10955 if ('account_id' not in params) or (params['account_id'] is None): 10956 raise ValueError("Missing the required parameter `account_id` when calling `list_tabs`") 10957 # verify the required parameter 'envelope_id' is set 10958 if ('envelope_id' not in params) or (params['envelope_id'] is None): 10959 raise ValueError("Missing the required parameter `envelope_id` when calling `list_tabs`") 10960 # verify the required parameter 'recipient_id' is set 10961 if ('recipient_id' not in params) or (params['recipient_id'] is None): 10962 raise ValueError("Missing the required parameter `recipient_id` when calling `list_tabs`") 10963 10964 10965 collection_formats = {} 10966 10967 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/tabs'.replace('{format}', 'json') 10968 path_params = {} 10969 if 'account_id' in params: 10970 path_params['accountId'] = params['account_id'] 10971 if 'envelope_id' in params: 10972 path_params['envelopeId'] = params['envelope_id'] 10973 if 'recipient_id' in params: 10974 path_params['recipientId'] = params['recipient_id'] 10975 10976 query_params = {} 10977 if 'include_anchor_tab_locations' in params: 10978 query_params['include_anchor_tab_locations'] = params['include_anchor_tab_locations'] 10979 if 'include_metadata' in params: 10980 query_params['include_metadata'] = params['include_metadata'] 10981 10982 header_params = {} 10983 10984 form_params = [] 10985 local_var_files = {} 10986 10987 body_params = None 10988 # HTTP header `Accept` 10989 header_params['Accept'] = self.api_client.\ 10990 select_header_accept(['application/json']) 10991 10992 # Authentication setting 10993 auth_settings = [] 10994 10995 return self.api_client.call_api(resource_path, 'GET', 10996 path_params, 10997 query_params, 10998 header_params, 10999 body=body_params, 11000 post_params=form_params, 11001 files=local_var_files, 11002 response_type='Tabs', 11003 auth_settings=auth_settings, 11004 callback=params.get('callback'), 11005 _return_http_data_only=params.get('_return_http_data_only'), 11006 _preload_content=params.get('_preload_content', True), 11007 _request_timeout=params.get('_request_timeout'), 11008 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)
11010 def list_templates(self, account_id, envelope_id, **kwargs): 11011 """ 11012 Get List of Templates used in an Envelope 11013 This returns a list of the server-side templates, their name and ID, used in an envelope. 11014 This method makes a synchronous HTTP request by default. To make an 11015 asynchronous HTTP request, please define a `callback` function 11016 to be invoked when receiving the response. 11017 >>> def callback_function(response): 11018 >>> pprint(response) 11019 >>> 11020 >>> thread = api.list_templates(account_id, envelope_id, callback=callback_function) 11021 11022 :param callback function: The callback function 11023 for asynchronous request. (optional) 11024 :param str account_id: The external account number (int) or account ID Guid. (required) 11025 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11026 :param str include: The possible values are: matching_applied - This returns template matching information for the template. 11027 :return: TemplateInformation 11028 If the method is called asynchronously, 11029 returns the request thread. 11030 """ 11031 kwargs['_return_http_data_only'] = True 11032 if kwargs.get('callback'): 11033 return self.list_templates_with_http_info(account_id, envelope_id, **kwargs) 11034 else: 11035 (data) = self.list_templates_with_http_info(account_id, envelope_id, **kwargs) 11036 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)
11038 def list_templates_with_http_info(self, account_id, envelope_id, **kwargs): 11039 """ 11040 Get List of Templates used in an Envelope 11041 This returns a list of the server-side templates, their name and ID, used in an envelope. 11042 This method makes a synchronous HTTP request by default. To make an 11043 asynchronous HTTP request, please define a `callback` function 11044 to be invoked when receiving the response. 11045 >>> def callback_function(response): 11046 >>> pprint(response) 11047 >>> 11048 >>> thread = api.list_templates_with_http_info(account_id, envelope_id, callback=callback_function) 11049 11050 :param callback function: The callback function 11051 for asynchronous request. (optional) 11052 :param str account_id: The external account number (int) or account ID Guid. (required) 11053 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11054 :param str include: The possible values are: matching_applied - This returns template matching information for the template. 11055 :return: TemplateInformation 11056 If the method is called asynchronously, 11057 returns the request thread. 11058 """ 11059 11060 all_params = ['account_id', 'envelope_id', 'include'] 11061 all_params.append('callback') 11062 all_params.append('_return_http_data_only') 11063 all_params.append('_preload_content') 11064 all_params.append('_request_timeout') 11065 11066 params = locals() 11067 for key, val in iteritems(params['kwargs']): 11068 if key not in all_params: 11069 raise TypeError( 11070 "Got an unexpected keyword argument '%s'" 11071 " to method list_templates" % key 11072 ) 11073 params[key] = val 11074 del params['kwargs'] 11075 # verify the required parameter 'account_id' is set 11076 if ('account_id' not in params) or (params['account_id'] is None): 11077 raise ValueError("Missing the required parameter `account_id` when calling `list_templates`") 11078 # verify the required parameter 'envelope_id' is set 11079 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11080 raise ValueError("Missing the required parameter `envelope_id` when calling `list_templates`") 11081 11082 11083 collection_formats = {} 11084 11085 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/templates'.replace('{format}', 'json') 11086 path_params = {} 11087 if 'account_id' in params: 11088 path_params['accountId'] = params['account_id'] 11089 if 'envelope_id' in params: 11090 path_params['envelopeId'] = params['envelope_id'] 11091 11092 query_params = {} 11093 if 'include' in params: 11094 query_params['include'] = params['include'] 11095 11096 header_params = {} 11097 11098 form_params = [] 11099 local_var_files = {} 11100 11101 body_params = None 11102 # HTTP header `Accept` 11103 header_params['Accept'] = self.api_client.\ 11104 select_header_accept(['application/json']) 11105 11106 # Authentication setting 11107 auth_settings = [] 11108 11109 return self.api_client.call_api(resource_path, 'GET', 11110 path_params, 11111 query_params, 11112 header_params, 11113 body=body_params, 11114 post_params=form_params, 11115 files=local_var_files, 11116 response_type='TemplateInformation', 11117 auth_settings=auth_settings, 11118 callback=params.get('callback'), 11119 _return_http_data_only=params.get('_return_http_data_only'), 11120 _preload_content=params.get('_preload_content', True), 11121 _request_timeout=params.get('_request_timeout'), 11122 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)
11124 def list_templates_for_document(self, account_id, document_id, envelope_id, **kwargs): 11125 """ 11126 Gets the templates associated with a document in an existing envelope. 11127 Retrieves the templates associated with a document in the specified envelope. 11128 This method makes a synchronous HTTP request by default. To make an 11129 asynchronous HTTP request, please define a `callback` function 11130 to be invoked when receiving the response. 11131 >>> def callback_function(response): 11132 >>> pprint(response) 11133 >>> 11134 >>> thread = api.list_templates_for_document(account_id, document_id, envelope_id, callback=callback_function) 11135 11136 :param callback function: The callback function 11137 for asynchronous request. (optional) 11138 :param str account_id: The external account number (int) or account ID Guid. (required) 11139 :param str document_id: The ID of the document being accessed. (required) 11140 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11141 :param str include: 11142 :return: TemplateInformation 11143 If the method is called asynchronously, 11144 returns the request thread. 11145 """ 11146 kwargs['_return_http_data_only'] = True 11147 if kwargs.get('callback'): 11148 return self.list_templates_for_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 11149 else: 11150 (data) = self.list_templates_for_document_with_http_info(account_id, document_id, envelope_id, **kwargs) 11151 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)
11153 def list_templates_for_document_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 11154 """ 11155 Gets the templates associated with a document in an existing envelope. 11156 Retrieves the templates associated with a document in the specified envelope. 11157 This method makes a synchronous HTTP request by default. To make an 11158 asynchronous HTTP request, please define a `callback` function 11159 to be invoked when receiving the response. 11160 >>> def callback_function(response): 11161 >>> pprint(response) 11162 >>> 11163 >>> thread = api.list_templates_for_document_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 11164 11165 :param callback function: The callback function 11166 for asynchronous request. (optional) 11167 :param str account_id: The external account number (int) or account ID Guid. (required) 11168 :param str document_id: The ID of the document being accessed. (required) 11169 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11170 :param str include: 11171 :return: TemplateInformation 11172 If the method is called asynchronously, 11173 returns the request thread. 11174 """ 11175 11176 all_params = ['account_id', 'document_id', 'envelope_id', 'include'] 11177 all_params.append('callback') 11178 all_params.append('_return_http_data_only') 11179 all_params.append('_preload_content') 11180 all_params.append('_request_timeout') 11181 11182 params = locals() 11183 for key, val in iteritems(params['kwargs']): 11184 if key not in all_params: 11185 raise TypeError( 11186 "Got an unexpected keyword argument '%s'" 11187 " to method list_templates_for_document" % key 11188 ) 11189 params[key] = val 11190 del params['kwargs'] 11191 # verify the required parameter 'account_id' is set 11192 if ('account_id' not in params) or (params['account_id'] is None): 11193 raise ValueError("Missing the required parameter `account_id` when calling `list_templates_for_document`") 11194 # verify the required parameter 'document_id' is set 11195 if ('document_id' not in params) or (params['document_id'] is None): 11196 raise ValueError("Missing the required parameter `document_id` when calling `list_templates_for_document`") 11197 # verify the required parameter 'envelope_id' is set 11198 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11199 raise ValueError("Missing the required parameter `envelope_id` when calling `list_templates_for_document`") 11200 11201 11202 collection_formats = {} 11203 11204 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/templates'.replace('{format}', 'json') 11205 path_params = {} 11206 if 'account_id' in params: 11207 path_params['accountId'] = params['account_id'] 11208 if 'document_id' in params: 11209 path_params['documentId'] = params['document_id'] 11210 if 'envelope_id' in params: 11211 path_params['envelopeId'] = params['envelope_id'] 11212 11213 query_params = {} 11214 if 'include' in params: 11215 query_params['include'] = params['include'] 11216 11217 header_params = {} 11218 11219 form_params = [] 11220 local_var_files = {} 11221 11222 body_params = None 11223 # HTTP header `Accept` 11224 header_params['Accept'] = self.api_client.\ 11225 select_header_accept(['application/json']) 11226 11227 # Authentication setting 11228 auth_settings = [] 11229 11230 return self.api_client.call_api(resource_path, 'GET', 11231 path_params, 11232 query_params, 11233 header_params, 11234 body=body_params, 11235 post_params=form_params, 11236 files=local_var_files, 11237 response_type='TemplateInformation', 11238 auth_settings=auth_settings, 11239 callback=params.get('callback'), 11240 _return_http_data_only=params.get('_return_http_data_only'), 11241 _preload_content=params.get('_preload_content', True), 11242 _request_timeout=params.get('_request_timeout'), 11243 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)
11245 def put_attachment(self, account_id, attachment_id, envelope_id, **kwargs): 11246 """ 11247 Add an attachment to a DRAFT or IN-PROCESS envelope. 11248 Adds an attachment to a draft or in-process envelope. 11249 This method makes a synchronous HTTP request by default. To make an 11250 asynchronous HTTP request, please define a `callback` function 11251 to be invoked when receiving the response. 11252 >>> def callback_function(response): 11253 >>> pprint(response) 11254 >>> 11255 >>> thread = api.put_attachment(account_id, attachment_id, envelope_id, callback=callback_function) 11256 11257 :param callback function: The callback function 11258 for asynchronous request. (optional) 11259 :param str account_id: The external account number (int) or account ID Guid. (required) 11260 :param str attachment_id: (required) 11261 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11262 :param Attachment attachment: 11263 :return: EnvelopeAttachmentsResult 11264 If the method is called asynchronously, 11265 returns the request thread. 11266 """ 11267 kwargs['_return_http_data_only'] = True 11268 if kwargs.get('callback'): 11269 return self.put_attachment_with_http_info(account_id, attachment_id, envelope_id, **kwargs) 11270 else: 11271 (data) = self.put_attachment_with_http_info(account_id, attachment_id, envelope_id, **kwargs) 11272 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)
11274 def put_attachment_with_http_info(self, account_id, attachment_id, envelope_id, **kwargs): 11275 """ 11276 Add an attachment to a DRAFT or IN-PROCESS envelope. 11277 Adds an attachment to a draft or in-process envelope. 11278 This method makes a synchronous HTTP request by default. To make an 11279 asynchronous HTTP request, please define a `callback` function 11280 to be invoked when receiving the response. 11281 >>> def callback_function(response): 11282 >>> pprint(response) 11283 >>> 11284 >>> thread = api.put_attachment_with_http_info(account_id, attachment_id, envelope_id, callback=callback_function) 11285 11286 :param callback function: The callback function 11287 for asynchronous request. (optional) 11288 :param str account_id: The external account number (int) or account ID Guid. (required) 11289 :param str attachment_id: (required) 11290 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11291 :param Attachment attachment: 11292 :return: EnvelopeAttachmentsResult 11293 If the method is called asynchronously, 11294 returns the request thread. 11295 """ 11296 11297 all_params = ['account_id', 'attachment_id', 'envelope_id', 'attachment'] 11298 all_params.append('callback') 11299 all_params.append('_return_http_data_only') 11300 all_params.append('_preload_content') 11301 all_params.append('_request_timeout') 11302 11303 params = locals() 11304 for key, val in iteritems(params['kwargs']): 11305 if key not in all_params: 11306 raise TypeError( 11307 "Got an unexpected keyword argument '%s'" 11308 " to method put_attachment" % key 11309 ) 11310 params[key] = val 11311 del params['kwargs'] 11312 # verify the required parameter 'account_id' is set 11313 if ('account_id' not in params) or (params['account_id'] is None): 11314 raise ValueError("Missing the required parameter `account_id` when calling `put_attachment`") 11315 # verify the required parameter 'attachment_id' is set 11316 if ('attachment_id' not in params) or (params['attachment_id'] is None): 11317 raise ValueError("Missing the required parameter `attachment_id` when calling `put_attachment`") 11318 # verify the required parameter 'envelope_id' is set 11319 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11320 raise ValueError("Missing the required parameter `envelope_id` when calling `put_attachment`") 11321 11322 11323 collection_formats = {} 11324 11325 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments/{attachmentId}'.replace('{format}', 'json') 11326 path_params = {} 11327 if 'account_id' in params: 11328 path_params['accountId'] = params['account_id'] 11329 if 'attachment_id' in params: 11330 path_params['attachmentId'] = params['attachment_id'] 11331 if 'envelope_id' in params: 11332 path_params['envelopeId'] = params['envelope_id'] 11333 11334 query_params = {} 11335 11336 header_params = {} 11337 11338 form_params = [] 11339 local_var_files = {} 11340 11341 body_params = None 11342 if 'attachment' in params: 11343 body_params = params['attachment'] 11344 # HTTP header `Accept` 11345 header_params['Accept'] = self.api_client.\ 11346 select_header_accept(['application/json']) 11347 11348 # Authentication setting 11349 auth_settings = [] 11350 11351 return self.api_client.call_api(resource_path, 'PUT', 11352 path_params, 11353 query_params, 11354 header_params, 11355 body=body_params, 11356 post_params=form_params, 11357 files=local_var_files, 11358 response_type='EnvelopeAttachmentsResult', 11359 auth_settings=auth_settings, 11360 callback=params.get('callback'), 11361 _return_http_data_only=params.get('_return_http_data_only'), 11362 _preload_content=params.get('_preload_content', True), 11363 _request_timeout=params.get('_request_timeout'), 11364 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)
11366 def put_attachments(self, account_id, envelope_id, **kwargs): 11367 """ 11368 Add one or more attachments to a DRAFT or IN-PROCESS envelope. 11369 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). 11370 This method makes a synchronous HTTP request by default. To make an 11371 asynchronous HTTP request, please define a `callback` function 11372 to be invoked when receiving the response. 11373 >>> def callback_function(response): 11374 >>> pprint(response) 11375 >>> 11376 >>> thread = api.put_attachments(account_id, envelope_id, callback=callback_function) 11377 11378 :param callback function: The callback function 11379 for asynchronous request. (optional) 11380 :param str account_id: The external account number (int) or account ID Guid. (required) 11381 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11382 :param EnvelopeAttachmentsRequest envelope_attachments_request: 11383 :return: EnvelopeAttachmentsResult 11384 If the method is called asynchronously, 11385 returns the request thread. 11386 """ 11387 kwargs['_return_http_data_only'] = True 11388 if kwargs.get('callback'): 11389 return self.put_attachments_with_http_info(account_id, envelope_id, **kwargs) 11390 else: 11391 (data) = self.put_attachments_with_http_info(account_id, envelope_id, **kwargs) 11392 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)
11394 def put_attachments_with_http_info(self, account_id, envelope_id, **kwargs): 11395 """ 11396 Add one or more attachments to a DRAFT or IN-PROCESS envelope. 11397 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). 11398 This method makes a synchronous HTTP request by default. To make an 11399 asynchronous HTTP request, please define a `callback` function 11400 to be invoked when receiving the response. 11401 >>> def callback_function(response): 11402 >>> pprint(response) 11403 >>> 11404 >>> thread = api.put_attachments_with_http_info(account_id, envelope_id, callback=callback_function) 11405 11406 :param callback function: The callback function 11407 for asynchronous request. (optional) 11408 :param str account_id: The external account number (int) or account ID Guid. (required) 11409 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11410 :param EnvelopeAttachmentsRequest envelope_attachments_request: 11411 :return: EnvelopeAttachmentsResult 11412 If the method is called asynchronously, 11413 returns the request thread. 11414 """ 11415 11416 all_params = ['account_id', 'envelope_id', 'envelope_attachments_request'] 11417 all_params.append('callback') 11418 all_params.append('_return_http_data_only') 11419 all_params.append('_preload_content') 11420 all_params.append('_request_timeout') 11421 11422 params = locals() 11423 for key, val in iteritems(params['kwargs']): 11424 if key not in all_params: 11425 raise TypeError( 11426 "Got an unexpected keyword argument '%s'" 11427 " to method put_attachments" % key 11428 ) 11429 params[key] = val 11430 del params['kwargs'] 11431 # verify the required parameter 'account_id' is set 11432 if ('account_id' not in params) or (params['account_id'] is None): 11433 raise ValueError("Missing the required parameter `account_id` when calling `put_attachments`") 11434 # verify the required parameter 'envelope_id' is set 11435 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11436 raise ValueError("Missing the required parameter `envelope_id` when calling `put_attachments`") 11437 11438 11439 collection_formats = {} 11440 11441 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments'.replace('{format}', 'json') 11442 path_params = {} 11443 if 'account_id' in params: 11444 path_params['accountId'] = params['account_id'] 11445 if 'envelope_id' in params: 11446 path_params['envelopeId'] = params['envelope_id'] 11447 11448 query_params = {} 11449 11450 header_params = {} 11451 11452 form_params = [] 11453 local_var_files = {} 11454 11455 body_params = None 11456 if 'envelope_attachments_request' in params: 11457 body_params = params['envelope_attachments_request'] 11458 # HTTP header `Accept` 11459 header_params['Accept'] = self.api_client.\ 11460 select_header_accept(['application/json']) 11461 11462 # Authentication setting 11463 auth_settings = [] 11464 11465 return self.api_client.call_api(resource_path, 'PUT', 11466 path_params, 11467 query_params, 11468 header_params, 11469 body=body_params, 11470 post_params=form_params, 11471 files=local_var_files, 11472 response_type='EnvelopeAttachmentsResult', 11473 auth_settings=auth_settings, 11474 callback=params.get('callback'), 11475 _return_http_data_only=params.get('_return_http_data_only'), 11476 _preload_content=params.get('_preload_content', True), 11477 _request_timeout=params.get('_request_timeout'), 11478 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)
11480 def rotate_document_page(self, account_id, document_id, envelope_id, page_number, **kwargs): 11481 """ 11482 Rotates page image from an envelope for display. 11483 Rotates page image from an envelope for display. The page image can be rotated to the left or right. 11484 This method makes a synchronous HTTP request by default. To make an 11485 asynchronous HTTP request, please define a `callback` function 11486 to be invoked when receiving the response. 11487 >>> def callback_function(response): 11488 >>> pprint(response) 11489 >>> 11490 >>> thread = api.rotate_document_page(account_id, document_id, envelope_id, page_number, callback=callback_function) 11491 11492 :param callback function: The callback function 11493 for asynchronous request. (optional) 11494 :param str account_id: The external account number (int) or account ID Guid. (required) 11495 :param str document_id: The ID of the document being accessed. (required) 11496 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11497 :param str page_number: The page number being accessed. (required) 11498 :param PageRequest page_request: 11499 :return: None 11500 If the method is called asynchronously, 11501 returns the request thread. 11502 """ 11503 kwargs['_return_http_data_only'] = True 11504 if kwargs.get('callback'): 11505 return self.rotate_document_page_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 11506 else: 11507 (data) = self.rotate_document_page_with_http_info(account_id, document_id, envelope_id, page_number, **kwargs) 11508 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)
11510 def rotate_document_page_with_http_info(self, account_id, document_id, envelope_id, page_number, **kwargs): 11511 """ 11512 Rotates page image from an envelope for display. 11513 Rotates page image from an envelope for display. The page image can be rotated to the left or right. 11514 This method makes a synchronous HTTP request by default. To make an 11515 asynchronous HTTP request, please define a `callback` function 11516 to be invoked when receiving the response. 11517 >>> def callback_function(response): 11518 >>> pprint(response) 11519 >>> 11520 >>> thread = api.rotate_document_page_with_http_info(account_id, document_id, envelope_id, page_number, callback=callback_function) 11521 11522 :param callback function: The callback function 11523 for asynchronous request. (optional) 11524 :param str account_id: The external account number (int) or account ID Guid. (required) 11525 :param str document_id: The ID of the document being accessed. (required) 11526 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11527 :param str page_number: The page number being accessed. (required) 11528 :param PageRequest page_request: 11529 :return: None 11530 If the method is called asynchronously, 11531 returns the request thread. 11532 """ 11533 11534 all_params = ['account_id', 'document_id', 'envelope_id', 'page_number', 'page_request'] 11535 all_params.append('callback') 11536 all_params.append('_return_http_data_only') 11537 all_params.append('_preload_content') 11538 all_params.append('_request_timeout') 11539 11540 params = locals() 11541 for key, val in iteritems(params['kwargs']): 11542 if key not in all_params: 11543 raise TypeError( 11544 "Got an unexpected keyword argument '%s'" 11545 " to method rotate_document_page" % key 11546 ) 11547 params[key] = val 11548 del params['kwargs'] 11549 # verify the required parameter 'account_id' is set 11550 if ('account_id' not in params) or (params['account_id'] is None): 11551 raise ValueError("Missing the required parameter `account_id` when calling `rotate_document_page`") 11552 # verify the required parameter 'document_id' is set 11553 if ('document_id' not in params) or (params['document_id'] is None): 11554 raise ValueError("Missing the required parameter `document_id` when calling `rotate_document_page`") 11555 # verify the required parameter 'envelope_id' is set 11556 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11557 raise ValueError("Missing the required parameter `envelope_id` when calling `rotate_document_page`") 11558 # verify the required parameter 'page_number' is set 11559 if ('page_number' not in params) or (params['page_number'] is None): 11560 raise ValueError("Missing the required parameter `page_number` when calling `rotate_document_page`") 11561 11562 11563 collection_formats = {} 11564 11565 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/pages/{pageNumber}/page_image'.replace('{format}', 'json') 11566 path_params = {} 11567 if 'account_id' in params: 11568 path_params['accountId'] = params['account_id'] 11569 if 'document_id' in params: 11570 path_params['documentId'] = params['document_id'] 11571 if 'envelope_id' in params: 11572 path_params['envelopeId'] = params['envelope_id'] 11573 if 'page_number' in params: 11574 path_params['pageNumber'] = params['page_number'] 11575 11576 query_params = {} 11577 11578 header_params = {} 11579 11580 form_params = [] 11581 local_var_files = {} 11582 11583 body_params = None 11584 if 'page_request' in params: 11585 body_params = params['page_request'] 11586 # HTTP header `Accept` 11587 header_params['Accept'] = self.api_client.\ 11588 select_header_accept(['application/json']) 11589 11590 # Authentication setting 11591 auth_settings = [] 11592 11593 return self.api_client.call_api(resource_path, 'PUT', 11594 path_params, 11595 query_params, 11596 header_params, 11597 body=body_params, 11598 post_params=form_params, 11599 files=local_var_files, 11600 response_type=None, 11601 auth_settings=auth_settings, 11602 callback=params.get('callback'), 11603 _return_http_data_only=params.get('_return_http_data_only'), 11604 _preload_content=params.get('_preload_content', True), 11605 _request_timeout=params.get('_request_timeout'), 11606 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)
11608 def update(self, account_id, envelope_id, **kwargs): 11609 """ 11610 Send Draft Envelope/Void Envelope/Move/Purge Envelope/Modify draft 11611 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. 11612 This method makes a synchronous HTTP request by default. To make an 11613 asynchronous HTTP request, please define a `callback` function 11614 to be invoked when receiving the response. 11615 >>> def callback_function(response): 11616 >>> pprint(response) 11617 >>> 11618 >>> thread = api.update(account_id, envelope_id, callback=callback_function) 11619 11620 :param callback function: The callback function 11621 for asynchronous request. (optional) 11622 :param str account_id: The external account number (int) or account ID Guid. (required) 11623 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11624 :param str advanced_update: When set to **true**, allows the caller to update recipients, tabs, custom fields, notification, email settings and other envelope attributes. 11625 :param str resend_envelope: When set to **true**, sends the specified envelope again. 11626 :param Envelope envelope: 11627 :return: EnvelopeUpdateSummary 11628 If the method is called asynchronously, 11629 returns the request thread. 11630 """ 11631 kwargs['_return_http_data_only'] = True 11632 if kwargs.get('callback'): 11633 return self.update_with_http_info(account_id, envelope_id, **kwargs) 11634 else: 11635 (data) = self.update_with_http_info(account_id, envelope_id, **kwargs) 11636 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 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)
11638 def update_with_http_info(self, account_id, envelope_id, **kwargs): 11639 """ 11640 Send Draft Envelope/Void Envelope/Move/Purge Envelope/Modify draft 11641 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. 11642 This method makes a synchronous HTTP request by default. To make an 11643 asynchronous HTTP request, please define a `callback` function 11644 to be invoked when receiving the response. 11645 >>> def callback_function(response): 11646 >>> pprint(response) 11647 >>> 11648 >>> thread = api.update_with_http_info(account_id, envelope_id, callback=callback_function) 11649 11650 :param callback function: The callback function 11651 for asynchronous request. (optional) 11652 :param str account_id: The external account number (int) or account ID Guid. (required) 11653 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11654 :param str advanced_update: When set to **true**, allows the caller to update recipients, tabs, custom fields, notification, email settings and other envelope attributes. 11655 :param str resend_envelope: When set to **true**, sends the specified envelope again. 11656 :param Envelope envelope: 11657 :return: EnvelopeUpdateSummary 11658 If the method is called asynchronously, 11659 returns the request thread. 11660 """ 11661 11662 all_params = ['account_id', 'envelope_id', 'advanced_update', 'resend_envelope', 'envelope'] 11663 all_params.append('callback') 11664 all_params.append('_return_http_data_only') 11665 all_params.append('_preload_content') 11666 all_params.append('_request_timeout') 11667 11668 params = locals() 11669 for key, val in iteritems(params['kwargs']): 11670 if key not in all_params: 11671 raise TypeError( 11672 "Got an unexpected keyword argument '%s'" 11673 " to method update" % key 11674 ) 11675 params[key] = val 11676 del params['kwargs'] 11677 # verify the required parameter 'account_id' is set 11678 if ('account_id' not in params) or (params['account_id'] is None): 11679 raise ValueError("Missing the required parameter `account_id` when calling `update`") 11680 # verify the required parameter 'envelope_id' is set 11681 if ('envelope_id' not in params) or (params['envelope_id'] is None): 11682 raise ValueError("Missing the required parameter `envelope_id` when calling `update`") 11683 11684 11685 collection_formats = {} 11686 11687 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}'.replace('{format}', 'json') 11688 path_params = {} 11689 if 'account_id' in params: 11690 path_params['accountId'] = params['account_id'] 11691 if 'envelope_id' in params: 11692 path_params['envelopeId'] = params['envelope_id'] 11693 11694 query_params = {} 11695 if 'advanced_update' in params: 11696 query_params['advanced_update'] = params['advanced_update'] 11697 if 'resend_envelope' in params: 11698 query_params['resend_envelope'] = params['resend_envelope'] 11699 11700 header_params = {} 11701 11702 form_params = [] 11703 local_var_files = {} 11704 11705 body_params = None 11706 if 'envelope' in params: 11707 body_params = params['envelope'] 11708 # HTTP header `Accept` 11709 header_params['Accept'] = self.api_client.\ 11710 select_header_accept(['application/json']) 11711 11712 # Authentication setting 11713 auth_settings = [] 11714 11715 return self.api_client.call_api(resource_path, 'PUT', 11716 path_params, 11717 query_params, 11718 header_params, 11719 body=body_params, 11720 post_params=form_params, 11721 files=local_var_files, 11722 response_type='EnvelopeUpdateSummary', 11723 auth_settings=auth_settings, 11724 callback=params.get('callback'), 11725 _return_http_data_only=params.get('_return_http_data_only'), 11726 _preload_content=params.get('_preload_content', True), 11727 _request_timeout=params.get('_request_timeout'), 11728 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 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)
11730 def update_chunked_upload(self, account_id, chunked_upload_id, **kwargs): 11731 """ 11732 Integrity-Check and Commit a ChunkedUpload, readying it for use elsewhere. 11733 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. 11734 This method makes a synchronous HTTP request by default. To make an 11735 asynchronous HTTP request, please define a `callback` function 11736 to be invoked when receiving the response. 11737 >>> def callback_function(response): 11738 >>> pprint(response) 11739 >>> 11740 >>> thread = api.update_chunked_upload(account_id, chunked_upload_id, callback=callback_function) 11741 11742 :param callback function: The callback function 11743 for asynchronous request. (optional) 11744 :param str account_id: The external account number (int) or account ID Guid. (required) 11745 :param str chunked_upload_id: (required) 11746 :param str action: 11747 :return: ChunkedUploadResponse 11748 If the method is called asynchronously, 11749 returns the request thread. 11750 """ 11751 kwargs['_return_http_data_only'] = True 11752 if kwargs.get('callback'): 11753 return self.update_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 11754 else: 11755 (data) = self.update_chunked_upload_with_http_info(account_id, chunked_upload_id, **kwargs) 11756 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)
11758 def update_chunked_upload_with_http_info(self, account_id, chunked_upload_id, **kwargs): 11759 """ 11760 Integrity-Check and Commit a ChunkedUpload, readying it for use elsewhere. 11761 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. 11762 This method makes a synchronous HTTP request by default. To make an 11763 asynchronous HTTP request, please define a `callback` function 11764 to be invoked when receiving the response. 11765 >>> def callback_function(response): 11766 >>> pprint(response) 11767 >>> 11768 >>> thread = api.update_chunked_upload_with_http_info(account_id, chunked_upload_id, callback=callback_function) 11769 11770 :param callback function: The callback function 11771 for asynchronous request. (optional) 11772 :param str account_id: The external account number (int) or account ID Guid. (required) 11773 :param str chunked_upload_id: (required) 11774 :param str action: 11775 :return: ChunkedUploadResponse 11776 If the method is called asynchronously, 11777 returns the request thread. 11778 """ 11779 11780 all_params = ['account_id', 'chunked_upload_id', 'action'] 11781 all_params.append('callback') 11782 all_params.append('_return_http_data_only') 11783 all_params.append('_preload_content') 11784 all_params.append('_request_timeout') 11785 11786 params = locals() 11787 for key, val in iteritems(params['kwargs']): 11788 if key not in all_params: 11789 raise TypeError( 11790 "Got an unexpected keyword argument '%s'" 11791 " to method update_chunked_upload" % key 11792 ) 11793 params[key] = val 11794 del params['kwargs'] 11795 # verify the required parameter 'account_id' is set 11796 if ('account_id' not in params) or (params['account_id'] is None): 11797 raise ValueError("Missing the required parameter `account_id` when calling `update_chunked_upload`") 11798 # verify the required parameter 'chunked_upload_id' is set 11799 if ('chunked_upload_id' not in params) or (params['chunked_upload_id'] is None): 11800 raise ValueError("Missing the required parameter `chunked_upload_id` when calling `update_chunked_upload`") 11801 11802 11803 collection_formats = {} 11804 11805 resource_path = '/v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}'.replace('{format}', 'json') 11806 path_params = {} 11807 if 'account_id' in params: 11808 path_params['accountId'] = params['account_id'] 11809 if 'chunked_upload_id' in params: 11810 path_params['chunkedUploadId'] = params['chunked_upload_id'] 11811 11812 query_params = {} 11813 if 'action' in params: 11814 query_params['action'] = params['action'] 11815 11816 header_params = {} 11817 11818 form_params = [] 11819 local_var_files = {} 11820 11821 body_params = None 11822 # HTTP header `Accept` 11823 header_params['Accept'] = self.api_client.\ 11824 select_header_accept(['application/json']) 11825 11826 # Authentication setting 11827 auth_settings = [] 11828 11829 return self.api_client.call_api(resource_path, 'PUT', 11830 path_params, 11831 query_params, 11832 header_params, 11833 body=body_params, 11834 post_params=form_params, 11835 files=local_var_files, 11836 response_type='ChunkedUploadResponse', 11837 auth_settings=auth_settings, 11838 callback=params.get('callback'), 11839 _return_http_data_only=params.get('_return_http_data_only'), 11840 _preload_content=params.get('_preload_content', True), 11841 _request_timeout=params.get('_request_timeout'), 11842 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)
11844 def update_chunked_upload_part(self, account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs): 11845 """ 11846 Add a chunk, a chunk 'part', to an existing ChunkedUpload. 11847 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. 11848 This method makes a synchronous HTTP request by default. To make an 11849 asynchronous HTTP request, please define a `callback` function 11850 to be invoked when receiving the response. 11851 >>> def callback_function(response): 11852 >>> pprint(response) 11853 >>> 11854 >>> thread = api.update_chunked_upload_part(account_id, chunked_upload_id, chunked_upload_part_seq, callback=callback_function) 11855 11856 :param callback function: The callback function 11857 for asynchronous request. (optional) 11858 :param str account_id: The external account number (int) or account ID Guid. (required) 11859 :param str chunked_upload_id: (required) 11860 :param str chunked_upload_part_seq: (required) 11861 :param ChunkedUploadRequest chunked_upload_request: 11862 :return: ChunkedUploadResponse 11863 If the method is called asynchronously, 11864 returns the request thread. 11865 """ 11866 kwargs['_return_http_data_only'] = True 11867 if kwargs.get('callback'): 11868 return self.update_chunked_upload_part_with_http_info(account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs) 11869 else: 11870 (data) = self.update_chunked_upload_part_with_http_info(account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs) 11871 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)
11873 def update_chunked_upload_part_with_http_info(self, account_id, chunked_upload_id, chunked_upload_part_seq, **kwargs): 11874 """ 11875 Add a chunk, a chunk 'part', to an existing ChunkedUpload. 11876 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. 11877 This method makes a synchronous HTTP request by default. To make an 11878 asynchronous HTTP request, please define a `callback` function 11879 to be invoked when receiving the response. 11880 >>> def callback_function(response): 11881 >>> pprint(response) 11882 >>> 11883 >>> thread = api.update_chunked_upload_part_with_http_info(account_id, chunked_upload_id, chunked_upload_part_seq, callback=callback_function) 11884 11885 :param callback function: The callback function 11886 for asynchronous request. (optional) 11887 :param str account_id: The external account number (int) or account ID Guid. (required) 11888 :param str chunked_upload_id: (required) 11889 :param str chunked_upload_part_seq: (required) 11890 :param ChunkedUploadRequest chunked_upload_request: 11891 :return: ChunkedUploadResponse 11892 If the method is called asynchronously, 11893 returns the request thread. 11894 """ 11895 11896 all_params = ['account_id', 'chunked_upload_id', 'chunked_upload_part_seq', 'chunked_upload_request'] 11897 all_params.append('callback') 11898 all_params.append('_return_http_data_only') 11899 all_params.append('_preload_content') 11900 all_params.append('_request_timeout') 11901 11902 params = locals() 11903 for key, val in iteritems(params['kwargs']): 11904 if key not in all_params: 11905 raise TypeError( 11906 "Got an unexpected keyword argument '%s'" 11907 " to method update_chunked_upload_part" % key 11908 ) 11909 params[key] = val 11910 del params['kwargs'] 11911 # verify the required parameter 'account_id' is set 11912 if ('account_id' not in params) or (params['account_id'] is None): 11913 raise ValueError("Missing the required parameter `account_id` when calling `update_chunked_upload_part`") 11914 # verify the required parameter 'chunked_upload_id' is set 11915 if ('chunked_upload_id' not in params) or (params['chunked_upload_id'] is None): 11916 raise ValueError("Missing the required parameter `chunked_upload_id` when calling `update_chunked_upload_part`") 11917 # verify the required parameter 'chunked_upload_part_seq' is set 11918 if ('chunked_upload_part_seq' not in params) or (params['chunked_upload_part_seq'] is None): 11919 raise ValueError("Missing the required parameter `chunked_upload_part_seq` when calling `update_chunked_upload_part`") 11920 11921 11922 collection_formats = {} 11923 11924 resource_path = '/v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}/{chunkedUploadPartSeq}'.replace('{format}', 'json') 11925 path_params = {} 11926 if 'account_id' in params: 11927 path_params['accountId'] = params['account_id'] 11928 if 'chunked_upload_id' in params: 11929 path_params['chunkedUploadId'] = params['chunked_upload_id'] 11930 if 'chunked_upload_part_seq' in params: 11931 path_params['chunkedUploadPartSeq'] = params['chunked_upload_part_seq'] 11932 11933 query_params = {} 11934 11935 header_params = {} 11936 11937 form_params = [] 11938 local_var_files = {} 11939 11940 body_params = None 11941 if 'chunked_upload_request' in params: 11942 body_params = params['chunked_upload_request'] 11943 # HTTP header `Accept` 11944 header_params['Accept'] = self.api_client.\ 11945 select_header_accept(['application/json']) 11946 11947 # Authentication setting 11948 auth_settings = [] 11949 11950 return self.api_client.call_api(resource_path, 'PUT', 11951 path_params, 11952 query_params, 11953 header_params, 11954 body=body_params, 11955 post_params=form_params, 11956 files=local_var_files, 11957 response_type='ChunkedUploadResponse', 11958 auth_settings=auth_settings, 11959 callback=params.get('callback'), 11960 _return_http_data_only=params.get('_return_http_data_only'), 11961 _preload_content=params.get('_preload_content', True), 11962 _request_timeout=params.get('_request_timeout'), 11963 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)
11965 def update_custom_fields(self, account_id, envelope_id, **kwargs): 11966 """ 11967 Updates envelope custom fields in an envelope. 11968 Updates the envelope custom fields in draft and in-process envelopes. Each custom field used in an envelope must have a unique name. 11969 This method makes a synchronous HTTP request by default. To make an 11970 asynchronous HTTP request, please define a `callback` function 11971 to be invoked when receiving the response. 11972 >>> def callback_function(response): 11973 >>> pprint(response) 11974 >>> 11975 >>> thread = api.update_custom_fields(account_id, envelope_id, callback=callback_function) 11976 11977 :param callback function: The callback function 11978 for asynchronous request. (optional) 11979 :param str account_id: The external account number (int) or account ID Guid. (required) 11980 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 11981 :param CustomFields custom_fields: 11982 :return: CustomFields 11983 If the method is called asynchronously, 11984 returns the request thread. 11985 """ 11986 kwargs['_return_http_data_only'] = True 11987 if kwargs.get('callback'): 11988 return self.update_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 11989 else: 11990 (data) = self.update_custom_fields_with_http_info(account_id, envelope_id, **kwargs) 11991 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)
11993 def update_custom_fields_with_http_info(self, account_id, envelope_id, **kwargs): 11994 """ 11995 Updates envelope custom fields in an envelope. 11996 Updates the envelope custom fields in draft and in-process envelopes. Each custom field used in an envelope must have a unique name. 11997 This method makes a synchronous HTTP request by default. To make an 11998 asynchronous HTTP request, please define a `callback` function 11999 to be invoked when receiving the response. 12000 >>> def callback_function(response): 12001 >>> pprint(response) 12002 >>> 12003 >>> thread = api.update_custom_fields_with_http_info(account_id, envelope_id, callback=callback_function) 12004 12005 :param callback function: The callback function 12006 for asynchronous request. (optional) 12007 :param str account_id: The external account number (int) or account ID Guid. (required) 12008 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12009 :param CustomFields custom_fields: 12010 :return: CustomFields 12011 If the method is called asynchronously, 12012 returns the request thread. 12013 """ 12014 12015 all_params = ['account_id', 'envelope_id', 'custom_fields'] 12016 all_params.append('callback') 12017 all_params.append('_return_http_data_only') 12018 all_params.append('_preload_content') 12019 all_params.append('_request_timeout') 12020 12021 params = locals() 12022 for key, val in iteritems(params['kwargs']): 12023 if key not in all_params: 12024 raise TypeError( 12025 "Got an unexpected keyword argument '%s'" 12026 " to method update_custom_fields" % key 12027 ) 12028 params[key] = val 12029 del params['kwargs'] 12030 # verify the required parameter 'account_id' is set 12031 if ('account_id' not in params) or (params['account_id'] is None): 12032 raise ValueError("Missing the required parameter `account_id` when calling `update_custom_fields`") 12033 # verify the required parameter 'envelope_id' is set 12034 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12035 raise ValueError("Missing the required parameter `envelope_id` when calling `update_custom_fields`") 12036 12037 12038 collection_formats = {} 12039 12040 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/custom_fields'.replace('{format}', 'json') 12041 path_params = {} 12042 if 'account_id' in params: 12043 path_params['accountId'] = params['account_id'] 12044 if 'envelope_id' in params: 12045 path_params['envelopeId'] = params['envelope_id'] 12046 12047 query_params = {} 12048 12049 header_params = {} 12050 12051 form_params = [] 12052 local_var_files = {} 12053 12054 body_params = None 12055 if 'custom_fields' in params: 12056 body_params = params['custom_fields'] 12057 # HTTP header `Accept` 12058 header_params['Accept'] = self.api_client.\ 12059 select_header_accept(['application/json']) 12060 12061 # Authentication setting 12062 auth_settings = [] 12063 12064 return self.api_client.call_api(resource_path, 'PUT', 12065 path_params, 12066 query_params, 12067 header_params, 12068 body=body_params, 12069 post_params=form_params, 12070 files=local_var_files, 12071 response_type='CustomFields', 12072 auth_settings=auth_settings, 12073 callback=params.get('callback'), 12074 _return_http_data_only=params.get('_return_http_data_only'), 12075 _preload_content=params.get('_preload_content', True), 12076 _request_timeout=params.get('_request_timeout'), 12077 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)
12079 def update_document(self, account_id, document_id, envelope_id, document_file_bytes, **kwargs): 12080 """ 12081 Adds a document to an existing draft envelope. 12082 Adds a document to an existing draft envelope. 12083 This method makes a synchronous HTTP request by default. To make an 12084 asynchronous HTTP request, please define a `callback` function 12085 to be invoked when receiving the response. 12086 >>> def callback_function(response): 12087 >>> pprint(response) 12088 >>> 12089 >>> thread = api.update_document(account_id, document_id, envelope_id, document_file_bytes, callback=callback_function) 12090 12091 :param callback function: The callback function 12092 for asynchronous request. (optional) 12093 :param str account_id: The external account number (int) or account ID Guid. (required) 12094 :param str document_id: The ID of the document being accessed. (required) 12095 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12096 :param str document_file_bytes: Updated document content. (required) 12097 :return: EnvelopeDocument 12098 If the method is called asynchronously, 12099 returns the request thread. 12100 """ 12101 kwargs['_return_http_data_only'] = True 12102 if kwargs.get('callback'): 12103 return self.update_document_with_http_info(account_id, document_id, envelope_id, document_file_bytes, **kwargs) 12104 else: 12105 (data) = self.update_document_with_http_info(account_id, document_id, envelope_id, document_file_bytes, **kwargs) 12106 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)
12108 def update_document_with_http_info(self, account_id, document_id, envelope_id, document_file_bytes, **kwargs): 12109 """ 12110 Adds a document to an existing draft envelope. 12111 Adds a document to an existing draft envelope. 12112 This method makes a synchronous HTTP request by default. To make an 12113 asynchronous HTTP request, please define a `callback` function 12114 to be invoked when receiving the response. 12115 >>> def callback_function(response): 12116 >>> pprint(response) 12117 >>> 12118 >>> thread = api.update_document_with_http_info(account_id, document_id, envelope_id, document_file_bytes, callback=callback_function) 12119 12120 :param callback function: The callback function 12121 for asynchronous request. (optional) 12122 :param str account_id: The external account number (int) or account ID Guid. (required) 12123 :param str document_id: The ID of the document being accessed. (required) 12124 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12125 :param str document_file_bytes: Updated document content. (required) 12126 :return: EnvelopeDocument 12127 If the method is called asynchronously, 12128 returns the request thread. 12129 """ 12130 12131 all_params = ['account_id', 'document_id', 'envelope_id', 'document_file_bytes'] 12132 all_params.append('callback') 12133 all_params.append('_return_http_data_only') 12134 all_params.append('_preload_content') 12135 all_params.append('_request_timeout') 12136 12137 params = locals() 12138 for key, val in iteritems(params['kwargs']): 12139 if key not in all_params: 12140 raise TypeError( 12141 "Got an unexpected keyword argument '%s'" 12142 " to method update_document" % key 12143 ) 12144 params[key] = val 12145 del params['kwargs'] 12146 # verify the required parameter 'account_id' is set 12147 if ('account_id' not in params) or (params['account_id'] is None): 12148 raise ValueError("Missing the required parameter `account_id` when calling `update_document`") 12149 # verify the required parameter 'document_id' is set 12150 if ('document_id' not in params) or (params['document_id'] is None): 12151 raise ValueError("Missing the required parameter `document_id` when calling `update_document`") 12152 # verify the required parameter 'envelope_id' is set 12153 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12154 raise ValueError("Missing the required parameter `envelope_id` when calling `update_document`") 12155 # verify the required parameter 'document_file_bytes' is set 12156 if ('document_file_bytes' not in params) or (params['document_file_bytes'] is None): 12157 raise ValueError("Missing the required parameter `document_file_bytes` when calling `update_document`") 12158 12159 12160 collection_formats = {} 12161 12162 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}'.replace('{format}', 'json') 12163 path_params = {} 12164 if 'account_id' in params: 12165 path_params['accountId'] = params['account_id'] 12166 if 'document_id' in params: 12167 path_params['documentId'] = params['document_id'] 12168 if 'envelope_id' in params: 12169 path_params['envelopeId'] = params['envelope_id'] 12170 12171 query_params = {} 12172 12173 header_params = {} 12174 12175 form_params = [] 12176 local_var_files = {} 12177 12178 body_params = None 12179 if 'document_file_bytes' in params: 12180 body_params = params['document_file_bytes'] 12181 # HTTP header `Accept` 12182 header_params['Accept'] = self.api_client.\ 12183 select_header_accept(['application/json']) 12184 12185 # HTTP header `Content-Type` 12186 header_params['Content-Type'] = self.api_client.\ 12187 select_header_content_type(['application/pdf']) 12188 12189 # Authentication setting 12190 auth_settings = [] 12191 12192 return self.api_client.call_api(resource_path, 'PUT', 12193 path_params, 12194 query_params, 12195 header_params, 12196 body=body_params, 12197 post_params=form_params, 12198 files=local_var_files, 12199 response_type='EnvelopeDocument', 12200 auth_settings=auth_settings, 12201 callback=params.get('callback'), 12202 _return_http_data_only=params.get('_return_http_data_only'), 12203 _preload_content=params.get('_preload_content', True), 12204 _request_timeout=params.get('_request_timeout'), 12205 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)
12207 def update_document_fields(self, account_id, document_id, envelope_id, **kwargs): 12208 """ 12209 Updates existing custom document fields in an existing envelope document. 12210 Updates existing custom document fields in an existing envelope document. 12211 This method makes a synchronous HTTP request by default. To make an 12212 asynchronous HTTP request, please define a `callback` function 12213 to be invoked when receiving the response. 12214 >>> def callback_function(response): 12215 >>> pprint(response) 12216 >>> 12217 >>> thread = api.update_document_fields(account_id, document_id, envelope_id, callback=callback_function) 12218 12219 :param callback function: The callback function 12220 for asynchronous request. (optional) 12221 :param str account_id: The external account number (int) or account ID Guid. (required) 12222 :param str document_id: The ID of the document being accessed. (required) 12223 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12224 :param DocumentFieldsInformation document_fields_information: 12225 :return: DocumentFieldsInformation 12226 If the method is called asynchronously, 12227 returns the request thread. 12228 """ 12229 kwargs['_return_http_data_only'] = True 12230 if kwargs.get('callback'): 12231 return self.update_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 12232 else: 12233 (data) = self.update_document_fields_with_http_info(account_id, document_id, envelope_id, **kwargs) 12234 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)
12236 def update_document_fields_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 12237 """ 12238 Updates existing custom document fields in an existing envelope document. 12239 Updates existing custom document fields in an existing envelope document. 12240 This method makes a synchronous HTTP request by default. To make an 12241 asynchronous HTTP request, please define a `callback` function 12242 to be invoked when receiving the response. 12243 >>> def callback_function(response): 12244 >>> pprint(response) 12245 >>> 12246 >>> thread = api.update_document_fields_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 12247 12248 :param callback function: The callback function 12249 for asynchronous request. (optional) 12250 :param str account_id: The external account number (int) or account ID Guid. (required) 12251 :param str document_id: The ID of the document being accessed. (required) 12252 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12253 :param DocumentFieldsInformation document_fields_information: 12254 :return: DocumentFieldsInformation 12255 If the method is called asynchronously, 12256 returns the request thread. 12257 """ 12258 12259 all_params = ['account_id', 'document_id', 'envelope_id', 'document_fields_information'] 12260 all_params.append('callback') 12261 all_params.append('_return_http_data_only') 12262 all_params.append('_preload_content') 12263 all_params.append('_request_timeout') 12264 12265 params = locals() 12266 for key, val in iteritems(params['kwargs']): 12267 if key not in all_params: 12268 raise TypeError( 12269 "Got an unexpected keyword argument '%s'" 12270 " to method update_document_fields" % key 12271 ) 12272 params[key] = val 12273 del params['kwargs'] 12274 # verify the required parameter 'account_id' is set 12275 if ('account_id' not in params) or (params['account_id'] is None): 12276 raise ValueError("Missing the required parameter `account_id` when calling `update_document_fields`") 12277 # verify the required parameter 'document_id' is set 12278 if ('document_id' not in params) or (params['document_id'] is None): 12279 raise ValueError("Missing the required parameter `document_id` when calling `update_document_fields`") 12280 # verify the required parameter 'envelope_id' is set 12281 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12282 raise ValueError("Missing the required parameter `envelope_id` when calling `update_document_fields`") 12283 12284 12285 collection_formats = {} 12286 12287 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/fields'.replace('{format}', 'json') 12288 path_params = {} 12289 if 'account_id' in params: 12290 path_params['accountId'] = params['account_id'] 12291 if 'document_id' in params: 12292 path_params['documentId'] = params['document_id'] 12293 if 'envelope_id' in params: 12294 path_params['envelopeId'] = params['envelope_id'] 12295 12296 query_params = {} 12297 12298 header_params = {} 12299 12300 form_params = [] 12301 local_var_files = {} 12302 12303 body_params = None 12304 if 'document_fields_information' in params: 12305 body_params = params['document_fields_information'] 12306 # HTTP header `Accept` 12307 header_params['Accept'] = self.api_client.\ 12308 select_header_accept(['application/json']) 12309 12310 # Authentication setting 12311 auth_settings = [] 12312 12313 return self.api_client.call_api(resource_path, 'PUT', 12314 path_params, 12315 query_params, 12316 header_params, 12317 body=body_params, 12318 post_params=form_params, 12319 files=local_var_files, 12320 response_type='DocumentFieldsInformation', 12321 auth_settings=auth_settings, 12322 callback=params.get('callback'), 12323 _return_http_data_only=params.get('_return_http_data_only'), 12324 _preload_content=params.get('_preload_content', True), 12325 _request_timeout=params.get('_request_timeout'), 12326 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)
12328 def update_document_tabs(self, account_id, document_id, envelope_id, **kwargs): 12329 """ 12330 Updates the tabs for an envelope document 12331 Updates tabs in the document specified by `documentId` in the envelope specified by `envelopeId`. 12332 This method makes a synchronous HTTP request by default. To make an 12333 asynchronous HTTP request, please define a `callback` function 12334 to be invoked when receiving the response. 12335 >>> def callback_function(response): 12336 >>> pprint(response) 12337 >>> 12338 >>> thread = api.update_document_tabs(account_id, document_id, envelope_id, callback=callback_function) 12339 12340 :param callback function: The callback function 12341 for asynchronous request. (optional) 12342 :param str account_id: The external account number (int) or account ID Guid. (required) 12343 :param str document_id: The ID of the document being accessed. (required) 12344 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12345 :param Tabs tabs: 12346 :return: Tabs 12347 If the method is called asynchronously, 12348 returns the request thread. 12349 """ 12350 kwargs['_return_http_data_only'] = True 12351 if kwargs.get('callback'): 12352 return self.update_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 12353 else: 12354 (data) = self.update_document_tabs_with_http_info(account_id, document_id, envelope_id, **kwargs) 12355 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)
12357 def update_document_tabs_with_http_info(self, account_id, document_id, envelope_id, **kwargs): 12358 """ 12359 Updates the tabs for an envelope document 12360 Updates tabs in the document specified by `documentId` in the envelope specified by `envelopeId`. 12361 This method makes a synchronous HTTP request by default. To make an 12362 asynchronous HTTP request, please define a `callback` function 12363 to be invoked when receiving the response. 12364 >>> def callback_function(response): 12365 >>> pprint(response) 12366 >>> 12367 >>> thread = api.update_document_tabs_with_http_info(account_id, document_id, envelope_id, callback=callback_function) 12368 12369 :param callback function: The callback function 12370 for asynchronous request. (optional) 12371 :param str account_id: The external account number (int) or account ID Guid. (required) 12372 :param str document_id: The ID of the document being accessed. (required) 12373 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12374 :param Tabs tabs: 12375 :return: Tabs 12376 If the method is called asynchronously, 12377 returns the request thread. 12378 """ 12379 12380 all_params = ['account_id', 'document_id', 'envelope_id', 'tabs'] 12381 all_params.append('callback') 12382 all_params.append('_return_http_data_only') 12383 all_params.append('_preload_content') 12384 all_params.append('_request_timeout') 12385 12386 params = locals() 12387 for key, val in iteritems(params['kwargs']): 12388 if key not in all_params: 12389 raise TypeError( 12390 "Got an unexpected keyword argument '%s'" 12391 " to method update_document_tabs" % key 12392 ) 12393 params[key] = val 12394 del params['kwargs'] 12395 # verify the required parameter 'account_id' is set 12396 if ('account_id' not in params) or (params['account_id'] is None): 12397 raise ValueError("Missing the required parameter `account_id` when calling `update_document_tabs`") 12398 # verify the required parameter 'document_id' is set 12399 if ('document_id' not in params) or (params['document_id'] is None): 12400 raise ValueError("Missing the required parameter `document_id` when calling `update_document_tabs`") 12401 # verify the required parameter 'envelope_id' is set 12402 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12403 raise ValueError("Missing the required parameter `envelope_id` when calling `update_document_tabs`") 12404 12405 12406 collection_formats = {} 12407 12408 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/tabs'.replace('{format}', 'json') 12409 path_params = {} 12410 if 'account_id' in params: 12411 path_params['accountId'] = params['account_id'] 12412 if 'document_id' in params: 12413 path_params['documentId'] = params['document_id'] 12414 if 'envelope_id' in params: 12415 path_params['envelopeId'] = params['envelope_id'] 12416 12417 query_params = {} 12418 12419 header_params = {} 12420 12421 form_params = [] 12422 local_var_files = {} 12423 12424 body_params = None 12425 if 'tabs' in params: 12426 body_params = params['tabs'] 12427 # HTTP header `Accept` 12428 header_params['Accept'] = self.api_client.\ 12429 select_header_accept(['application/json']) 12430 12431 # Authentication setting 12432 auth_settings = [] 12433 12434 return self.api_client.call_api(resource_path, 'PUT', 12435 path_params, 12436 query_params, 12437 header_params, 12438 body=body_params, 12439 post_params=form_params, 12440 files=local_var_files, 12441 response_type='Tabs', 12442 auth_settings=auth_settings, 12443 callback=params.get('callback'), 12444 _return_http_data_only=params.get('_return_http_data_only'), 12445 _preload_content=params.get('_preload_content', True), 12446 _request_timeout=params.get('_request_timeout'), 12447 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)
12449 def update_documents(self, account_id, envelope_id, **kwargs): 12450 """ 12451 Adds one or more documents to an existing envelope document. 12452 Adds one or more documents to an existing envelope document. 12453 This method makes a synchronous HTTP request by default. To make an 12454 asynchronous HTTP request, please define a `callback` function 12455 to be invoked when receiving the response. 12456 >>> def callback_function(response): 12457 >>> pprint(response) 12458 >>> 12459 >>> thread = api.update_documents(account_id, envelope_id, callback=callback_function) 12460 12461 :param callback function: The callback function 12462 for asynchronous request. (optional) 12463 :param str account_id: The external account number (int) or account ID Guid. (required) 12464 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12465 :param EnvelopeDefinition envelope_definition: 12466 :return: EnvelopeDocumentsResult 12467 If the method is called asynchronously, 12468 returns the request thread. 12469 """ 12470 kwargs['_return_http_data_only'] = True 12471 if kwargs.get('callback'): 12472 return self.update_documents_with_http_info(account_id, envelope_id, **kwargs) 12473 else: 12474 (data) = self.update_documents_with_http_info(account_id, envelope_id, **kwargs) 12475 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)
12477 def update_documents_with_http_info(self, account_id, envelope_id, **kwargs): 12478 """ 12479 Adds one or more documents to an existing envelope document. 12480 Adds one or more documents to an existing envelope document. 12481 This method makes a synchronous HTTP request by default. To make an 12482 asynchronous HTTP request, please define a `callback` function 12483 to be invoked when receiving the response. 12484 >>> def callback_function(response): 12485 >>> pprint(response) 12486 >>> 12487 >>> thread = api.update_documents_with_http_info(account_id, envelope_id, callback=callback_function) 12488 12489 :param callback function: The callback function 12490 for asynchronous request. (optional) 12491 :param str account_id: The external account number (int) or account ID Guid. (required) 12492 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12493 :param EnvelopeDefinition envelope_definition: 12494 :return: EnvelopeDocumentsResult 12495 If the method is called asynchronously, 12496 returns the request thread. 12497 """ 12498 12499 all_params = ['account_id', 'envelope_id', 'envelope_definition'] 12500 all_params.append('callback') 12501 all_params.append('_return_http_data_only') 12502 all_params.append('_preload_content') 12503 all_params.append('_request_timeout') 12504 12505 params = locals() 12506 for key, val in iteritems(params['kwargs']): 12507 if key not in all_params: 12508 raise TypeError( 12509 "Got an unexpected keyword argument '%s'" 12510 " to method update_documents" % key 12511 ) 12512 params[key] = val 12513 del params['kwargs'] 12514 # verify the required parameter 'account_id' is set 12515 if ('account_id' not in params) or (params['account_id'] is None): 12516 raise ValueError("Missing the required parameter `account_id` when calling `update_documents`") 12517 # verify the required parameter 'envelope_id' is set 12518 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12519 raise ValueError("Missing the required parameter `envelope_id` when calling `update_documents`") 12520 12521 12522 collection_formats = {} 12523 12524 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents'.replace('{format}', 'json') 12525 path_params = {} 12526 if 'account_id' in params: 12527 path_params['accountId'] = params['account_id'] 12528 if 'envelope_id' in params: 12529 path_params['envelopeId'] = params['envelope_id'] 12530 12531 query_params = {} 12532 12533 header_params = {} 12534 12535 form_params = [] 12536 local_var_files = {} 12537 12538 body_params = None 12539 if 'envelope_definition' in params: 12540 body_params = params['envelope_definition'] 12541 # HTTP header `Accept` 12542 header_params['Accept'] = self.api_client.\ 12543 select_header_accept(['application/json']) 12544 12545 # Authentication setting 12546 auth_settings = [] 12547 12548 return self.api_client.call_api(resource_path, 'PUT', 12549 path_params, 12550 query_params, 12551 header_params, 12552 body=body_params, 12553 post_params=form_params, 12554 files=local_var_files, 12555 response_type='EnvelopeDocumentsResult', 12556 auth_settings=auth_settings, 12557 callback=params.get('callback'), 12558 _return_http_data_only=params.get('_return_http_data_only'), 12559 _preload_content=params.get('_preload_content', True), 12560 _request_timeout=params.get('_request_timeout'), 12561 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)
12563 def update_email_settings(self, account_id, envelope_id, **kwargs): 12564 """ 12565 Updates the email setting overrides for an envelope. 12566 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. 12567 This method makes a synchronous HTTP request by default. To make an 12568 asynchronous HTTP request, please define a `callback` function 12569 to be invoked when receiving the response. 12570 >>> def callback_function(response): 12571 >>> pprint(response) 12572 >>> 12573 >>> thread = api.update_email_settings(account_id, envelope_id, callback=callback_function) 12574 12575 :param callback function: The callback function 12576 for asynchronous request. (optional) 12577 :param str account_id: The external account number (int) or account ID Guid. (required) 12578 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12579 :param EmailSettings email_settings: 12580 :return: EmailSettings 12581 If the method is called asynchronously, 12582 returns the request thread. 12583 """ 12584 kwargs['_return_http_data_only'] = True 12585 if kwargs.get('callback'): 12586 return self.update_email_settings_with_http_info(account_id, envelope_id, **kwargs) 12587 else: 12588 (data) = self.update_email_settings_with_http_info(account_id, envelope_id, **kwargs) 12589 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)
12591 def update_email_settings_with_http_info(self, account_id, envelope_id, **kwargs): 12592 """ 12593 Updates the email setting overrides for an envelope. 12594 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. 12595 This method makes a synchronous HTTP request by default. To make an 12596 asynchronous HTTP request, please define a `callback` function 12597 to be invoked when receiving the response. 12598 >>> def callback_function(response): 12599 >>> pprint(response) 12600 >>> 12601 >>> thread = api.update_email_settings_with_http_info(account_id, envelope_id, callback=callback_function) 12602 12603 :param callback function: The callback function 12604 for asynchronous request. (optional) 12605 :param str account_id: The external account number (int) or account ID Guid. (required) 12606 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12607 :param EmailSettings email_settings: 12608 :return: EmailSettings 12609 If the method is called asynchronously, 12610 returns the request thread. 12611 """ 12612 12613 all_params = ['account_id', 'envelope_id', 'email_settings'] 12614 all_params.append('callback') 12615 all_params.append('_return_http_data_only') 12616 all_params.append('_preload_content') 12617 all_params.append('_request_timeout') 12618 12619 params = locals() 12620 for key, val in iteritems(params['kwargs']): 12621 if key not in all_params: 12622 raise TypeError( 12623 "Got an unexpected keyword argument '%s'" 12624 " to method update_email_settings" % key 12625 ) 12626 params[key] = val 12627 del params['kwargs'] 12628 # verify the required parameter 'account_id' is set 12629 if ('account_id' not in params) or (params['account_id'] is None): 12630 raise ValueError("Missing the required parameter `account_id` when calling `update_email_settings`") 12631 # verify the required parameter 'envelope_id' is set 12632 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12633 raise ValueError("Missing the required parameter `envelope_id` when calling `update_email_settings`") 12634 12635 12636 collection_formats = {} 12637 12638 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/email_settings'.replace('{format}', 'json') 12639 path_params = {} 12640 if 'account_id' in params: 12641 path_params['accountId'] = params['account_id'] 12642 if 'envelope_id' in params: 12643 path_params['envelopeId'] = params['envelope_id'] 12644 12645 query_params = {} 12646 12647 header_params = {} 12648 12649 form_params = [] 12650 local_var_files = {} 12651 12652 body_params = None 12653 if 'email_settings' in params: 12654 body_params = params['email_settings'] 12655 # HTTP header `Accept` 12656 header_params['Accept'] = self.api_client.\ 12657 select_header_accept(['application/json']) 12658 12659 # Authentication setting 12660 auth_settings = [] 12661 12662 return self.api_client.call_api(resource_path, 'PUT', 12663 path_params, 12664 query_params, 12665 header_params, 12666 body=body_params, 12667 post_params=form_params, 12668 files=local_var_files, 12669 response_type='EmailSettings', 12670 auth_settings=auth_settings, 12671 callback=params.get('callback'), 12672 _return_http_data_only=params.get('_return_http_data_only'), 12673 _preload_content=params.get('_preload_content', True), 12674 _request_timeout=params.get('_request_timeout'), 12675 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)
12677 def update_envelope_delayed_routing_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 12678 """ 12679 Updates the delayed routing rules for an envelope's workflow step definition. 12680 This method makes a synchronous HTTP request by default. To make an 12681 asynchronous HTTP request, please define a `callback` function 12682 to be invoked when receiving the response. 12683 >>> def callback_function(response): 12684 >>> pprint(response) 12685 >>> 12686 >>> thread = api.update_envelope_delayed_routing_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 12687 12688 :param callback function: The callback function 12689 for asynchronous request. (optional) 12690 :param str account_id: The external account number (int) or account ID Guid. (required) 12691 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12692 :param str workflow_step_id: (required) 12693 :param DelayedRouting delayed_routing: 12694 :return: DelayedRouting 12695 If the method is called asynchronously, 12696 returns the request thread. 12697 """ 12698 kwargs['_return_http_data_only'] = True 12699 if kwargs.get('callback'): 12700 return self.update_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 12701 else: 12702 (data) = self.update_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 12703 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)
12705 def update_envelope_delayed_routing_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 12706 """ 12707 Updates the delayed routing rules for an envelope's workflow step definition. 12708 This method makes a synchronous HTTP request by default. To make an 12709 asynchronous HTTP request, please define a `callback` function 12710 to be invoked when receiving the response. 12711 >>> def callback_function(response): 12712 >>> pprint(response) 12713 >>> 12714 >>> thread = api.update_envelope_delayed_routing_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 12715 12716 :param callback function: The callback function 12717 for asynchronous request. (optional) 12718 :param str account_id: The external account number (int) or account ID Guid. (required) 12719 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12720 :param str workflow_step_id: (required) 12721 :param DelayedRouting delayed_routing: 12722 :return: DelayedRouting 12723 If the method is called asynchronously, 12724 returns the request thread. 12725 """ 12726 12727 all_params = ['account_id', 'envelope_id', 'workflow_step_id', 'delayed_routing'] 12728 all_params.append('callback') 12729 all_params.append('_return_http_data_only') 12730 all_params.append('_preload_content') 12731 all_params.append('_request_timeout') 12732 12733 params = locals() 12734 for key, val in iteritems(params['kwargs']): 12735 if key not in all_params: 12736 raise TypeError( 12737 "Got an unexpected keyword argument '%s'" 12738 " to method update_envelope_delayed_routing_definition" % key 12739 ) 12740 params[key] = val 12741 del params['kwargs'] 12742 # verify the required parameter 'account_id' is set 12743 if ('account_id' not in params) or (params['account_id'] is None): 12744 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_delayed_routing_definition`") 12745 # verify the required parameter 'envelope_id' is set 12746 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12747 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_delayed_routing_definition`") 12748 # verify the required parameter 'workflow_step_id' is set 12749 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 12750 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_envelope_delayed_routing_definition`") 12751 12752 12753 collection_formats = {} 12754 12755 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 12756 path_params = {} 12757 if 'account_id' in params: 12758 path_params['accountId'] = params['account_id'] 12759 if 'envelope_id' in params: 12760 path_params['envelopeId'] = params['envelope_id'] 12761 if 'workflow_step_id' in params: 12762 path_params['workflowStepId'] = params['workflow_step_id'] 12763 12764 query_params = {} 12765 12766 header_params = {} 12767 12768 form_params = [] 12769 local_var_files = {} 12770 12771 body_params = None 12772 if 'delayed_routing' in params: 12773 body_params = params['delayed_routing'] 12774 # HTTP header `Accept` 12775 header_params['Accept'] = self.api_client.\ 12776 select_header_accept(['application/json']) 12777 12778 # Authentication setting 12779 auth_settings = [] 12780 12781 return self.api_client.call_api(resource_path, 'PUT', 12782 path_params, 12783 query_params, 12784 header_params, 12785 body=body_params, 12786 post_params=form_params, 12787 files=local_var_files, 12788 response_type='DelayedRouting', 12789 auth_settings=auth_settings, 12790 callback=params.get('callback'), 12791 _return_http_data_only=params.get('_return_http_data_only'), 12792 _preload_content=params.get('_preload_content', True), 12793 _request_timeout=params.get('_request_timeout'), 12794 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)
12796 def update_envelope_doc_gen_form_fields(self, account_id, envelope_id, **kwargs): 12797 """ 12798 Updates formfields for an envelope 12799 This method makes a synchronous HTTP request by default. To make an 12800 asynchronous HTTP request, please define a `callback` function 12801 to be invoked when receiving the response. 12802 >>> def callback_function(response): 12803 >>> pprint(response) 12804 >>> 12805 >>> thread = api.update_envelope_doc_gen_form_fields(account_id, envelope_id, callback=callback_function) 12806 12807 :param callback function: The callback function 12808 for asynchronous request. (optional) 12809 :param str account_id: The external account number (int) or account ID Guid. (required) 12810 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12811 :param str update_docgen_formfields_only: 12812 :param DocGenFormFieldRequest doc_gen_form_field_request: 12813 :return: DocGenFormFieldResponse 12814 If the method is called asynchronously, 12815 returns the request thread. 12816 """ 12817 kwargs['_return_http_data_only'] = True 12818 if kwargs.get('callback'): 12819 return self.update_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, **kwargs) 12820 else: 12821 (data) = self.update_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, **kwargs) 12822 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)
12824 def update_envelope_doc_gen_form_fields_with_http_info(self, account_id, envelope_id, **kwargs): 12825 """ 12826 Updates formfields for an envelope 12827 This method makes a synchronous HTTP request by default. To make an 12828 asynchronous HTTP request, please define a `callback` function 12829 to be invoked when receiving the response. 12830 >>> def callback_function(response): 12831 >>> pprint(response) 12832 >>> 12833 >>> thread = api.update_envelope_doc_gen_form_fields_with_http_info(account_id, envelope_id, callback=callback_function) 12834 12835 :param callback function: The callback function 12836 for asynchronous request. (optional) 12837 :param str account_id: The external account number (int) or account ID Guid. (required) 12838 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12839 :param str update_docgen_formfields_only: 12840 :param DocGenFormFieldRequest doc_gen_form_field_request: 12841 :return: DocGenFormFieldResponse 12842 If the method is called asynchronously, 12843 returns the request thread. 12844 """ 12845 12846 all_params = ['account_id', 'envelope_id', 'update_docgen_formfields_only', 'doc_gen_form_field_request'] 12847 all_params.append('callback') 12848 all_params.append('_return_http_data_only') 12849 all_params.append('_preload_content') 12850 all_params.append('_request_timeout') 12851 12852 params = locals() 12853 for key, val in iteritems(params['kwargs']): 12854 if key not in all_params: 12855 raise TypeError( 12856 "Got an unexpected keyword argument '%s'" 12857 " to method update_envelope_doc_gen_form_fields" % key 12858 ) 12859 params[key] = val 12860 del params['kwargs'] 12861 # verify the required parameter 'account_id' is set 12862 if ('account_id' not in params) or (params['account_id'] is None): 12863 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_doc_gen_form_fields`") 12864 # verify the required parameter 'envelope_id' is set 12865 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12866 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_doc_gen_form_fields`") 12867 12868 12869 collection_formats = {} 12870 12871 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/docGenFormFields'.replace('{format}', 'json') 12872 path_params = {} 12873 if 'account_id' in params: 12874 path_params['accountId'] = params['account_id'] 12875 if 'envelope_id' in params: 12876 path_params['envelopeId'] = params['envelope_id'] 12877 12878 query_params = {} 12879 if 'update_docgen_formfields_only' in params: 12880 query_params['update_docgen_formfields_only'] = params['update_docgen_formfields_only'] 12881 12882 header_params = {} 12883 12884 form_params = [] 12885 local_var_files = {} 12886 12887 body_params = None 12888 if 'doc_gen_form_field_request' in params: 12889 body_params = params['doc_gen_form_field_request'] 12890 # HTTP header `Accept` 12891 header_params['Accept'] = self.api_client.\ 12892 select_header_accept(['application/json']) 12893 12894 # Authentication setting 12895 auth_settings = [] 12896 12897 return self.api_client.call_api(resource_path, 'PUT', 12898 path_params, 12899 query_params, 12900 header_params, 12901 body=body_params, 12902 post_params=form_params, 12903 files=local_var_files, 12904 response_type='DocGenFormFieldResponse', 12905 auth_settings=auth_settings, 12906 callback=params.get('callback'), 12907 _return_http_data_only=params.get('_return_http_data_only'), 12908 _preload_content=params.get('_preload_content', True), 12909 _request_timeout=params.get('_request_timeout'), 12910 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)
12912 def update_envelope_scheduled_sending_definition(self, account_id, envelope_id, **kwargs): 12913 """ 12914 Updates the scheduled sending rules for an envelope's workflow definition. 12915 This method makes a synchronous HTTP request by default. To make an 12916 asynchronous HTTP request, please define a `callback` function 12917 to be invoked when receiving the response. 12918 >>> def callback_function(response): 12919 >>> pprint(response) 12920 >>> 12921 >>> thread = api.update_envelope_scheduled_sending_definition(account_id, envelope_id, callback=callback_function) 12922 12923 :param callback function: The callback function 12924 for asynchronous request. (optional) 12925 :param str account_id: The external account number (int) or account ID Guid. (required) 12926 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12927 :param ScheduledSending scheduled_sending: 12928 :return: ScheduledSending 12929 If the method is called asynchronously, 12930 returns the request thread. 12931 """ 12932 kwargs['_return_http_data_only'] = True 12933 if kwargs.get('callback'): 12934 return self.update_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 12935 else: 12936 (data) = self.update_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, **kwargs) 12937 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)
12939 def update_envelope_scheduled_sending_definition_with_http_info(self, account_id, envelope_id, **kwargs): 12940 """ 12941 Updates the scheduled sending rules for an envelope's workflow definition. 12942 This method makes a synchronous HTTP request by default. To make an 12943 asynchronous HTTP request, please define a `callback` function 12944 to be invoked when receiving the response. 12945 >>> def callback_function(response): 12946 >>> pprint(response) 12947 >>> 12948 >>> thread = api.update_envelope_scheduled_sending_definition_with_http_info(account_id, envelope_id, callback=callback_function) 12949 12950 :param callback function: The callback function 12951 for asynchronous request. (optional) 12952 :param str account_id: The external account number (int) or account ID Guid. (required) 12953 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 12954 :param ScheduledSending scheduled_sending: 12955 :return: ScheduledSending 12956 If the method is called asynchronously, 12957 returns the request thread. 12958 """ 12959 12960 all_params = ['account_id', 'envelope_id', 'scheduled_sending'] 12961 all_params.append('callback') 12962 all_params.append('_return_http_data_only') 12963 all_params.append('_preload_content') 12964 all_params.append('_request_timeout') 12965 12966 params = locals() 12967 for key, val in iteritems(params['kwargs']): 12968 if key not in all_params: 12969 raise TypeError( 12970 "Got an unexpected keyword argument '%s'" 12971 " to method update_envelope_scheduled_sending_definition" % key 12972 ) 12973 params[key] = val 12974 del params['kwargs'] 12975 # verify the required parameter 'account_id' is set 12976 if ('account_id' not in params) or (params['account_id'] is None): 12977 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_scheduled_sending_definition`") 12978 # verify the required parameter 'envelope_id' is set 12979 if ('envelope_id' not in params) or (params['envelope_id'] is None): 12980 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_scheduled_sending_definition`") 12981 12982 12983 collection_formats = {} 12984 12985 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/scheduledSending'.replace('{format}', 'json') 12986 path_params = {} 12987 if 'account_id' in params: 12988 path_params['accountId'] = params['account_id'] 12989 if 'envelope_id' in params: 12990 path_params['envelopeId'] = params['envelope_id'] 12991 12992 query_params = {} 12993 12994 header_params = {} 12995 12996 form_params = [] 12997 local_var_files = {} 12998 12999 body_params = None 13000 if 'scheduled_sending' in params: 13001 body_params = params['scheduled_sending'] 13002 # HTTP header `Accept` 13003 header_params['Accept'] = self.api_client.\ 13004 select_header_accept(['application/json']) 13005 13006 # Authentication setting 13007 auth_settings = [] 13008 13009 return self.api_client.call_api(resource_path, 'PUT', 13010 path_params, 13011 query_params, 13012 header_params, 13013 body=body_params, 13014 post_params=form_params, 13015 files=local_var_files, 13016 response_type='ScheduledSending', 13017 auth_settings=auth_settings, 13018 callback=params.get('callback'), 13019 _return_http_data_only=params.get('_return_http_data_only'), 13020 _preload_content=params.get('_preload_content', True), 13021 _request_timeout=params.get('_request_timeout'), 13022 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)
13024 def update_envelope_transfer_rule(self, account_id, envelope_transfer_rule_id, **kwargs): 13025 """ 13026 Update an envelope transfer rule for an account. 13027 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. 13028 This method makes a synchronous HTTP request by default. To make an 13029 asynchronous HTTP request, please define a `callback` function 13030 to be invoked when receiving the response. 13031 >>> def callback_function(response): 13032 >>> pprint(response) 13033 >>> 13034 >>> thread = api.update_envelope_transfer_rule(account_id, envelope_transfer_rule_id, callback=callback_function) 13035 13036 :param callback function: The callback function 13037 for asynchronous request. (optional) 13038 :param str account_id: The external account number (int) or account ID Guid. (required) 13039 :param str envelope_transfer_rule_id: (required) 13040 :param EnvelopeTransferRule envelope_transfer_rule: 13041 :return: EnvelopeTransferRule 13042 If the method is called asynchronously, 13043 returns the request thread. 13044 """ 13045 kwargs['_return_http_data_only'] = True 13046 if kwargs.get('callback'): 13047 return self.update_envelope_transfer_rule_with_http_info(account_id, envelope_transfer_rule_id, **kwargs) 13048 else: 13049 (data) = self.update_envelope_transfer_rule_with_http_info(account_id, envelope_transfer_rule_id, **kwargs) 13050 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)
13052 def update_envelope_transfer_rule_with_http_info(self, account_id, envelope_transfer_rule_id, **kwargs): 13053 """ 13054 Update an envelope transfer rule for an account. 13055 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. 13056 This method makes a synchronous HTTP request by default. To make an 13057 asynchronous HTTP request, please define a `callback` function 13058 to be invoked when receiving the response. 13059 >>> def callback_function(response): 13060 >>> pprint(response) 13061 >>> 13062 >>> thread = api.update_envelope_transfer_rule_with_http_info(account_id, envelope_transfer_rule_id, callback=callback_function) 13063 13064 :param callback function: The callback function 13065 for asynchronous request. (optional) 13066 :param str account_id: The external account number (int) or account ID Guid. (required) 13067 :param str envelope_transfer_rule_id: (required) 13068 :param EnvelopeTransferRule envelope_transfer_rule: 13069 :return: EnvelopeTransferRule 13070 If the method is called asynchronously, 13071 returns the request thread. 13072 """ 13073 13074 all_params = ['account_id', 'envelope_transfer_rule_id', 'envelope_transfer_rule'] 13075 all_params.append('callback') 13076 all_params.append('_return_http_data_only') 13077 all_params.append('_preload_content') 13078 all_params.append('_request_timeout') 13079 13080 params = locals() 13081 for key, val in iteritems(params['kwargs']): 13082 if key not in all_params: 13083 raise TypeError( 13084 "Got an unexpected keyword argument '%s'" 13085 " to method update_envelope_transfer_rule" % key 13086 ) 13087 params[key] = val 13088 del params['kwargs'] 13089 # verify the required parameter 'account_id' is set 13090 if ('account_id' not in params) or (params['account_id'] is None): 13091 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_transfer_rule`") 13092 # verify the required parameter 'envelope_transfer_rule_id' is set 13093 if ('envelope_transfer_rule_id' not in params) or (params['envelope_transfer_rule_id'] is None): 13094 raise ValueError("Missing the required parameter `envelope_transfer_rule_id` when calling `update_envelope_transfer_rule`") 13095 13096 13097 collection_formats = {} 13098 13099 resource_path = '/v2.1/accounts/{accountId}/envelopes/transfer_rules/{envelopeTransferRuleId}'.replace('{format}', 'json') 13100 path_params = {} 13101 if 'account_id' in params: 13102 path_params['accountId'] = params['account_id'] 13103 if 'envelope_transfer_rule_id' in params: 13104 path_params['envelopeTransferRuleId'] = params['envelope_transfer_rule_id'] 13105 13106 query_params = {} 13107 13108 header_params = {} 13109 13110 form_params = [] 13111 local_var_files = {} 13112 13113 body_params = None 13114 if 'envelope_transfer_rule' in params: 13115 body_params = params['envelope_transfer_rule'] 13116 # HTTP header `Accept` 13117 header_params['Accept'] = self.api_client.\ 13118 select_header_accept(['application/json']) 13119 13120 # Authentication setting 13121 auth_settings = [] 13122 13123 return self.api_client.call_api(resource_path, 'PUT', 13124 path_params, 13125 query_params, 13126 header_params, 13127 body=body_params, 13128 post_params=form_params, 13129 files=local_var_files, 13130 response_type='EnvelopeTransferRule', 13131 auth_settings=auth_settings, 13132 callback=params.get('callback'), 13133 _return_http_data_only=params.get('_return_http_data_only'), 13134 _preload_content=params.get('_preload_content', True), 13135 _request_timeout=params.get('_request_timeout'), 13136 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)
13138 def update_envelope_transfer_rules(self, account_id, **kwargs): 13139 """ 13140 Update envelope transfer rules for an account. 13141 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. 13142 This method makes a synchronous HTTP request by default. To make an 13143 asynchronous HTTP request, please define a `callback` function 13144 to be invoked when receiving the response. 13145 >>> def callback_function(response): 13146 >>> pprint(response) 13147 >>> 13148 >>> thread = api.update_envelope_transfer_rules(account_id, callback=callback_function) 13149 13150 :param callback function: The callback function 13151 for asynchronous request. (optional) 13152 :param str account_id: The external account number (int) or account ID Guid. (required) 13153 :param EnvelopeTransferRuleInformation envelope_transfer_rule_information: 13154 :return: EnvelopeTransferRuleInformation 13155 If the method is called asynchronously, 13156 returns the request thread. 13157 """ 13158 kwargs['_return_http_data_only'] = True 13159 if kwargs.get('callback'): 13160 return self.update_envelope_transfer_rules_with_http_info(account_id, **kwargs) 13161 else: 13162 (data) = self.update_envelope_transfer_rules_with_http_info(account_id, **kwargs) 13163 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)
13165 def update_envelope_transfer_rules_with_http_info(self, account_id, **kwargs): 13166 """ 13167 Update envelope transfer rules for an account. 13168 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. 13169 This method makes a synchronous HTTP request by default. To make an 13170 asynchronous HTTP request, please define a `callback` function 13171 to be invoked when receiving the response. 13172 >>> def callback_function(response): 13173 >>> pprint(response) 13174 >>> 13175 >>> thread = api.update_envelope_transfer_rules_with_http_info(account_id, callback=callback_function) 13176 13177 :param callback function: The callback function 13178 for asynchronous request. (optional) 13179 :param str account_id: The external account number (int) or account ID Guid. (required) 13180 :param EnvelopeTransferRuleInformation envelope_transfer_rule_information: 13181 :return: EnvelopeTransferRuleInformation 13182 If the method is called asynchronously, 13183 returns the request thread. 13184 """ 13185 13186 all_params = ['account_id', 'envelope_transfer_rule_information'] 13187 all_params.append('callback') 13188 all_params.append('_return_http_data_only') 13189 all_params.append('_preload_content') 13190 all_params.append('_request_timeout') 13191 13192 params = locals() 13193 for key, val in iteritems(params['kwargs']): 13194 if key not in all_params: 13195 raise TypeError( 13196 "Got an unexpected keyword argument '%s'" 13197 " to method update_envelope_transfer_rules" % key 13198 ) 13199 params[key] = val 13200 del params['kwargs'] 13201 # verify the required parameter 'account_id' is set 13202 if ('account_id' not in params) or (params['account_id'] is None): 13203 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_transfer_rules`") 13204 13205 13206 collection_formats = {} 13207 13208 resource_path = '/v2.1/accounts/{accountId}/envelopes/transfer_rules'.replace('{format}', 'json') 13209 path_params = {} 13210 if 'account_id' in params: 13211 path_params['accountId'] = params['account_id'] 13212 13213 query_params = {} 13214 13215 header_params = {} 13216 13217 form_params = [] 13218 local_var_files = {} 13219 13220 body_params = None 13221 if 'envelope_transfer_rule_information' in params: 13222 body_params = params['envelope_transfer_rule_information'] 13223 # HTTP header `Accept` 13224 header_params['Accept'] = self.api_client.\ 13225 select_header_accept(['application/json']) 13226 13227 # Authentication setting 13228 auth_settings = [] 13229 13230 return self.api_client.call_api(resource_path, 'PUT', 13231 path_params, 13232 query_params, 13233 header_params, 13234 body=body_params, 13235 post_params=form_params, 13236 files=local_var_files, 13237 response_type='EnvelopeTransferRuleInformation', 13238 auth_settings=auth_settings, 13239 callback=params.get('callback'), 13240 _return_http_data_only=params.get('_return_http_data_only'), 13241 _preload_content=params.get('_preload_content', True), 13242 _request_timeout=params.get('_request_timeout'), 13243 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)
13245 def update_envelope_workflow_definition(self, account_id, envelope_id, **kwargs): 13246 """ 13247 Updates the envelope workflow definition for an envelope. 13248 Updates the specified envelope's workflow definition if it has one. 13249 This method makes a synchronous HTTP request by default. To make an 13250 asynchronous HTTP request, please define a `callback` function 13251 to be invoked when receiving the response. 13252 >>> def callback_function(response): 13253 >>> pprint(response) 13254 >>> 13255 >>> thread = api.update_envelope_workflow_definition(account_id, envelope_id, callback=callback_function) 13256 13257 :param callback function: The callback function 13258 for asynchronous request. (optional) 13259 :param str account_id: The external account number (int) or account ID Guid. (required) 13260 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13261 :param Workflow workflow: 13262 :return: Workflow 13263 If the method is called asynchronously, 13264 returns the request thread. 13265 """ 13266 kwargs['_return_http_data_only'] = True 13267 if kwargs.get('callback'): 13268 return self.update_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 13269 else: 13270 (data) = self.update_envelope_workflow_definition_with_http_info(account_id, envelope_id, **kwargs) 13271 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)
13273 def update_envelope_workflow_definition_with_http_info(self, account_id, envelope_id, **kwargs): 13274 """ 13275 Updates the envelope workflow definition for an envelope. 13276 Updates the specified envelope's workflow definition if it has one. 13277 This method makes a synchronous HTTP request by default. To make an 13278 asynchronous HTTP request, please define a `callback` function 13279 to be invoked when receiving the response. 13280 >>> def callback_function(response): 13281 >>> pprint(response) 13282 >>> 13283 >>> thread = api.update_envelope_workflow_definition_with_http_info(account_id, envelope_id, callback=callback_function) 13284 13285 :param callback function: The callback function 13286 for asynchronous request. (optional) 13287 :param str account_id: The external account number (int) or account ID Guid. (required) 13288 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13289 :param Workflow workflow: 13290 :return: Workflow 13291 If the method is called asynchronously, 13292 returns the request thread. 13293 """ 13294 13295 all_params = ['account_id', 'envelope_id', 'workflow'] 13296 all_params.append('callback') 13297 all_params.append('_return_http_data_only') 13298 all_params.append('_preload_content') 13299 all_params.append('_request_timeout') 13300 13301 params = locals() 13302 for key, val in iteritems(params['kwargs']): 13303 if key not in all_params: 13304 raise TypeError( 13305 "Got an unexpected keyword argument '%s'" 13306 " to method update_envelope_workflow_definition" % key 13307 ) 13308 params[key] = val 13309 del params['kwargs'] 13310 # verify the required parameter 'account_id' is set 13311 if ('account_id' not in params) or (params['account_id'] is None): 13312 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_workflow_definition`") 13313 # verify the required parameter 'envelope_id' is set 13314 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13315 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_workflow_definition`") 13316 13317 13318 collection_formats = {} 13319 13320 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow'.replace('{format}', 'json') 13321 path_params = {} 13322 if 'account_id' in params: 13323 path_params['accountId'] = params['account_id'] 13324 if 'envelope_id' in params: 13325 path_params['envelopeId'] = params['envelope_id'] 13326 13327 query_params = {} 13328 13329 header_params = {} 13330 13331 form_params = [] 13332 local_var_files = {} 13333 13334 body_params = None 13335 if 'workflow' in params: 13336 body_params = params['workflow'] 13337 # HTTP header `Accept` 13338 header_params['Accept'] = self.api_client.\ 13339 select_header_accept(['application/json']) 13340 13341 # Authentication setting 13342 auth_settings = [] 13343 13344 return self.api_client.call_api(resource_path, 'PUT', 13345 path_params, 13346 query_params, 13347 header_params, 13348 body=body_params, 13349 post_params=form_params, 13350 files=local_var_files, 13351 response_type='Workflow', 13352 auth_settings=auth_settings, 13353 callback=params.get('callback'), 13354 _return_http_data_only=params.get('_return_http_data_only'), 13355 _preload_content=params.get('_preload_content', True), 13356 _request_timeout=params.get('_request_timeout'), 13357 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)
13359 def update_envelope_workflow_step_definition(self, account_id, envelope_id, workflow_step_id, **kwargs): 13360 """ 13361 Updates the envelope workflow step definition for an envelope. 13362 This method makes a synchronous HTTP request by default. To make an 13363 asynchronous HTTP request, please define a `callback` function 13364 to be invoked when receiving the response. 13365 >>> def callback_function(response): 13366 >>> pprint(response) 13367 >>> 13368 >>> thread = api.update_envelope_workflow_step_definition(account_id, envelope_id, workflow_step_id, callback=callback_function) 13369 13370 :param callback function: The callback function 13371 for asynchronous request. (optional) 13372 :param str account_id: The external account number (int) or account ID Guid. (required) 13373 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13374 :param str workflow_step_id: (required) 13375 :param WorkflowStep workflow_step: 13376 :return: WorkflowStep 13377 If the method is called asynchronously, 13378 returns the request thread. 13379 """ 13380 kwargs['_return_http_data_only'] = True 13381 if kwargs.get('callback'): 13382 return self.update_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 13383 else: 13384 (data) = self.update_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, **kwargs) 13385 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)
13387 def update_envelope_workflow_step_definition_with_http_info(self, account_id, envelope_id, workflow_step_id, **kwargs): 13388 """ 13389 Updates the envelope workflow step definition for an envelope. 13390 This method makes a synchronous HTTP request by default. To make an 13391 asynchronous HTTP request, please define a `callback` function 13392 to be invoked when receiving the response. 13393 >>> def callback_function(response): 13394 >>> pprint(response) 13395 >>> 13396 >>> thread = api.update_envelope_workflow_step_definition_with_http_info(account_id, envelope_id, workflow_step_id, callback=callback_function) 13397 13398 :param callback function: The callback function 13399 for asynchronous request. (optional) 13400 :param str account_id: The external account number (int) or account ID Guid. (required) 13401 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13402 :param str workflow_step_id: (required) 13403 :param WorkflowStep workflow_step: 13404 :return: WorkflowStep 13405 If the method is called asynchronously, 13406 returns the request thread. 13407 """ 13408 13409 all_params = ['account_id', 'envelope_id', 'workflow_step_id', 'workflow_step'] 13410 all_params.append('callback') 13411 all_params.append('_return_http_data_only') 13412 all_params.append('_preload_content') 13413 all_params.append('_request_timeout') 13414 13415 params = locals() 13416 for key, val in iteritems(params['kwargs']): 13417 if key not in all_params: 13418 raise TypeError( 13419 "Got an unexpected keyword argument '%s'" 13420 " to method update_envelope_workflow_step_definition" % key 13421 ) 13422 params[key] = val 13423 del params['kwargs'] 13424 # verify the required parameter 'account_id' is set 13425 if ('account_id' not in params) or (params['account_id'] is None): 13426 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_workflow_step_definition`") 13427 # verify the required parameter 'envelope_id' is set 13428 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13429 raise ValueError("Missing the required parameter `envelope_id` when calling `update_envelope_workflow_step_definition`") 13430 # verify the required parameter 'workflow_step_id' is set 13431 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 13432 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_envelope_workflow_step_definition`") 13433 13434 13435 collection_formats = {} 13436 13437 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 13438 path_params = {} 13439 if 'account_id' in params: 13440 path_params['accountId'] = params['account_id'] 13441 if 'envelope_id' in params: 13442 path_params['envelopeId'] = params['envelope_id'] 13443 if 'workflow_step_id' in params: 13444 path_params['workflowStepId'] = params['workflow_step_id'] 13445 13446 query_params = {} 13447 13448 header_params = {} 13449 13450 form_params = [] 13451 local_var_files = {} 13452 13453 body_params = None 13454 if 'workflow_step' in params: 13455 body_params = params['workflow_step'] 13456 # HTTP header `Accept` 13457 header_params['Accept'] = self.api_client.\ 13458 select_header_accept(['application/json']) 13459 13460 # Authentication setting 13461 auth_settings = [] 13462 13463 return self.api_client.call_api(resource_path, 'PUT', 13464 path_params, 13465 query_params, 13466 header_params, 13467 body=body_params, 13468 post_params=form_params, 13469 files=local_var_files, 13470 response_type='WorkflowStep', 13471 auth_settings=auth_settings, 13472 callback=params.get('callback'), 13473 _return_http_data_only=params.get('_return_http_data_only'), 13474 _preload_content=params.get('_preload_content', True), 13475 _request_timeout=params.get('_request_timeout'), 13476 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)
13478 def update_lock(self, account_id, envelope_id, **kwargs): 13479 """ 13480 Updates an envelope lock. 13481 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. 13482 This method makes a synchronous HTTP request by default. To make an 13483 asynchronous HTTP request, please define a `callback` function 13484 to be invoked when receiving the response. 13485 >>> def callback_function(response): 13486 >>> pprint(response) 13487 >>> 13488 >>> thread = api.update_lock(account_id, envelope_id, callback=callback_function) 13489 13490 :param callback function: The callback function 13491 for asynchronous request. (optional) 13492 :param str account_id: The external account number (int) or account ID Guid. (required) 13493 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13494 :param LockRequest lock_request: 13495 :return: LockInformation 13496 If the method is called asynchronously, 13497 returns the request thread. 13498 """ 13499 kwargs['_return_http_data_only'] = True 13500 if kwargs.get('callback'): 13501 return self.update_lock_with_http_info(account_id, envelope_id, **kwargs) 13502 else: 13503 (data) = self.update_lock_with_http_info(account_id, envelope_id, **kwargs) 13504 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)
13506 def update_lock_with_http_info(self, account_id, envelope_id, **kwargs): 13507 """ 13508 Updates an envelope lock. 13509 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. 13510 This method makes a synchronous HTTP request by default. To make an 13511 asynchronous HTTP request, please define a `callback` function 13512 to be invoked when receiving the response. 13513 >>> def callback_function(response): 13514 >>> pprint(response) 13515 >>> 13516 >>> thread = api.update_lock_with_http_info(account_id, envelope_id, callback=callback_function) 13517 13518 :param callback function: The callback function 13519 for asynchronous request. (optional) 13520 :param str account_id: The external account number (int) or account ID Guid. (required) 13521 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13522 :param LockRequest lock_request: 13523 :return: LockInformation 13524 If the method is called asynchronously, 13525 returns the request thread. 13526 """ 13527 13528 all_params = ['account_id', 'envelope_id', 'lock_request'] 13529 all_params.append('callback') 13530 all_params.append('_return_http_data_only') 13531 all_params.append('_preload_content') 13532 all_params.append('_request_timeout') 13533 13534 params = locals() 13535 for key, val in iteritems(params['kwargs']): 13536 if key not in all_params: 13537 raise TypeError( 13538 "Got an unexpected keyword argument '%s'" 13539 " to method update_lock" % key 13540 ) 13541 params[key] = val 13542 del params['kwargs'] 13543 # verify the required parameter 'account_id' is set 13544 if ('account_id' not in params) or (params['account_id'] is None): 13545 raise ValueError("Missing the required parameter `account_id` when calling `update_lock`") 13546 # verify the required parameter 'envelope_id' is set 13547 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13548 raise ValueError("Missing the required parameter `envelope_id` when calling `update_lock`") 13549 13550 13551 collection_formats = {} 13552 13553 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/lock'.replace('{format}', 'json') 13554 path_params = {} 13555 if 'account_id' in params: 13556 path_params['accountId'] = params['account_id'] 13557 if 'envelope_id' in params: 13558 path_params['envelopeId'] = params['envelope_id'] 13559 13560 query_params = {} 13561 13562 header_params = {} 13563 13564 form_params = [] 13565 local_var_files = {} 13566 13567 body_params = None 13568 if 'lock_request' in params: 13569 body_params = params['lock_request'] 13570 # HTTP header `Accept` 13571 header_params['Accept'] = self.api_client.\ 13572 select_header_accept(['application/json']) 13573 13574 # Authentication setting 13575 auth_settings = [] 13576 13577 return self.api_client.call_api(resource_path, 'PUT', 13578 path_params, 13579 query_params, 13580 header_params, 13581 body=body_params, 13582 post_params=form_params, 13583 files=local_var_files, 13584 response_type='LockInformation', 13585 auth_settings=auth_settings, 13586 callback=params.get('callback'), 13587 _return_http_data_only=params.get('_return_http_data_only'), 13588 _preload_content=params.get('_preload_content', True), 13589 _request_timeout=params.get('_request_timeout'), 13590 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)
13592 def update_notification_settings(self, account_id, envelope_id, **kwargs): 13593 """ 13594 Sets envelope notification (Reminders/Expirations) structure for an existing envelope. 13595 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. 13596 This method makes a synchronous HTTP request by default. To make an 13597 asynchronous HTTP request, please define a `callback` function 13598 to be invoked when receiving the response. 13599 >>> def callback_function(response): 13600 >>> pprint(response) 13601 >>> 13602 >>> thread = api.update_notification_settings(account_id, envelope_id, callback=callback_function) 13603 13604 :param callback function: The callback function 13605 for asynchronous request. (optional) 13606 :param str account_id: The external account number (int) or account ID Guid. (required) 13607 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13608 :param EnvelopeNotificationRequest envelope_notification_request: 13609 :return: Notification 13610 If the method is called asynchronously, 13611 returns the request thread. 13612 """ 13613 kwargs['_return_http_data_only'] = True 13614 if kwargs.get('callback'): 13615 return self.update_notification_settings_with_http_info(account_id, envelope_id, **kwargs) 13616 else: 13617 (data) = self.update_notification_settings_with_http_info(account_id, envelope_id, **kwargs) 13618 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)
13620 def update_notification_settings_with_http_info(self, account_id, envelope_id, **kwargs): 13621 """ 13622 Sets envelope notification (Reminders/Expirations) structure for an existing envelope. 13623 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. 13624 This method makes a synchronous HTTP request by default. To make an 13625 asynchronous HTTP request, please define a `callback` function 13626 to be invoked when receiving the response. 13627 >>> def callback_function(response): 13628 >>> pprint(response) 13629 >>> 13630 >>> thread = api.update_notification_settings_with_http_info(account_id, envelope_id, callback=callback_function) 13631 13632 :param callback function: The callback function 13633 for asynchronous request. (optional) 13634 :param str account_id: The external account number (int) or account ID Guid. (required) 13635 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13636 :param EnvelopeNotificationRequest envelope_notification_request: 13637 :return: Notification 13638 If the method is called asynchronously, 13639 returns the request thread. 13640 """ 13641 13642 all_params = ['account_id', 'envelope_id', 'envelope_notification_request'] 13643 all_params.append('callback') 13644 all_params.append('_return_http_data_only') 13645 all_params.append('_preload_content') 13646 all_params.append('_request_timeout') 13647 13648 params = locals() 13649 for key, val in iteritems(params['kwargs']): 13650 if key not in all_params: 13651 raise TypeError( 13652 "Got an unexpected keyword argument '%s'" 13653 " to method update_notification_settings" % key 13654 ) 13655 params[key] = val 13656 del params['kwargs'] 13657 # verify the required parameter 'account_id' is set 13658 if ('account_id' not in params) or (params['account_id'] is None): 13659 raise ValueError("Missing the required parameter `account_id` when calling `update_notification_settings`") 13660 # verify the required parameter 'envelope_id' is set 13661 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13662 raise ValueError("Missing the required parameter `envelope_id` when calling `update_notification_settings`") 13663 13664 13665 collection_formats = {} 13666 13667 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/notification'.replace('{format}', 'json') 13668 path_params = {} 13669 if 'account_id' in params: 13670 path_params['accountId'] = params['account_id'] 13671 if 'envelope_id' in params: 13672 path_params['envelopeId'] = params['envelope_id'] 13673 13674 query_params = {} 13675 13676 header_params = {} 13677 13678 form_params = [] 13679 local_var_files = {} 13680 13681 body_params = None 13682 if 'envelope_notification_request' in params: 13683 body_params = params['envelope_notification_request'] 13684 # HTTP header `Accept` 13685 header_params['Accept'] = self.api_client.\ 13686 select_header_accept(['application/json']) 13687 13688 # Authentication setting 13689 auth_settings = [] 13690 13691 return self.api_client.call_api(resource_path, 'PUT', 13692 path_params, 13693 query_params, 13694 header_params, 13695 body=body_params, 13696 post_params=form_params, 13697 files=local_var_files, 13698 response_type='Notification', 13699 auth_settings=auth_settings, 13700 callback=params.get('callback'), 13701 _return_http_data_only=params.get('_return_http_data_only'), 13702 _preload_content=params.get('_preload_content', True), 13703 _request_timeout=params.get('_request_timeout'), 13704 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)
13706 def update_recipient_document_visibility(self, account_id, envelope_id, recipient_id, **kwargs): 13707 """ 13708 Updates document visibility for the recipients 13709 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. 13710 This method makes a synchronous HTTP request by default. To make an 13711 asynchronous HTTP request, please define a `callback` function 13712 to be invoked when receiving the response. 13713 >>> def callback_function(response): 13714 >>> pprint(response) 13715 >>> 13716 >>> thread = api.update_recipient_document_visibility(account_id, envelope_id, recipient_id, callback=callback_function) 13717 13718 :param callback function: The callback function 13719 for asynchronous request. (optional) 13720 :param str account_id: The external account number (int) or account ID Guid. (required) 13721 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13722 :param str recipient_id: The ID of the recipient being accessed. (required) 13723 :param DocumentVisibilityList document_visibility_list: 13724 :return: DocumentVisibilityList 13725 If the method is called asynchronously, 13726 returns the request thread. 13727 """ 13728 kwargs['_return_http_data_only'] = True 13729 if kwargs.get('callback'): 13730 return self.update_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13731 else: 13732 (data) = self.update_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13733 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)
13735 def update_recipient_document_visibility_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 13736 """ 13737 Updates document visibility for the recipients 13738 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. 13739 This method makes a synchronous HTTP request by default. To make an 13740 asynchronous HTTP request, please define a `callback` function 13741 to be invoked when receiving the response. 13742 >>> def callback_function(response): 13743 >>> pprint(response) 13744 >>> 13745 >>> thread = api.update_recipient_document_visibility_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 13746 13747 :param callback function: The callback function 13748 for asynchronous request. (optional) 13749 :param str account_id: The external account number (int) or account ID Guid. (required) 13750 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13751 :param str recipient_id: The ID of the recipient being accessed. (required) 13752 :param DocumentVisibilityList document_visibility_list: 13753 :return: DocumentVisibilityList 13754 If the method is called asynchronously, 13755 returns the request thread. 13756 """ 13757 13758 all_params = ['account_id', 'envelope_id', 'recipient_id', 'document_visibility_list'] 13759 all_params.append('callback') 13760 all_params.append('_return_http_data_only') 13761 all_params.append('_preload_content') 13762 all_params.append('_request_timeout') 13763 13764 params = locals() 13765 for key, val in iteritems(params['kwargs']): 13766 if key not in all_params: 13767 raise TypeError( 13768 "Got an unexpected keyword argument '%s'" 13769 " to method update_recipient_document_visibility" % key 13770 ) 13771 params[key] = val 13772 del params['kwargs'] 13773 # verify the required parameter 'account_id' is set 13774 if ('account_id' not in params) or (params['account_id'] is None): 13775 raise ValueError("Missing the required parameter `account_id` when calling `update_recipient_document_visibility`") 13776 # verify the required parameter 'envelope_id' is set 13777 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13778 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipient_document_visibility`") 13779 # verify the required parameter 'recipient_id' is set 13780 if ('recipient_id' not in params) or (params['recipient_id'] is None): 13781 raise ValueError("Missing the required parameter `recipient_id` when calling `update_recipient_document_visibility`") 13782 13783 13784 collection_formats = {} 13785 13786 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/document_visibility'.replace('{format}', 'json') 13787 path_params = {} 13788 if 'account_id' in params: 13789 path_params['accountId'] = params['account_id'] 13790 if 'envelope_id' in params: 13791 path_params['envelopeId'] = params['envelope_id'] 13792 if 'recipient_id' in params: 13793 path_params['recipientId'] = params['recipient_id'] 13794 13795 query_params = {} 13796 13797 header_params = {} 13798 13799 form_params = [] 13800 local_var_files = {} 13801 13802 body_params = None 13803 if 'document_visibility_list' in params: 13804 body_params = params['document_visibility_list'] 13805 # HTTP header `Accept` 13806 header_params['Accept'] = self.api_client.\ 13807 select_header_accept(['application/json']) 13808 13809 # Authentication setting 13810 auth_settings = [] 13811 13812 return self.api_client.call_api(resource_path, 'PUT', 13813 path_params, 13814 query_params, 13815 header_params, 13816 body=body_params, 13817 post_params=form_params, 13818 files=local_var_files, 13819 response_type='DocumentVisibilityList', 13820 auth_settings=auth_settings, 13821 callback=params.get('callback'), 13822 _return_http_data_only=params.get('_return_http_data_only'), 13823 _preload_content=params.get('_preload_content', True), 13824 _request_timeout=params.get('_request_timeout'), 13825 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)
13827 def update_recipient_initials_image(self, account_id, envelope_id, recipient_id, **kwargs): 13828 """ 13829 Sets the initials image for an accountless signer. 13830 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**. 13831 This method makes a synchronous HTTP request by default. To make an 13832 asynchronous HTTP request, please define a `callback` function 13833 to be invoked when receiving the response. 13834 >>> def callback_function(response): 13835 >>> pprint(response) 13836 >>> 13837 >>> thread = api.update_recipient_initials_image(account_id, envelope_id, recipient_id, callback=callback_function) 13838 13839 :param callback function: The callback function 13840 for asynchronous request. (optional) 13841 :param str account_id: The external account number (int) or account ID Guid. (required) 13842 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13843 :param str recipient_id: The ID of the recipient being accessed. (required) 13844 :return: None 13845 If the method is called asynchronously, 13846 returns the request thread. 13847 """ 13848 kwargs['_return_http_data_only'] = True 13849 if kwargs.get('callback'): 13850 return self.update_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13851 else: 13852 (data) = self.update_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13853 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)
13855 def update_recipient_initials_image_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 13856 """ 13857 Sets the initials image for an accountless signer. 13858 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**. 13859 This method makes a synchronous HTTP request by default. To make an 13860 asynchronous HTTP request, please define a `callback` function 13861 to be invoked when receiving the response. 13862 >>> def callback_function(response): 13863 >>> pprint(response) 13864 >>> 13865 >>> thread = api.update_recipient_initials_image_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 13866 13867 :param callback function: The callback function 13868 for asynchronous request. (optional) 13869 :param str account_id: The external account number (int) or account ID Guid. (required) 13870 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13871 :param str recipient_id: The ID of the recipient being accessed. (required) 13872 :return: None 13873 If the method is called asynchronously, 13874 returns the request thread. 13875 """ 13876 13877 all_params = ['account_id', 'envelope_id', 'recipient_id'] 13878 all_params.append('callback') 13879 all_params.append('_return_http_data_only') 13880 all_params.append('_preload_content') 13881 all_params.append('_request_timeout') 13882 13883 params = locals() 13884 for key, val in iteritems(params['kwargs']): 13885 if key not in all_params: 13886 raise TypeError( 13887 "Got an unexpected keyword argument '%s'" 13888 " to method update_recipient_initials_image" % key 13889 ) 13890 params[key] = val 13891 del params['kwargs'] 13892 # verify the required parameter 'account_id' is set 13893 if ('account_id' not in params) or (params['account_id'] is None): 13894 raise ValueError("Missing the required parameter `account_id` when calling `update_recipient_initials_image`") 13895 # verify the required parameter 'envelope_id' is set 13896 if ('envelope_id' not in params) or (params['envelope_id'] is None): 13897 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipient_initials_image`") 13898 # verify the required parameter 'recipient_id' is set 13899 if ('recipient_id' not in params) or (params['recipient_id'] is None): 13900 raise ValueError("Missing the required parameter `recipient_id` when calling `update_recipient_initials_image`") 13901 13902 13903 collection_formats = {} 13904 13905 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/initials_image'.replace('{format}', 'json') 13906 path_params = {} 13907 if 'account_id' in params: 13908 path_params['accountId'] = params['account_id'] 13909 if 'envelope_id' in params: 13910 path_params['envelopeId'] = params['envelope_id'] 13911 if 'recipient_id' in params: 13912 path_params['recipientId'] = params['recipient_id'] 13913 13914 query_params = {} 13915 13916 header_params = {} 13917 13918 form_params = [] 13919 local_var_files = {} 13920 13921 body_params = None 13922 # HTTP header `Accept` 13923 header_params['Accept'] = self.api_client.\ 13924 select_header_accept(['application/json']) 13925 13926 # HTTP header `Content-Type` 13927 header_params['Content-Type'] = self.api_client.\ 13928 select_header_content_type(['image/gif']) 13929 13930 # Authentication setting 13931 auth_settings = [] 13932 13933 return self.api_client.call_api(resource_path, 'PUT', 13934 path_params, 13935 query_params, 13936 header_params, 13937 body=body_params, 13938 post_params=form_params, 13939 files=local_var_files, 13940 response_type=None, 13941 auth_settings=auth_settings, 13942 callback=params.get('callback'), 13943 _return_http_data_only=params.get('_return_http_data_only'), 13944 _preload_content=params.get('_preload_content', True), 13945 _request_timeout=params.get('_request_timeout'), 13946 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)
13948 def update_recipient_signature_image(self, account_id, envelope_id, recipient_id, **kwargs): 13949 """ 13950 Sets the signature image for an accountless signer. 13951 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**. 13952 This method makes a synchronous HTTP request by default. To make an 13953 asynchronous HTTP request, please define a `callback` function 13954 to be invoked when receiving the response. 13955 >>> def callback_function(response): 13956 >>> pprint(response) 13957 >>> 13958 >>> thread = api.update_recipient_signature_image(account_id, envelope_id, recipient_id, callback=callback_function) 13959 13960 :param callback function: The callback function 13961 for asynchronous request. (optional) 13962 :param str account_id: The external account number (int) or account ID Guid. (required) 13963 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13964 :param str recipient_id: The ID of the recipient being accessed. (required) 13965 :return: None 13966 If the method is called asynchronously, 13967 returns the request thread. 13968 """ 13969 kwargs['_return_http_data_only'] = True 13970 if kwargs.get('callback'): 13971 return self.update_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13972 else: 13973 (data) = self.update_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 13974 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)
13976 def update_recipient_signature_image_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 13977 """ 13978 Sets the signature image for an accountless signer. 13979 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**. 13980 This method makes a synchronous HTTP request by default. To make an 13981 asynchronous HTTP request, please define a `callback` function 13982 to be invoked when receiving the response. 13983 >>> def callback_function(response): 13984 >>> pprint(response) 13985 >>> 13986 >>> thread = api.update_recipient_signature_image_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 13987 13988 :param callback function: The callback function 13989 for asynchronous request. (optional) 13990 :param str account_id: The external account number (int) or account ID Guid. (required) 13991 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 13992 :param str recipient_id: The ID of the recipient being accessed. (required) 13993 :return: None 13994 If the method is called asynchronously, 13995 returns the request thread. 13996 """ 13997 13998 all_params = ['account_id', 'envelope_id', 'recipient_id'] 13999 all_params.append('callback') 14000 all_params.append('_return_http_data_only') 14001 all_params.append('_preload_content') 14002 all_params.append('_request_timeout') 14003 14004 params = locals() 14005 for key, val in iteritems(params['kwargs']): 14006 if key not in all_params: 14007 raise TypeError( 14008 "Got an unexpected keyword argument '%s'" 14009 " to method update_recipient_signature_image" % key 14010 ) 14011 params[key] = val 14012 del params['kwargs'] 14013 # verify the required parameter 'account_id' is set 14014 if ('account_id' not in params) or (params['account_id'] is None): 14015 raise ValueError("Missing the required parameter `account_id` when calling `update_recipient_signature_image`") 14016 # verify the required parameter 'envelope_id' is set 14017 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14018 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipient_signature_image`") 14019 # verify the required parameter 'recipient_id' is set 14020 if ('recipient_id' not in params) or (params['recipient_id'] is None): 14021 raise ValueError("Missing the required parameter `recipient_id` when calling `update_recipient_signature_image`") 14022 14023 14024 collection_formats = {} 14025 14026 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/signature_image'.replace('{format}', 'json') 14027 path_params = {} 14028 if 'account_id' in params: 14029 path_params['accountId'] = params['account_id'] 14030 if 'envelope_id' in params: 14031 path_params['envelopeId'] = params['envelope_id'] 14032 if 'recipient_id' in params: 14033 path_params['recipientId'] = params['recipient_id'] 14034 14035 query_params = {} 14036 14037 header_params = {} 14038 14039 form_params = [] 14040 local_var_files = {} 14041 14042 body_params = None 14043 # HTTP header `Accept` 14044 header_params['Accept'] = self.api_client.\ 14045 select_header_accept(['application/json']) 14046 14047 # HTTP header `Content-Type` 14048 header_params['Content-Type'] = self.api_client.\ 14049 select_header_content_type(['image/gif']) 14050 14051 # Authentication setting 14052 auth_settings = [] 14053 14054 return self.api_client.call_api(resource_path, 'PUT', 14055 path_params, 14056 query_params, 14057 header_params, 14058 body=body_params, 14059 post_params=form_params, 14060 files=local_var_files, 14061 response_type=None, 14062 auth_settings=auth_settings, 14063 callback=params.get('callback'), 14064 _return_http_data_only=params.get('_return_http_data_only'), 14065 _preload_content=params.get('_preload_content', True), 14066 _request_timeout=params.get('_request_timeout'), 14067 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)
14069 def update_recipients(self, account_id, envelope_id, **kwargs): 14070 """ 14071 Updates recipients in a draft envelope or corrects recipient information for an in process envelope. 14072 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). 14073 This method makes a synchronous HTTP request by default. To make an 14074 asynchronous HTTP request, please define a `callback` function 14075 to be invoked when receiving the response. 14076 >>> def callback_function(response): 14077 >>> pprint(response) 14078 >>> 14079 >>> thread = api.update_recipients(account_id, envelope_id, callback=callback_function) 14080 14081 :param callback function: The callback function 14082 for asynchronous request. (optional) 14083 :param str account_id: The external account number (int) or account ID Guid. (required) 14084 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14085 :param str combine_same_order_recipients: 14086 :param str offline_signing: 14087 :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. 14088 :param Recipients recipients: 14089 :return: RecipientsUpdateSummary 14090 If the method is called asynchronously, 14091 returns the request thread. 14092 """ 14093 kwargs['_return_http_data_only'] = True 14094 if kwargs.get('callback'): 14095 return self.update_recipients_with_http_info(account_id, envelope_id, **kwargs) 14096 else: 14097 (data) = self.update_recipients_with_http_info(account_id, envelope_id, **kwargs) 14098 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)
14100 def update_recipients_with_http_info(self, account_id, envelope_id, **kwargs): 14101 """ 14102 Updates recipients in a draft envelope or corrects recipient information for an in process envelope. 14103 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). 14104 This method makes a synchronous HTTP request by default. To make an 14105 asynchronous HTTP request, please define a `callback` function 14106 to be invoked when receiving the response. 14107 >>> def callback_function(response): 14108 >>> pprint(response) 14109 >>> 14110 >>> thread = api.update_recipients_with_http_info(account_id, envelope_id, callback=callback_function) 14111 14112 :param callback function: The callback function 14113 for asynchronous request. (optional) 14114 :param str account_id: The external account number (int) or account ID Guid. (required) 14115 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14116 :param str combine_same_order_recipients: 14117 :param str offline_signing: 14118 :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. 14119 :param Recipients recipients: 14120 :return: RecipientsUpdateSummary 14121 If the method is called asynchronously, 14122 returns the request thread. 14123 """ 14124 14125 all_params = ['account_id', 'envelope_id', 'combine_same_order_recipients', 'offline_signing', 'resend_envelope', 'recipients'] 14126 all_params.append('callback') 14127 all_params.append('_return_http_data_only') 14128 all_params.append('_preload_content') 14129 all_params.append('_request_timeout') 14130 14131 params = locals() 14132 for key, val in iteritems(params['kwargs']): 14133 if key not in all_params: 14134 raise TypeError( 14135 "Got an unexpected keyword argument '%s'" 14136 " to method update_recipients" % key 14137 ) 14138 params[key] = val 14139 del params['kwargs'] 14140 # verify the required parameter 'account_id' is set 14141 if ('account_id' not in params) or (params['account_id'] is None): 14142 raise ValueError("Missing the required parameter `account_id` when calling `update_recipients`") 14143 # verify the required parameter 'envelope_id' is set 14144 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14145 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipients`") 14146 14147 14148 collection_formats = {} 14149 14150 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients'.replace('{format}', 'json') 14151 path_params = {} 14152 if 'account_id' in params: 14153 path_params['accountId'] = params['account_id'] 14154 if 'envelope_id' in params: 14155 path_params['envelopeId'] = params['envelope_id'] 14156 14157 query_params = {} 14158 if 'combine_same_order_recipients' in params: 14159 query_params['combine_same_order_recipients'] = params['combine_same_order_recipients'] 14160 if 'offline_signing' in params: 14161 query_params['offline_signing'] = params['offline_signing'] 14162 if 'resend_envelope' in params: 14163 query_params['resend_envelope'] = params['resend_envelope'] 14164 14165 header_params = {} 14166 14167 form_params = [] 14168 local_var_files = {} 14169 14170 body_params = None 14171 if 'recipients' in params: 14172 body_params = params['recipients'] 14173 # HTTP header `Accept` 14174 header_params['Accept'] = self.api_client.\ 14175 select_header_accept(['application/json']) 14176 14177 # Authentication setting 14178 auth_settings = [] 14179 14180 return self.api_client.call_api(resource_path, 'PUT', 14181 path_params, 14182 query_params, 14183 header_params, 14184 body=body_params, 14185 post_params=form_params, 14186 files=local_var_files, 14187 response_type='RecipientsUpdateSummary', 14188 auth_settings=auth_settings, 14189 callback=params.get('callback'), 14190 _return_http_data_only=params.get('_return_http_data_only'), 14191 _preload_content=params.get('_preload_content', True), 14192 _request_timeout=params.get('_request_timeout'), 14193 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)
14195 def update_recipients_document_visibility(self, account_id, envelope_id, **kwargs): 14196 """ 14197 Updates document visibility for the recipients 14198 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. 14199 This method makes a synchronous HTTP request by default. To make an 14200 asynchronous HTTP request, please define a `callback` function 14201 to be invoked when receiving the response. 14202 >>> def callback_function(response): 14203 >>> pprint(response) 14204 >>> 14205 >>> thread = api.update_recipients_document_visibility(account_id, envelope_id, callback=callback_function) 14206 14207 :param callback function: The callback function 14208 for asynchronous request. (optional) 14209 :param str account_id: The external account number (int) or account ID Guid. (required) 14210 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14211 :param DocumentVisibilityList document_visibility_list: 14212 :return: DocumentVisibilityList 14213 If the method is called asynchronously, 14214 returns the request thread. 14215 """ 14216 kwargs['_return_http_data_only'] = True 14217 if kwargs.get('callback'): 14218 return self.update_recipients_document_visibility_with_http_info(account_id, envelope_id, **kwargs) 14219 else: 14220 (data) = self.update_recipients_document_visibility_with_http_info(account_id, envelope_id, **kwargs) 14221 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)
14223 def update_recipients_document_visibility_with_http_info(self, account_id, envelope_id, **kwargs): 14224 """ 14225 Updates document visibility for the recipients 14226 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. 14227 This method makes a synchronous HTTP request by default. To make an 14228 asynchronous HTTP request, please define a `callback` function 14229 to be invoked when receiving the response. 14230 >>> def callback_function(response): 14231 >>> pprint(response) 14232 >>> 14233 >>> thread = api.update_recipients_document_visibility_with_http_info(account_id, envelope_id, callback=callback_function) 14234 14235 :param callback function: The callback function 14236 for asynchronous request. (optional) 14237 :param str account_id: The external account number (int) or account ID Guid. (required) 14238 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14239 :param DocumentVisibilityList document_visibility_list: 14240 :return: DocumentVisibilityList 14241 If the method is called asynchronously, 14242 returns the request thread. 14243 """ 14244 14245 all_params = ['account_id', 'envelope_id', 'document_visibility_list'] 14246 all_params.append('callback') 14247 all_params.append('_return_http_data_only') 14248 all_params.append('_preload_content') 14249 all_params.append('_request_timeout') 14250 14251 params = locals() 14252 for key, val in iteritems(params['kwargs']): 14253 if key not in all_params: 14254 raise TypeError( 14255 "Got an unexpected keyword argument '%s'" 14256 " to method update_recipients_document_visibility" % key 14257 ) 14258 params[key] = val 14259 del params['kwargs'] 14260 # verify the required parameter 'account_id' is set 14261 if ('account_id' not in params) or (params['account_id'] is None): 14262 raise ValueError("Missing the required parameter `account_id` when calling `update_recipients_document_visibility`") 14263 # verify the required parameter 'envelope_id' is set 14264 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14265 raise ValueError("Missing the required parameter `envelope_id` when calling `update_recipients_document_visibility`") 14266 14267 14268 collection_formats = {} 14269 14270 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/document_visibility'.replace('{format}', 'json') 14271 path_params = {} 14272 if 'account_id' in params: 14273 path_params['accountId'] = params['account_id'] 14274 if 'envelope_id' in params: 14275 path_params['envelopeId'] = params['envelope_id'] 14276 14277 query_params = {} 14278 14279 header_params = {} 14280 14281 form_params = [] 14282 local_var_files = {} 14283 14284 body_params = None 14285 if 'document_visibility_list' in params: 14286 body_params = params['document_visibility_list'] 14287 # HTTP header `Accept` 14288 header_params['Accept'] = self.api_client.\ 14289 select_header_accept(['application/json']) 14290 14291 # Authentication setting 14292 auth_settings = [] 14293 14294 return self.api_client.call_api(resource_path, 'PUT', 14295 path_params, 14296 query_params, 14297 header_params, 14298 body=body_params, 14299 post_params=form_params, 14300 files=local_var_files, 14301 response_type='DocumentVisibilityList', 14302 auth_settings=auth_settings, 14303 callback=params.get('callback'), 14304 _return_http_data_only=params.get('_return_http_data_only'), 14305 _preload_content=params.get('_preload_content', True), 14306 _request_timeout=params.get('_request_timeout'), 14307 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)
14309 def update_tabs(self, account_id, envelope_id, recipient_id, **kwargs): 14310 """ 14311 Updates the tabs for a recipient. 14312 Updates one or more tabs for a recipient in a draft envelope. 14313 This method makes a synchronous HTTP request by default. To make an 14314 asynchronous HTTP request, please define a `callback` function 14315 to be invoked when receiving the response. 14316 >>> def callback_function(response): 14317 >>> pprint(response) 14318 >>> 14319 >>> thread = api.update_tabs(account_id, envelope_id, recipient_id, callback=callback_function) 14320 14321 :param callback function: The callback function 14322 for asynchronous request. (optional) 14323 :param str account_id: The external account number (int) or account ID Guid. (required) 14324 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14325 :param str recipient_id: The ID of the recipient being accessed. (required) 14326 :param Tabs tabs: 14327 :return: Tabs 14328 If the method is called asynchronously, 14329 returns the request thread. 14330 """ 14331 kwargs['_return_http_data_only'] = True 14332 if kwargs.get('callback'): 14333 return self.update_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 14334 else: 14335 (data) = self.update_tabs_with_http_info(account_id, envelope_id, recipient_id, **kwargs) 14336 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)
14338 def update_tabs_with_http_info(self, account_id, envelope_id, recipient_id, **kwargs): 14339 """ 14340 Updates the tabs for a recipient. 14341 Updates one or more tabs for a recipient in a draft envelope. 14342 This method makes a synchronous HTTP request by default. To make an 14343 asynchronous HTTP request, please define a `callback` function 14344 to be invoked when receiving the response. 14345 >>> def callback_function(response): 14346 >>> pprint(response) 14347 >>> 14348 >>> thread = api.update_tabs_with_http_info(account_id, envelope_id, recipient_id, callback=callback_function) 14349 14350 :param callback function: The callback function 14351 for asynchronous request. (optional) 14352 :param str account_id: The external account number (int) or account ID Guid. (required) 14353 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14354 :param str recipient_id: The ID of the recipient being accessed. (required) 14355 :param Tabs tabs: 14356 :return: Tabs 14357 If the method is called asynchronously, 14358 returns the request thread. 14359 """ 14360 14361 all_params = ['account_id', 'envelope_id', 'recipient_id', 'tabs'] 14362 all_params.append('callback') 14363 all_params.append('_return_http_data_only') 14364 all_params.append('_preload_content') 14365 all_params.append('_request_timeout') 14366 14367 params = locals() 14368 for key, val in iteritems(params['kwargs']): 14369 if key not in all_params: 14370 raise TypeError( 14371 "Got an unexpected keyword argument '%s'" 14372 " to method update_tabs" % key 14373 ) 14374 params[key] = val 14375 del params['kwargs'] 14376 # verify the required parameter 'account_id' is set 14377 if ('account_id' not in params) or (params['account_id'] is None): 14378 raise ValueError("Missing the required parameter `account_id` when calling `update_tabs`") 14379 # verify the required parameter 'envelope_id' is set 14380 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14381 raise ValueError("Missing the required parameter `envelope_id` when calling `update_tabs`") 14382 # verify the required parameter 'recipient_id' is set 14383 if ('recipient_id' not in params) or (params['recipient_id'] is None): 14384 raise ValueError("Missing the required parameter `recipient_id` when calling `update_tabs`") 14385 14386 14387 collection_formats = {} 14388 14389 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/tabs'.replace('{format}', 'json') 14390 path_params = {} 14391 if 'account_id' in params: 14392 path_params['accountId'] = params['account_id'] 14393 if 'envelope_id' in params: 14394 path_params['envelopeId'] = params['envelope_id'] 14395 if 'recipient_id' in params: 14396 path_params['recipientId'] = params['recipient_id'] 14397 14398 query_params = {} 14399 14400 header_params = {} 14401 14402 form_params = [] 14403 local_var_files = {} 14404 14405 body_params = None 14406 if 'tabs' in params: 14407 body_params = params['tabs'] 14408 # HTTP header `Accept` 14409 header_params['Accept'] = self.api_client.\ 14410 select_header_accept(['application/json']) 14411 14412 # Authentication setting 14413 auth_settings = [] 14414 14415 return self.api_client.call_api(resource_path, 'PUT', 14416 path_params, 14417 query_params, 14418 header_params, 14419 body=body_params, 14420 post_params=form_params, 14421 files=local_var_files, 14422 response_type='Tabs', 14423 auth_settings=auth_settings, 14424 callback=params.get('callback'), 14425 _return_http_data_only=params.get('_return_http_data_only'), 14426 _preload_content=params.get('_preload_content', True), 14427 _request_timeout=params.get('_request_timeout'), 14428 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)
14430 def update_tabs_blob(self, account_id, envelope_id, **kwargs): 14431 """ 14432 Update encrypted tabs for envelope. 14433 14434 This method makes a synchronous HTTP request by default. To make an 14435 asynchronous HTTP request, please define a `callback` function 14436 to be invoked when receiving the response. 14437 >>> def callback_function(response): 14438 >>> pprint(response) 14439 >>> 14440 >>> thread = api.update_tabs_blob(account_id, envelope_id, callback=callback_function) 14441 14442 :param callback function: The callback function 14443 for asynchronous request. (optional) 14444 :param str account_id: The external account number (int) or account ID Guid. (required) 14445 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14446 :return: None 14447 If the method is called asynchronously, 14448 returns the request thread. 14449 """ 14450 kwargs['_return_http_data_only'] = True 14451 if kwargs.get('callback'): 14452 return self.update_tabs_blob_with_http_info(account_id, envelope_id, **kwargs) 14453 else: 14454 (data) = self.update_tabs_blob_with_http_info(account_id, envelope_id, **kwargs) 14455 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)
14457 def update_tabs_blob_with_http_info(self, account_id, envelope_id, **kwargs): 14458 """ 14459 Update encrypted tabs for envelope. 14460 14461 This method makes a synchronous HTTP request by default. To make an 14462 asynchronous HTTP request, please define a `callback` function 14463 to be invoked when receiving the response. 14464 >>> def callback_function(response): 14465 >>> pprint(response) 14466 >>> 14467 >>> thread = api.update_tabs_blob_with_http_info(account_id, envelope_id, callback=callback_function) 14468 14469 :param callback function: The callback function 14470 for asynchronous request. (optional) 14471 :param str account_id: The external account number (int) or account ID Guid. (required) 14472 :param str envelope_id: The envelopeId Guid of the envelope being accessed. (required) 14473 :return: None 14474 If the method is called asynchronously, 14475 returns the request thread. 14476 """ 14477 14478 all_params = ['account_id', 'envelope_id'] 14479 all_params.append('callback') 14480 all_params.append('_return_http_data_only') 14481 all_params.append('_preload_content') 14482 all_params.append('_request_timeout') 14483 14484 params = locals() 14485 for key, val in iteritems(params['kwargs']): 14486 if key not in all_params: 14487 raise TypeError( 14488 "Got an unexpected keyword argument '%s'" 14489 " to method update_tabs_blob" % key 14490 ) 14491 params[key] = val 14492 del params['kwargs'] 14493 # verify the required parameter 'account_id' is set 14494 if ('account_id' not in params) or (params['account_id'] is None): 14495 raise ValueError("Missing the required parameter `account_id` when calling `update_tabs_blob`") 14496 # verify the required parameter 'envelope_id' is set 14497 if ('envelope_id' not in params) or (params['envelope_id'] is None): 14498 raise ValueError("Missing the required parameter `envelope_id` when calling `update_tabs_blob`") 14499 14500 14501 collection_formats = {} 14502 14503 resource_path = '/v2.1/accounts/{accountId}/envelopes/{envelopeId}/tabs_blob'.replace('{format}', 'json') 14504 path_params = {} 14505 if 'account_id' in params: 14506 path_params['accountId'] = params['account_id'] 14507 if 'envelope_id' in params: 14508 path_params['envelopeId'] = params['envelope_id'] 14509 14510 query_params = {} 14511 14512 header_params = {} 14513 14514 form_params = [] 14515 local_var_files = {} 14516 14517 body_params = None 14518 # HTTP header `Accept` 14519 header_params['Accept'] = self.api_client.\ 14520 select_header_accept(['application/json']) 14521 14522 # Authentication setting 14523 auth_settings = [] 14524 14525 return self.api_client.call_api(resource_path, 'PUT', 14526 path_params, 14527 query_params, 14528 header_params, 14529 body=body_params, 14530 post_params=form_params, 14531 files=local_var_files, 14532 response_type=None, 14533 auth_settings=auth_settings, 14534 callback=params.get('callback'), 14535 _return_http_data_only=params.get('_return_http_data_only'), 14536 _preload_content=params.get('_preload_content', True), 14537 _request_timeout=params.get('_request_timeout'), 14538 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)
14540 def update_template_delayed_routing_definition(self, account_id, template_id, workflow_step_id, **kwargs): 14541 """ 14542 Updates the delayed routing rules for a template's workflow step definition. 14543 This method makes a synchronous HTTP request by default. To make an 14544 asynchronous HTTP request, please define a `callback` function 14545 to be invoked when receiving the response. 14546 >>> def callback_function(response): 14547 >>> pprint(response) 14548 >>> 14549 >>> thread = api.update_template_delayed_routing_definition(account_id, template_id, workflow_step_id, callback=callback_function) 14550 14551 :param callback function: The callback function 14552 for asynchronous request. (optional) 14553 :param str account_id: The external account number (int) or account ID Guid. (required) 14554 :param str template_id: The ID of the template being accessed. (required) 14555 :param str workflow_step_id: (required) 14556 :param DelayedRouting delayed_routing: 14557 :return: DelayedRouting 14558 If the method is called asynchronously, 14559 returns the request thread. 14560 """ 14561 kwargs['_return_http_data_only'] = True 14562 if kwargs.get('callback'): 14563 return self.update_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 14564 else: 14565 (data) = self.update_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 14566 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)
14568 def update_template_delayed_routing_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 14569 """ 14570 Updates the delayed routing rules for a template's workflow step definition. 14571 This method makes a synchronous HTTP request by default. To make an 14572 asynchronous HTTP request, please define a `callback` function 14573 to be invoked when receiving the response. 14574 >>> def callback_function(response): 14575 >>> pprint(response) 14576 >>> 14577 >>> thread = api.update_template_delayed_routing_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 14578 14579 :param callback function: The callback function 14580 for asynchronous request. (optional) 14581 :param str account_id: The external account number (int) or account ID Guid. (required) 14582 :param str template_id: The ID of the template being accessed. (required) 14583 :param str workflow_step_id: (required) 14584 :param DelayedRouting delayed_routing: 14585 :return: DelayedRouting 14586 If the method is called asynchronously, 14587 returns the request thread. 14588 """ 14589 14590 all_params = ['account_id', 'template_id', 'workflow_step_id', 'delayed_routing'] 14591 all_params.append('callback') 14592 all_params.append('_return_http_data_only') 14593 all_params.append('_preload_content') 14594 all_params.append('_request_timeout') 14595 14596 params = locals() 14597 for key, val in iteritems(params['kwargs']): 14598 if key not in all_params: 14599 raise TypeError( 14600 "Got an unexpected keyword argument '%s'" 14601 " to method update_template_delayed_routing_definition" % key 14602 ) 14603 params[key] = val 14604 del params['kwargs'] 14605 # verify the required parameter 'account_id' is set 14606 if ('account_id' not in params) or (params['account_id'] is None): 14607 raise ValueError("Missing the required parameter `account_id` when calling `update_template_delayed_routing_definition`") 14608 # verify the required parameter 'template_id' is set 14609 if ('template_id' not in params) or (params['template_id'] is None): 14610 raise ValueError("Missing the required parameter `template_id` when calling `update_template_delayed_routing_definition`") 14611 # verify the required parameter 'workflow_step_id' is set 14612 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 14613 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_template_delayed_routing_definition`") 14614 14615 14616 collection_formats = {} 14617 14618 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}/delayedRouting'.replace('{format}', 'json') 14619 path_params = {} 14620 if 'account_id' in params: 14621 path_params['accountId'] = params['account_id'] 14622 if 'template_id' in params: 14623 path_params['templateId'] = params['template_id'] 14624 if 'workflow_step_id' in params: 14625 path_params['workflowStepId'] = params['workflow_step_id'] 14626 14627 query_params = {} 14628 14629 header_params = {} 14630 14631 form_params = [] 14632 local_var_files = {} 14633 14634 body_params = None 14635 if 'delayed_routing' in params: 14636 body_params = params['delayed_routing'] 14637 # HTTP header `Accept` 14638 header_params['Accept'] = self.api_client.\ 14639 select_header_accept(['application/json']) 14640 14641 # Authentication setting 14642 auth_settings = [] 14643 14644 return self.api_client.call_api(resource_path, 'PUT', 14645 path_params, 14646 query_params, 14647 header_params, 14648 body=body_params, 14649 post_params=form_params, 14650 files=local_var_files, 14651 response_type='DelayedRouting', 14652 auth_settings=auth_settings, 14653 callback=params.get('callback'), 14654 _return_http_data_only=params.get('_return_http_data_only'), 14655 _preload_content=params.get('_preload_content', True), 14656 _request_timeout=params.get('_request_timeout'), 14657 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)
14659 def update_template_recipient_document_visibility(self, account_id, recipient_id, template_id, **kwargs): 14660 """ 14661 Updates document visibility for the recipients 14662 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. 14663 This method makes a synchronous HTTP request by default. To make an 14664 asynchronous HTTP request, please define a `callback` function 14665 to be invoked when receiving the response. 14666 >>> def callback_function(response): 14667 >>> pprint(response) 14668 >>> 14669 >>> thread = api.update_template_recipient_document_visibility(account_id, recipient_id, template_id, callback=callback_function) 14670 14671 :param callback function: The callback function 14672 for asynchronous request. (optional) 14673 :param str account_id: The external account number (int) or account ID Guid. (required) 14674 :param str recipient_id: The ID of the recipient being accessed. (required) 14675 :param str template_id: The ID of the template being accessed. (required) 14676 :param TemplateDocumentVisibilityList template_document_visibility_list: 14677 :return: TemplateDocumentVisibilityList 14678 If the method is called asynchronously, 14679 returns the request thread. 14680 """ 14681 kwargs['_return_http_data_only'] = True 14682 if kwargs.get('callback'): 14683 return self.update_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, **kwargs) 14684 else: 14685 (data) = self.update_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, **kwargs) 14686 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)
14688 def update_template_recipient_document_visibility_with_http_info(self, account_id, recipient_id, template_id, **kwargs): 14689 """ 14690 Updates document visibility for the recipients 14691 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. 14692 This method makes a synchronous HTTP request by default. To make an 14693 asynchronous HTTP request, please define a `callback` function 14694 to be invoked when receiving the response. 14695 >>> def callback_function(response): 14696 >>> pprint(response) 14697 >>> 14698 >>> thread = api.update_template_recipient_document_visibility_with_http_info(account_id, recipient_id, template_id, callback=callback_function) 14699 14700 :param callback function: The callback function 14701 for asynchronous request. (optional) 14702 :param str account_id: The external account number (int) or account ID Guid. (required) 14703 :param str recipient_id: The ID of the recipient being accessed. (required) 14704 :param str template_id: The ID of the template being accessed. (required) 14705 :param TemplateDocumentVisibilityList template_document_visibility_list: 14706 :return: TemplateDocumentVisibilityList 14707 If the method is called asynchronously, 14708 returns the request thread. 14709 """ 14710 14711 all_params = ['account_id', 'recipient_id', 'template_id', 'template_document_visibility_list'] 14712 all_params.append('callback') 14713 all_params.append('_return_http_data_only') 14714 all_params.append('_preload_content') 14715 all_params.append('_request_timeout') 14716 14717 params = locals() 14718 for key, val in iteritems(params['kwargs']): 14719 if key not in all_params: 14720 raise TypeError( 14721 "Got an unexpected keyword argument '%s'" 14722 " to method update_template_recipient_document_visibility" % key 14723 ) 14724 params[key] = val 14725 del params['kwargs'] 14726 # verify the required parameter 'account_id' is set 14727 if ('account_id' not in params) or (params['account_id'] is None): 14728 raise ValueError("Missing the required parameter `account_id` when calling `update_template_recipient_document_visibility`") 14729 # verify the required parameter 'recipient_id' is set 14730 if ('recipient_id' not in params) or (params['recipient_id'] is None): 14731 raise ValueError("Missing the required parameter `recipient_id` when calling `update_template_recipient_document_visibility`") 14732 # verify the required parameter 'template_id' is set 14733 if ('template_id' not in params) or (params['template_id'] is None): 14734 raise ValueError("Missing the required parameter `template_id` when calling `update_template_recipient_document_visibility`") 14735 14736 14737 collection_formats = {} 14738 14739 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/recipients/{recipientId}/document_visibility'.replace('{format}', 'json') 14740 path_params = {} 14741 if 'account_id' in params: 14742 path_params['accountId'] = params['account_id'] 14743 if 'recipient_id' in params: 14744 path_params['recipientId'] = params['recipient_id'] 14745 if 'template_id' in params: 14746 path_params['templateId'] = params['template_id'] 14747 14748 query_params = {} 14749 14750 header_params = {} 14751 14752 form_params = [] 14753 local_var_files = {} 14754 14755 body_params = None 14756 if 'template_document_visibility_list' in params: 14757 body_params = params['template_document_visibility_list'] 14758 # HTTP header `Accept` 14759 header_params['Accept'] = self.api_client.\ 14760 select_header_accept(['application/json']) 14761 14762 # Authentication setting 14763 auth_settings = [] 14764 14765 return self.api_client.call_api(resource_path, 'PUT', 14766 path_params, 14767 query_params, 14768 header_params, 14769 body=body_params, 14770 post_params=form_params, 14771 files=local_var_files, 14772 response_type='TemplateDocumentVisibilityList', 14773 auth_settings=auth_settings, 14774 callback=params.get('callback'), 14775 _return_http_data_only=params.get('_return_http_data_only'), 14776 _preload_content=params.get('_preload_content', True), 14777 _request_timeout=params.get('_request_timeout'), 14778 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)
14780 def update_template_recipients_document_visibility(self, account_id, template_id, **kwargs): 14781 """ 14782 Updates document visibility for the recipients 14783 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. 14784 This method makes a synchronous HTTP request by default. To make an 14785 asynchronous HTTP request, please define a `callback` function 14786 to be invoked when receiving the response. 14787 >>> def callback_function(response): 14788 >>> pprint(response) 14789 >>> 14790 >>> thread = api.update_template_recipients_document_visibility(account_id, template_id, callback=callback_function) 14791 14792 :param callback function: The callback function 14793 for asynchronous request. (optional) 14794 :param str account_id: The external account number (int) or account ID Guid. (required) 14795 :param str template_id: The ID of the template being accessed. (required) 14796 :param TemplateDocumentVisibilityList template_document_visibility_list: 14797 :return: TemplateDocumentVisibilityList 14798 If the method is called asynchronously, 14799 returns the request thread. 14800 """ 14801 kwargs['_return_http_data_only'] = True 14802 if kwargs.get('callback'): 14803 return self.update_template_recipients_document_visibility_with_http_info(account_id, template_id, **kwargs) 14804 else: 14805 (data) = self.update_template_recipients_document_visibility_with_http_info(account_id, template_id, **kwargs) 14806 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)
14808 def update_template_recipients_document_visibility_with_http_info(self, account_id, template_id, **kwargs): 14809 """ 14810 Updates document visibility for the recipients 14811 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. 14812 This method makes a synchronous HTTP request by default. To make an 14813 asynchronous HTTP request, please define a `callback` function 14814 to be invoked when receiving the response. 14815 >>> def callback_function(response): 14816 >>> pprint(response) 14817 >>> 14818 >>> thread = api.update_template_recipients_document_visibility_with_http_info(account_id, template_id, callback=callback_function) 14819 14820 :param callback function: The callback function 14821 for asynchronous request. (optional) 14822 :param str account_id: The external account number (int) or account ID Guid. (required) 14823 :param str template_id: The ID of the template being accessed. (required) 14824 :param TemplateDocumentVisibilityList template_document_visibility_list: 14825 :return: TemplateDocumentVisibilityList 14826 If the method is called asynchronously, 14827 returns the request thread. 14828 """ 14829 14830 all_params = ['account_id', 'template_id', 'template_document_visibility_list'] 14831 all_params.append('callback') 14832 all_params.append('_return_http_data_only') 14833 all_params.append('_preload_content') 14834 all_params.append('_request_timeout') 14835 14836 params = locals() 14837 for key, val in iteritems(params['kwargs']): 14838 if key not in all_params: 14839 raise TypeError( 14840 "Got an unexpected keyword argument '%s'" 14841 " to method update_template_recipients_document_visibility" % key 14842 ) 14843 params[key] = val 14844 del params['kwargs'] 14845 # verify the required parameter 'account_id' is set 14846 if ('account_id' not in params) or (params['account_id'] is None): 14847 raise ValueError("Missing the required parameter `account_id` when calling `update_template_recipients_document_visibility`") 14848 # verify the required parameter 'template_id' is set 14849 if ('template_id' not in params) or (params['template_id'] is None): 14850 raise ValueError("Missing the required parameter `template_id` when calling `update_template_recipients_document_visibility`") 14851 14852 14853 collection_formats = {} 14854 14855 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/recipients/document_visibility'.replace('{format}', 'json') 14856 path_params = {} 14857 if 'account_id' in params: 14858 path_params['accountId'] = params['account_id'] 14859 if 'template_id' in params: 14860 path_params['templateId'] = params['template_id'] 14861 14862 query_params = {} 14863 14864 header_params = {} 14865 14866 form_params = [] 14867 local_var_files = {} 14868 14869 body_params = None 14870 if 'template_document_visibility_list' in params: 14871 body_params = params['template_document_visibility_list'] 14872 # HTTP header `Accept` 14873 header_params['Accept'] = self.api_client.\ 14874 select_header_accept(['application/json']) 14875 14876 # Authentication setting 14877 auth_settings = [] 14878 14879 return self.api_client.call_api(resource_path, 'PUT', 14880 path_params, 14881 query_params, 14882 header_params, 14883 body=body_params, 14884 post_params=form_params, 14885 files=local_var_files, 14886 response_type='TemplateDocumentVisibilityList', 14887 auth_settings=auth_settings, 14888 callback=params.get('callback'), 14889 _return_http_data_only=params.get('_return_http_data_only'), 14890 _preload_content=params.get('_preload_content', True), 14891 _request_timeout=params.get('_request_timeout'), 14892 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)
14894 def update_template_scheduled_sending_definition(self, account_id, template_id, **kwargs): 14895 """ 14896 Updates the scheduled sending rules for a template's workflow definition. 14897 This method makes a synchronous HTTP request by default. To make an 14898 asynchronous HTTP request, please define a `callback` function 14899 to be invoked when receiving the response. 14900 >>> def callback_function(response): 14901 >>> pprint(response) 14902 >>> 14903 >>> thread = api.update_template_scheduled_sending_definition(account_id, template_id, callback=callback_function) 14904 14905 :param callback function: The callback function 14906 for asynchronous request. (optional) 14907 :param str account_id: The external account number (int) or account ID Guid. (required) 14908 :param str template_id: The ID of the template being accessed. (required) 14909 :param ScheduledSending scheduled_sending: 14910 :return: ScheduledSending 14911 If the method is called asynchronously, 14912 returns the request thread. 14913 """ 14914 kwargs['_return_http_data_only'] = True 14915 if kwargs.get('callback'): 14916 return self.update_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 14917 else: 14918 (data) = self.update_template_scheduled_sending_definition_with_http_info(account_id, template_id, **kwargs) 14919 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)
14921 def update_template_scheduled_sending_definition_with_http_info(self, account_id, template_id, **kwargs): 14922 """ 14923 Updates the scheduled sending rules for a template's workflow definition. 14924 This method makes a synchronous HTTP request by default. To make an 14925 asynchronous HTTP request, please define a `callback` function 14926 to be invoked when receiving the response. 14927 >>> def callback_function(response): 14928 >>> pprint(response) 14929 >>> 14930 >>> thread = api.update_template_scheduled_sending_definition_with_http_info(account_id, template_id, callback=callback_function) 14931 14932 :param callback function: The callback function 14933 for asynchronous request. (optional) 14934 :param str account_id: The external account number (int) or account ID Guid. (required) 14935 :param str template_id: The ID of the template being accessed. (required) 14936 :param ScheduledSending scheduled_sending: 14937 :return: ScheduledSending 14938 If the method is called asynchronously, 14939 returns the request thread. 14940 """ 14941 14942 all_params = ['account_id', 'template_id', 'scheduled_sending'] 14943 all_params.append('callback') 14944 all_params.append('_return_http_data_only') 14945 all_params.append('_preload_content') 14946 all_params.append('_request_timeout') 14947 14948 params = locals() 14949 for key, val in iteritems(params['kwargs']): 14950 if key not in all_params: 14951 raise TypeError( 14952 "Got an unexpected keyword argument '%s'" 14953 " to method update_template_scheduled_sending_definition" % key 14954 ) 14955 params[key] = val 14956 del params['kwargs'] 14957 # verify the required parameter 'account_id' is set 14958 if ('account_id' not in params) or (params['account_id'] is None): 14959 raise ValueError("Missing the required parameter `account_id` when calling `update_template_scheduled_sending_definition`") 14960 # verify the required parameter 'template_id' is set 14961 if ('template_id' not in params) or (params['template_id'] is None): 14962 raise ValueError("Missing the required parameter `template_id` when calling `update_template_scheduled_sending_definition`") 14963 14964 14965 collection_formats = {} 14966 14967 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/scheduledSending'.replace('{format}', 'json') 14968 path_params = {} 14969 if 'account_id' in params: 14970 path_params['accountId'] = params['account_id'] 14971 if 'template_id' in params: 14972 path_params['templateId'] = params['template_id'] 14973 14974 query_params = {} 14975 14976 header_params = {} 14977 14978 form_params = [] 14979 local_var_files = {} 14980 14981 body_params = None 14982 if 'scheduled_sending' in params: 14983 body_params = params['scheduled_sending'] 14984 # HTTP header `Accept` 14985 header_params['Accept'] = self.api_client.\ 14986 select_header_accept(['application/json']) 14987 14988 # Authentication setting 14989 auth_settings = [] 14990 14991 return self.api_client.call_api(resource_path, 'PUT', 14992 path_params, 14993 query_params, 14994 header_params, 14995 body=body_params, 14996 post_params=form_params, 14997 files=local_var_files, 14998 response_type='ScheduledSending', 14999 auth_settings=auth_settings, 15000 callback=params.get('callback'), 15001 _return_http_data_only=params.get('_return_http_data_only'), 15002 _preload_content=params.get('_preload_content', True), 15003 _request_timeout=params.get('_request_timeout'), 15004 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)
15006 def update_template_workflow_definition(self, account_id, template_id, **kwargs): 15007 """ 15008 Updates the workflow definition for a template. 15009 Updates the specified template's workflow definition if it has one. 15010 This method makes a synchronous HTTP request by default. To make an 15011 asynchronous HTTP request, please define a `callback` function 15012 to be invoked when receiving the response. 15013 >>> def callback_function(response): 15014 >>> pprint(response) 15015 >>> 15016 >>> thread = api.update_template_workflow_definition(account_id, template_id, callback=callback_function) 15017 15018 :param callback function: The callback function 15019 for asynchronous request. (optional) 15020 :param str account_id: The external account number (int) or account ID Guid. (required) 15021 :param str template_id: The ID of the template being accessed. (required) 15022 :param Workflow workflow: 15023 :return: Workflow 15024 If the method is called asynchronously, 15025 returns the request thread. 15026 """ 15027 kwargs['_return_http_data_only'] = True 15028 if kwargs.get('callback'): 15029 return self.update_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 15030 else: 15031 (data) = self.update_template_workflow_definition_with_http_info(account_id, template_id, **kwargs) 15032 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)
15034 def update_template_workflow_definition_with_http_info(self, account_id, template_id, **kwargs): 15035 """ 15036 Updates the workflow definition for a template. 15037 Updates the specified template's workflow definition if it has one. 15038 This method makes a synchronous HTTP request by default. To make an 15039 asynchronous HTTP request, please define a `callback` function 15040 to be invoked when receiving the response. 15041 >>> def callback_function(response): 15042 >>> pprint(response) 15043 >>> 15044 >>> thread = api.update_template_workflow_definition_with_http_info(account_id, template_id, callback=callback_function) 15045 15046 :param callback function: The callback function 15047 for asynchronous request. (optional) 15048 :param str account_id: The external account number (int) or account ID Guid. (required) 15049 :param str template_id: The ID of the template being accessed. (required) 15050 :param Workflow workflow: 15051 :return: Workflow 15052 If the method is called asynchronously, 15053 returns the request thread. 15054 """ 15055 15056 all_params = ['account_id', 'template_id', 'workflow'] 15057 all_params.append('callback') 15058 all_params.append('_return_http_data_only') 15059 all_params.append('_preload_content') 15060 all_params.append('_request_timeout') 15061 15062 params = locals() 15063 for key, val in iteritems(params['kwargs']): 15064 if key not in all_params: 15065 raise TypeError( 15066 "Got an unexpected keyword argument '%s'" 15067 " to method update_template_workflow_definition" % key 15068 ) 15069 params[key] = val 15070 del params['kwargs'] 15071 # verify the required parameter 'account_id' is set 15072 if ('account_id' not in params) or (params['account_id'] is None): 15073 raise ValueError("Missing the required parameter `account_id` when calling `update_template_workflow_definition`") 15074 # verify the required parameter 'template_id' is set 15075 if ('template_id' not in params) or (params['template_id'] is None): 15076 raise ValueError("Missing the required parameter `template_id` when calling `update_template_workflow_definition`") 15077 15078 15079 collection_formats = {} 15080 15081 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow'.replace('{format}', 'json') 15082 path_params = {} 15083 if 'account_id' in params: 15084 path_params['accountId'] = params['account_id'] 15085 if 'template_id' in params: 15086 path_params['templateId'] = params['template_id'] 15087 15088 query_params = {} 15089 15090 header_params = {} 15091 15092 form_params = [] 15093 local_var_files = {} 15094 15095 body_params = None 15096 if 'workflow' in params: 15097 body_params = params['workflow'] 15098 # HTTP header `Accept` 15099 header_params['Accept'] = self.api_client.\ 15100 select_header_accept(['application/json']) 15101 15102 # Authentication setting 15103 auth_settings = [] 15104 15105 return self.api_client.call_api(resource_path, 'PUT', 15106 path_params, 15107 query_params, 15108 header_params, 15109 body=body_params, 15110 post_params=form_params, 15111 files=local_var_files, 15112 response_type='Workflow', 15113 auth_settings=auth_settings, 15114 callback=params.get('callback'), 15115 _return_http_data_only=params.get('_return_http_data_only'), 15116 _preload_content=params.get('_preload_content', True), 15117 _request_timeout=params.get('_request_timeout'), 15118 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)
15120 def update_template_workflow_step_definition(self, account_id, template_id, workflow_step_id, **kwargs): 15121 """ 15122 Updates the template workflow step definition for an envelope. 15123 This method makes a synchronous HTTP request by default. To make an 15124 asynchronous HTTP request, please define a `callback` function 15125 to be invoked when receiving the response. 15126 >>> def callback_function(response): 15127 >>> pprint(response) 15128 >>> 15129 >>> thread = api.update_template_workflow_step_definition(account_id, template_id, workflow_step_id, callback=callback_function) 15130 15131 :param callback function: The callback function 15132 for asynchronous request. (optional) 15133 :param str account_id: The external account number (int) or account ID Guid. (required) 15134 :param str template_id: The ID of the template being accessed. (required) 15135 :param str workflow_step_id: (required) 15136 :param WorkflowStep workflow_step: 15137 :return: WorkflowStep 15138 If the method is called asynchronously, 15139 returns the request thread. 15140 """ 15141 kwargs['_return_http_data_only'] = True 15142 if kwargs.get('callback'): 15143 return self.update_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 15144 else: 15145 (data) = self.update_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, **kwargs) 15146 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)
15148 def update_template_workflow_step_definition_with_http_info(self, account_id, template_id, workflow_step_id, **kwargs): 15149 """ 15150 Updates the template workflow step definition for an envelope. 15151 This method makes a synchronous HTTP request by default. To make an 15152 asynchronous HTTP request, please define a `callback` function 15153 to be invoked when receiving the response. 15154 >>> def callback_function(response): 15155 >>> pprint(response) 15156 >>> 15157 >>> thread = api.update_template_workflow_step_definition_with_http_info(account_id, template_id, workflow_step_id, callback=callback_function) 15158 15159 :param callback function: The callback function 15160 for asynchronous request. (optional) 15161 :param str account_id: The external account number (int) or account ID Guid. (required) 15162 :param str template_id: The ID of the template being accessed. (required) 15163 :param str workflow_step_id: (required) 15164 :param WorkflowStep workflow_step: 15165 :return: WorkflowStep 15166 If the method is called asynchronously, 15167 returns the request thread. 15168 """ 15169 15170 all_params = ['account_id', 'template_id', 'workflow_step_id', 'workflow_step'] 15171 all_params.append('callback') 15172 all_params.append('_return_http_data_only') 15173 all_params.append('_preload_content') 15174 all_params.append('_request_timeout') 15175 15176 params = locals() 15177 for key, val in iteritems(params['kwargs']): 15178 if key not in all_params: 15179 raise TypeError( 15180 "Got an unexpected keyword argument '%s'" 15181 " to method update_template_workflow_step_definition" % key 15182 ) 15183 params[key] = val 15184 del params['kwargs'] 15185 # verify the required parameter 'account_id' is set 15186 if ('account_id' not in params) or (params['account_id'] is None): 15187 raise ValueError("Missing the required parameter `account_id` when calling `update_template_workflow_step_definition`") 15188 # verify the required parameter 'template_id' is set 15189 if ('template_id' not in params) or (params['template_id'] is None): 15190 raise ValueError("Missing the required parameter `template_id` when calling `update_template_workflow_step_definition`") 15191 # verify the required parameter 'workflow_step_id' is set 15192 if ('workflow_step_id' not in params) or (params['workflow_step_id'] is None): 15193 raise ValueError("Missing the required parameter `workflow_step_id` when calling `update_template_workflow_step_definition`") 15194 15195 15196 collection_formats = {} 15197 15198 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps/{workflowStepId}'.replace('{format}', 'json') 15199 path_params = {} 15200 if 'account_id' in params: 15201 path_params['accountId'] = params['account_id'] 15202 if 'template_id' in params: 15203 path_params['templateId'] = params['template_id'] 15204 if 'workflow_step_id' in params: 15205 path_params['workflowStepId'] = params['workflow_step_id'] 15206 15207 query_params = {} 15208 15209 header_params = {} 15210 15211 form_params = [] 15212 local_var_files = {} 15213 15214 body_params = None 15215 if 'workflow_step' in params: 15216 body_params = params['workflow_step'] 15217 # HTTP header `Accept` 15218 header_params['Accept'] = self.api_client.\ 15219 select_header_accept(['application/json']) 15220 15221 # Authentication setting 15222 auth_settings = [] 15223 15224 return self.api_client.call_api(resource_path, 'PUT', 15225 path_params, 15226 query_params, 15227 header_params, 15228 body=body_params, 15229 post_params=form_params, 15230 files=local_var_files, 15231 response_type='WorkflowStep', 15232 auth_settings=auth_settings, 15233 callback=params.get('callback'), 15234 _return_http_data_only=params.get('_return_http_data_only'), 15235 _preload_content=params.get('_preload_content', True), 15236 _request_timeout=params.get('_request_timeout'), 15237 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.