docusign_esign.apis.accounts_api
Docusign eSignature REST API
The Docusign eSignature REST API provides you with a powerful, convenient, and simple Web services API for interacting with Docusign. # noqa: E501
OpenAPI spec version: v2.1 Contact: devcenter@docusign.com Generated by: https://github.com/swagger-api/swagger-codegen.git
1# coding: utf-8 2 3""" 4 Docusign eSignature REST API 5 6 The Docusign eSignature REST API provides you with a powerful, convenient, and simple Web services API for interacting with Docusign. # noqa: E501 7 8 OpenAPI spec version: v2.1 9 Contact: devcenter@docusign.com 10 Generated by: https://github.com/swagger-api/swagger-codegen.git 11""" 12 13 14from __future__ import absolute_import 15 16import sys 17import os 18import re 19 20# python 2 and python 3 compatibility library 21from six import iteritems 22 23from ..client.configuration import Configuration 24from ..client.api_client import ApiClient 25 26 27class AccountsApi(object): 28 """ 29 NOTE: This class is auto generated by the swagger code generator program. 30 Do not edit the class manually. 31 Ref: https://github.com/swagger-api/swagger-codegen 32 """ 33 34 def __init__(self, api_client=None): 35 config = Configuration() 36 if api_client: 37 self.api_client = api_client 38 else: 39 if not config.api_client: 40 config.api_client = ApiClient() 41 self.api_client = config.api_client 42 43 def create(self, **kwargs): 44 """ 45 Creates new accounts. 46 Creates new DocuSign service accounts. This is used to create multiple DocuSign accounts with one call. It uses the same information and formats as the normal a [Accounts:create](accounts_create) call with the information included within a `newAccountRequests` element. A maximum of 100 new accounts can be created at one time. Note that the structure of the XML request is slightly different than the JSON request, in that the new account information is included in a `newAccountDefinition` property inside the `newAccountRequests` element. Response The response returns the new account ID, password and the default user information for each newly created account. A 201 code is returned if the call succeeded. While the call may have succeed, some of the individual account requests may have failed. In the case of failures to create the account, an `errorDetails` node is added in the response to each specific request that failed. 47 This method makes a synchronous HTTP request by default. To make an 48 asynchronous HTTP request, please define a `callback` function 49 to be invoked when receiving the response. 50 >>> def callback_function(response): 51 >>> pprint(response) 52 >>> 53 >>> thread = api.create(callback=callback_function) 54 55 :param callback function: The callback function 56 for asynchronous request. (optional) 57 :param str preview_billing_plan: When set to **true**, creates the account using a preview billing plan. 58 :param NewAccountDefinition new_account_definition: 59 :return: NewAccountSummary 60 If the method is called asynchronously, 61 returns the request thread. 62 """ 63 kwargs['_return_http_data_only'] = True 64 if kwargs.get('callback'): 65 return self.create_with_http_info(**kwargs) 66 else: 67 (data) = self.create_with_http_info(**kwargs) 68 return data 69 70 def create_with_http_info(self, **kwargs): 71 """ 72 Creates new accounts. 73 Creates new DocuSign service accounts. This is used to create multiple DocuSign accounts with one call. It uses the same information and formats as the normal a [Accounts:create](accounts_create) call with the information included within a `newAccountRequests` element. A maximum of 100 new accounts can be created at one time. Note that the structure of the XML request is slightly different than the JSON request, in that the new account information is included in a `newAccountDefinition` property inside the `newAccountRequests` element. Response The response returns the new account ID, password and the default user information for each newly created account. A 201 code is returned if the call succeeded. While the call may have succeed, some of the individual account requests may have failed. In the case of failures to create the account, an `errorDetails` node is added in the response to each specific request that failed. 74 This method makes a synchronous HTTP request by default. To make an 75 asynchronous HTTP request, please define a `callback` function 76 to be invoked when receiving the response. 77 >>> def callback_function(response): 78 >>> pprint(response) 79 >>> 80 >>> thread = api.create_with_http_info(callback=callback_function) 81 82 :param callback function: The callback function 83 for asynchronous request. (optional) 84 :param str preview_billing_plan: When set to **true**, creates the account using a preview billing plan. 85 :param NewAccountDefinition new_account_definition: 86 :return: NewAccountSummary 87 If the method is called asynchronously, 88 returns the request thread. 89 """ 90 91 all_params = ['preview_billing_plan', 'new_account_definition'] 92 all_params.append('callback') 93 all_params.append('_return_http_data_only') 94 all_params.append('_preload_content') 95 all_params.append('_request_timeout') 96 97 params = locals() 98 for key, val in iteritems(params['kwargs']): 99 if key not in all_params: 100 raise TypeError( 101 "Got an unexpected keyword argument '%s'" 102 " to method create" % key 103 ) 104 params[key] = val 105 del params['kwargs'] 106 107 108 collection_formats = {} 109 110 resource_path = '/v2.1/accounts'.replace('{format}', 'json') 111 path_params = {} 112 113 query_params = {} 114 if 'preview_billing_plan' in params: 115 query_params['preview_billing_plan'] = params['preview_billing_plan'] 116 117 header_params = {} 118 119 form_params = [] 120 local_var_files = {} 121 122 body_params = None 123 if 'new_account_definition' in params: 124 body_params = params['new_account_definition'] 125 # HTTP header `Accept` 126 header_params['Accept'] = self.api_client.\ 127 select_header_accept(['application/json']) 128 129 # Authentication setting 130 auth_settings = [] 131 132 return self.api_client.call_api(resource_path, 'POST', 133 path_params, 134 query_params, 135 header_params, 136 body=body_params, 137 post_params=form_params, 138 files=local_var_files, 139 response_type='NewAccountSummary', 140 auth_settings=auth_settings, 141 callback=params.get('callback'), 142 _return_http_data_only=params.get('_return_http_data_only'), 143 _preload_content=params.get('_preload_content', True), 144 _request_timeout=params.get('_request_timeout'), 145 collection_formats=collection_formats) 146 147 def create_account_signatures(self, account_id, **kwargs): 148 """ 149 Adds/updates one or more account signatures. This request may include images in multi-part format. 150 151 This method makes a synchronous HTTP request by default. To make an 152 asynchronous HTTP request, please define a `callback` function 153 to be invoked when receiving the response. 154 >>> def callback_function(response): 155 >>> pprint(response) 156 >>> 157 >>> thread = api.create_account_signatures(account_id, callback=callback_function) 158 159 :param callback function: The callback function 160 for asynchronous request. (optional) 161 :param str account_id: The external account number (int) or account ID Guid. (required) 162 :param str decode_only: 163 :param AccountSignaturesInformation account_signatures_information: 164 :return: AccountSignaturesInformation 165 If the method is called asynchronously, 166 returns the request thread. 167 """ 168 kwargs['_return_http_data_only'] = True 169 if kwargs.get('callback'): 170 return self.create_account_signatures_with_http_info(account_id, **kwargs) 171 else: 172 (data) = self.create_account_signatures_with_http_info(account_id, **kwargs) 173 return data 174 175 def create_account_signatures_with_http_info(self, account_id, **kwargs): 176 """ 177 Adds/updates one or more account signatures. This request may include images in multi-part format. 178 179 This method makes a synchronous HTTP request by default. To make an 180 asynchronous HTTP request, please define a `callback` function 181 to be invoked when receiving the response. 182 >>> def callback_function(response): 183 >>> pprint(response) 184 >>> 185 >>> thread = api.create_account_signatures_with_http_info(account_id, callback=callback_function) 186 187 :param callback function: The callback function 188 for asynchronous request. (optional) 189 :param str account_id: The external account number (int) or account ID Guid. (required) 190 :param str decode_only: 191 :param AccountSignaturesInformation account_signatures_information: 192 :return: AccountSignaturesInformation 193 If the method is called asynchronously, 194 returns the request thread. 195 """ 196 197 all_params = ['account_id', 'decode_only', 'account_signatures_information'] 198 all_params.append('callback') 199 all_params.append('_return_http_data_only') 200 all_params.append('_preload_content') 201 all_params.append('_request_timeout') 202 203 params = locals() 204 for key, val in iteritems(params['kwargs']): 205 if key not in all_params: 206 raise TypeError( 207 "Got an unexpected keyword argument '%s'" 208 " to method create_account_signatures" % key 209 ) 210 params[key] = val 211 del params['kwargs'] 212 # verify the required parameter 'account_id' is set 213 if ('account_id' not in params) or (params['account_id'] is None): 214 raise ValueError("Missing the required parameter `account_id` when calling `create_account_signatures`") 215 216 217 collection_formats = {} 218 219 resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json') 220 path_params = {} 221 if 'account_id' in params: 222 path_params['accountId'] = params['account_id'] 223 224 query_params = {} 225 if 'decode_only' in params: 226 query_params['decode_only'] = params['decode_only'] 227 228 header_params = {} 229 230 form_params = [] 231 local_var_files = {} 232 233 body_params = None 234 if 'account_signatures_information' in params: 235 body_params = params['account_signatures_information'] 236 # HTTP header `Accept` 237 header_params['Accept'] = self.api_client.\ 238 select_header_accept(['application/json']) 239 240 # Authentication setting 241 auth_settings = [] 242 243 return self.api_client.call_api(resource_path, 'POST', 244 path_params, 245 query_params, 246 header_params, 247 body=body_params, 248 post_params=form_params, 249 files=local_var_files, 250 response_type='AccountSignaturesInformation', 251 auth_settings=auth_settings, 252 callback=params.get('callback'), 253 _return_http_data_only=params.get('_return_http_data_only'), 254 _preload_content=params.get('_preload_content', True), 255 _request_timeout=params.get('_request_timeout'), 256 collection_formats=collection_formats) 257 258 def create_brand(self, account_id, **kwargs): 259 """ 260 Creates one or more brand profile files for the account. 261 Creates one or more brand profile files for the account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSig`) must be set to **true** for the account to use this call. An error is returned if `brandId` property for a brand profile is already set for the account. To upload a new version of an existing brand profile, you must delete the profile and then upload the newer version. When brand profile files are being uploaded, they must be combined into one zip file and the `Content-Type` must be `application/zip`. 262 This method makes a synchronous HTTP request by default. To make an 263 asynchronous HTTP request, please define a `callback` function 264 to be invoked when receiving the response. 265 >>> def callback_function(response): 266 >>> pprint(response) 267 >>> 268 >>> thread = api.create_brand(account_id, callback=callback_function) 269 270 :param callback function: The callback function 271 for asynchronous request. (optional) 272 :param str account_id: The external account number (int) or account ID GUID. (required) 273 :param Brand brand: 274 :return: BrandsResponse 275 If the method is called asynchronously, 276 returns the request thread. 277 """ 278 kwargs['_return_http_data_only'] = True 279 if kwargs.get('callback'): 280 return self.create_brand_with_http_info(account_id, **kwargs) 281 else: 282 (data) = self.create_brand_with_http_info(account_id, **kwargs) 283 return data 284 285 def create_brand_with_http_info(self, account_id, **kwargs): 286 """ 287 Creates one or more brand profile files for the account. 288 Creates one or more brand profile files for the account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSig`) must be set to **true** for the account to use this call. An error is returned if `brandId` property for a brand profile is already set for the account. To upload a new version of an existing brand profile, you must delete the profile and then upload the newer version. When brand profile files are being uploaded, they must be combined into one zip file and the `Content-Type` must be `application/zip`. 289 This method makes a synchronous HTTP request by default. To make an 290 asynchronous HTTP request, please define a `callback` function 291 to be invoked when receiving the response. 292 >>> def callback_function(response): 293 >>> pprint(response) 294 >>> 295 >>> thread = api.create_brand_with_http_info(account_id, callback=callback_function) 296 297 :param callback function: The callback function 298 for asynchronous request. (optional) 299 :param str account_id: The external account number (int) or account ID GUID. (required) 300 :param Brand brand: 301 :return: BrandsResponse 302 If the method is called asynchronously, 303 returns the request thread. 304 """ 305 306 all_params = ['account_id', 'brand'] 307 all_params.append('callback') 308 all_params.append('_return_http_data_only') 309 all_params.append('_preload_content') 310 all_params.append('_request_timeout') 311 312 params = locals() 313 for key, val in iteritems(params['kwargs']): 314 if key not in all_params: 315 raise TypeError( 316 "Got an unexpected keyword argument '%s'" 317 " to method create_brand" % key 318 ) 319 params[key] = val 320 del params['kwargs'] 321 # verify the required parameter 'account_id' is set 322 if ('account_id' not in params) or (params['account_id'] is None): 323 raise ValueError("Missing the required parameter `account_id` when calling `create_brand`") 324 325 326 collection_formats = {} 327 328 resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json') 329 path_params = {} 330 if 'account_id' in params: 331 path_params['accountId'] = params['account_id'] 332 333 query_params = {} 334 335 header_params = {} 336 337 form_params = [] 338 local_var_files = {} 339 340 body_params = None 341 if 'brand' in params: 342 body_params = params['brand'] 343 # HTTP header `Accept` 344 header_params['Accept'] = self.api_client.\ 345 select_header_accept(['application/json']) 346 347 # Authentication setting 348 auth_settings = [] 349 350 return self.api_client.call_api(resource_path, 'POST', 351 path_params, 352 query_params, 353 header_params, 354 body=body_params, 355 post_params=form_params, 356 files=local_var_files, 357 response_type='BrandsResponse', 358 auth_settings=auth_settings, 359 callback=params.get('callback'), 360 _return_http_data_only=params.get('_return_http_data_only'), 361 _preload_content=params.get('_preload_content', True), 362 _request_timeout=params.get('_request_timeout'), 363 collection_formats=collection_formats) 364 365 def create_custom_field(self, account_id, **kwargs): 366 """ 367 Creates an acount custom field. 368 This method creates a custom field and makes it available for all new envelopes associated with an account. 369 This method makes a synchronous HTTP request by default. To make an 370 asynchronous HTTP request, please define a `callback` function 371 to be invoked when receiving the response. 372 >>> def callback_function(response): 373 >>> pprint(response) 374 >>> 375 >>> thread = api.create_custom_field(account_id, callback=callback_function) 376 377 :param callback function: The callback function 378 for asynchronous request. (optional) 379 :param str account_id: The external account number (int) or account ID Guid. (required) 380 :param str apply_to_templates: 381 :param CustomField custom_field: 382 :return: CustomFields 383 If the method is called asynchronously, 384 returns the request thread. 385 """ 386 kwargs['_return_http_data_only'] = True 387 if kwargs.get('callback'): 388 return self.create_custom_field_with_http_info(account_id, **kwargs) 389 else: 390 (data) = self.create_custom_field_with_http_info(account_id, **kwargs) 391 return data 392 393 def create_custom_field_with_http_info(self, account_id, **kwargs): 394 """ 395 Creates an acount custom field. 396 This method creates a custom field and makes it available for all new envelopes associated with an account. 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_custom_field_with_http_info(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 str apply_to_templates: 409 :param CustomField custom_field: 410 :return: CustomFields 411 If the method is called asynchronously, 412 returns the request thread. 413 """ 414 415 all_params = ['account_id', 'apply_to_templates', 'custom_field'] 416 all_params.append('callback') 417 all_params.append('_return_http_data_only') 418 all_params.append('_preload_content') 419 all_params.append('_request_timeout') 420 421 params = locals() 422 for key, val in iteritems(params['kwargs']): 423 if key not in all_params: 424 raise TypeError( 425 "Got an unexpected keyword argument '%s'" 426 " to method create_custom_field" % key 427 ) 428 params[key] = val 429 del params['kwargs'] 430 # verify the required parameter 'account_id' is set 431 if ('account_id' not in params) or (params['account_id'] is None): 432 raise ValueError("Missing the required parameter `account_id` when calling `create_custom_field`") 433 434 435 collection_formats = {} 436 437 resource_path = '/v2.1/accounts/{accountId}/custom_fields'.replace('{format}', 'json') 438 path_params = {} 439 if 'account_id' in params: 440 path_params['accountId'] = params['account_id'] 441 442 query_params = {} 443 if 'apply_to_templates' in params: 444 query_params['apply_to_templates'] = params['apply_to_templates'] 445 446 header_params = {} 447 448 form_params = [] 449 local_var_files = {} 450 451 body_params = None 452 if 'custom_field' in params: 453 body_params = params['custom_field'] 454 # HTTP header `Accept` 455 header_params['Accept'] = self.api_client.\ 456 select_header_accept(['application/json']) 457 458 # Authentication setting 459 auth_settings = [] 460 461 return self.api_client.call_api(resource_path, 'POST', 462 path_params, 463 query_params, 464 header_params, 465 body=body_params, 466 post_params=form_params, 467 files=local_var_files, 468 response_type='CustomFields', 469 auth_settings=auth_settings, 470 callback=params.get('callback'), 471 _return_http_data_only=params.get('_return_http_data_only'), 472 _preload_content=params.get('_preload_content', True), 473 _request_timeout=params.get('_request_timeout'), 474 collection_formats=collection_formats) 475 476 def create_permission_profile(self, account_id, **kwargs): 477 """ 478 Creates a new permission profile in the specified account. 479 This method creates a new permission profile for an account. ### Related topics - [How to create a permission profile](/docs/esign-rest-api/how-to/permission-profile-creating/) 480 This method makes a synchronous HTTP request by default. To make an 481 asynchronous HTTP request, please define a `callback` function 482 to be invoked when receiving the response. 483 >>> def callback_function(response): 484 >>> pprint(response) 485 >>> 486 >>> thread = api.create_permission_profile(account_id, callback=callback_function) 487 488 :param callback function: The callback function 489 for asynchronous request. (optional) 490 :param str account_id: The external account number (int) or account ID Guid. (required) 491 :param str include: 492 :param PermissionProfile permission_profile: 493 :return: PermissionProfile 494 If the method is called asynchronously, 495 returns the request thread. 496 """ 497 kwargs['_return_http_data_only'] = True 498 if kwargs.get('callback'): 499 return self.create_permission_profile_with_http_info(account_id, **kwargs) 500 else: 501 (data) = self.create_permission_profile_with_http_info(account_id, **kwargs) 502 return data 503 504 def create_permission_profile_with_http_info(self, account_id, **kwargs): 505 """ 506 Creates a new permission profile in the specified account. 507 This method creates a new permission profile for an account. ### Related topics - [How to create a permission profile](/docs/esign-rest-api/how-to/permission-profile-creating/) 508 This method makes a synchronous HTTP request by default. To make an 509 asynchronous HTTP request, please define a `callback` function 510 to be invoked when receiving the response. 511 >>> def callback_function(response): 512 >>> pprint(response) 513 >>> 514 >>> thread = api.create_permission_profile_with_http_info(account_id, callback=callback_function) 515 516 :param callback function: The callback function 517 for asynchronous request. (optional) 518 :param str account_id: The external account number (int) or account ID Guid. (required) 519 :param str include: 520 :param PermissionProfile permission_profile: 521 :return: PermissionProfile 522 If the method is called asynchronously, 523 returns the request thread. 524 """ 525 526 all_params = ['account_id', 'include', 'permission_profile'] 527 all_params.append('callback') 528 all_params.append('_return_http_data_only') 529 all_params.append('_preload_content') 530 all_params.append('_request_timeout') 531 532 params = locals() 533 for key, val in iteritems(params['kwargs']): 534 if key not in all_params: 535 raise TypeError( 536 "Got an unexpected keyword argument '%s'" 537 " to method create_permission_profile" % key 538 ) 539 params[key] = val 540 del params['kwargs'] 541 # verify the required parameter 'account_id' is set 542 if ('account_id' not in params) or (params['account_id'] is None): 543 raise ValueError("Missing the required parameter `account_id` when calling `create_permission_profile`") 544 545 546 collection_formats = {} 547 548 resource_path = '/v2.1/accounts/{accountId}/permission_profiles'.replace('{format}', 'json') 549 path_params = {} 550 if 'account_id' in params: 551 path_params['accountId'] = params['account_id'] 552 553 query_params = {} 554 if 'include' in params: 555 query_params['include'] = params['include'] 556 557 header_params = {} 558 559 form_params = [] 560 local_var_files = {} 561 562 body_params = None 563 if 'permission_profile' in params: 564 body_params = params['permission_profile'] 565 # HTTP header `Accept` 566 header_params['Accept'] = self.api_client.\ 567 select_header_accept(['application/json']) 568 569 # Authentication setting 570 auth_settings = [] 571 572 return self.api_client.call_api(resource_path, 'POST', 573 path_params, 574 query_params, 575 header_params, 576 body=body_params, 577 post_params=form_params, 578 files=local_var_files, 579 response_type='PermissionProfile', 580 auth_settings=auth_settings, 581 callback=params.get('callback'), 582 _return_http_data_only=params.get('_return_http_data_only'), 583 _preload_content=params.get('_preload_content', True), 584 _request_timeout=params.get('_request_timeout'), 585 collection_formats=collection_formats) 586 587 def create_user_authorization(self, account_id, user_id, **kwargs): 588 """ 589 Creates the user authorization 590 This method makes a synchronous HTTP request by default. To make an 591 asynchronous HTTP request, please define a `callback` function 592 to be invoked when receiving the response. 593 >>> def callback_function(response): 594 >>> pprint(response) 595 >>> 596 >>> thread = api.create_user_authorization(account_id, user_id, callback=callback_function) 597 598 :param callback function: The callback function 599 for asynchronous request. (optional) 600 :param str account_id: The external account number (int) or account ID Guid. (required) 601 :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required) 602 :param UserAuthorizationCreateRequest user_authorization_create_request: 603 :return: UserAuthorization 604 If the method is called asynchronously, 605 returns the request thread. 606 """ 607 kwargs['_return_http_data_only'] = True 608 if kwargs.get('callback'): 609 return self.create_user_authorization_with_http_info(account_id, user_id, **kwargs) 610 else: 611 (data) = self.create_user_authorization_with_http_info(account_id, user_id, **kwargs) 612 return data 613 614 def create_user_authorization_with_http_info(self, account_id, user_id, **kwargs): 615 """ 616 Creates the user authorization 617 This method makes a synchronous HTTP request by default. To make an 618 asynchronous HTTP request, please define a `callback` function 619 to be invoked when receiving the response. 620 >>> def callback_function(response): 621 >>> pprint(response) 622 >>> 623 >>> thread = api.create_user_authorization_with_http_info(account_id, user_id, callback=callback_function) 624 625 :param callback function: The callback function 626 for asynchronous request. (optional) 627 :param str account_id: The external account number (int) or account ID Guid. (required) 628 :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required) 629 :param UserAuthorizationCreateRequest user_authorization_create_request: 630 :return: UserAuthorization 631 If the method is called asynchronously, 632 returns the request thread. 633 """ 634 635 all_params = ['account_id', 'user_id', 'user_authorization_create_request'] 636 all_params.append('callback') 637 all_params.append('_return_http_data_only') 638 all_params.append('_preload_content') 639 all_params.append('_request_timeout') 640 641 params = locals() 642 for key, val in iteritems(params['kwargs']): 643 if key not in all_params: 644 raise TypeError( 645 "Got an unexpected keyword argument '%s'" 646 " to method create_user_authorization" % key 647 ) 648 params[key] = val 649 del params['kwargs'] 650 # verify the required parameter 'account_id' is set 651 if ('account_id' not in params) or (params['account_id'] is None): 652 raise ValueError("Missing the required parameter `account_id` when calling `create_user_authorization`") 653 # verify the required parameter 'user_id' is set 654 if ('user_id' not in params) or (params['user_id'] is None): 655 raise ValueError("Missing the required parameter `user_id` when calling `create_user_authorization`") 656 657 658 collection_formats = {} 659 660 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorization'.replace('{format}', 'json') 661 path_params = {} 662 if 'account_id' in params: 663 path_params['accountId'] = params['account_id'] 664 if 'user_id' in params: 665 path_params['userId'] = params['user_id'] 666 667 query_params = {} 668 669 header_params = {} 670 671 form_params = [] 672 local_var_files = {} 673 674 body_params = None 675 if 'user_authorization_create_request' in params: 676 body_params = params['user_authorization_create_request'] 677 # HTTP header `Accept` 678 header_params['Accept'] = self.api_client.\ 679 select_header_accept(['application/json']) 680 681 # Authentication setting 682 auth_settings = [] 683 684 return self.api_client.call_api(resource_path, 'POST', 685 path_params, 686 query_params, 687 header_params, 688 body=body_params, 689 post_params=form_params, 690 files=local_var_files, 691 response_type='UserAuthorization', 692 auth_settings=auth_settings, 693 callback=params.get('callback'), 694 _return_http_data_only=params.get('_return_http_data_only'), 695 _preload_content=params.get('_preload_content', True), 696 _request_timeout=params.get('_request_timeout'), 697 collection_formats=collection_formats) 698 699 def create_user_authorizations(self, account_id, user_id, **kwargs): 700 """ 701 Creates ot updates user authorizations 702 This method makes a synchronous HTTP request by default. To make an 703 asynchronous HTTP request, please define a `callback` function 704 to be invoked when receiving the response. 705 >>> def callback_function(response): 706 >>> pprint(response) 707 >>> 708 >>> thread = api.create_user_authorizations(account_id, user_id, callback=callback_function) 709 710 :param callback function: The callback function 711 for asynchronous request. (optional) 712 :param str account_id: The external account number (int) or account ID Guid. (required) 713 :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required) 714 :param UserAuthorizationsRequest user_authorizations_request: 715 :return: UserAuthorizationsResponse 716 If the method is called asynchronously, 717 returns the request thread. 718 """ 719 kwargs['_return_http_data_only'] = True 720 if kwargs.get('callback'): 721 return self.create_user_authorizations_with_http_info(account_id, user_id, **kwargs) 722 else: 723 (data) = self.create_user_authorizations_with_http_info(account_id, user_id, **kwargs) 724 return data 725 726 def create_user_authorizations_with_http_info(self, account_id, user_id, **kwargs): 727 """ 728 Creates ot updates user authorizations 729 This method makes a synchronous HTTP request by default. To make an 730 asynchronous HTTP request, please define a `callback` function 731 to be invoked when receiving the response. 732 >>> def callback_function(response): 733 >>> pprint(response) 734 >>> 735 >>> thread = api.create_user_authorizations_with_http_info(account_id, user_id, callback=callback_function) 736 737 :param callback function: The callback function 738 for asynchronous request. (optional) 739 :param str account_id: The external account number (int) or account ID Guid. (required) 740 :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required) 741 :param UserAuthorizationsRequest user_authorizations_request: 742 :return: UserAuthorizationsResponse 743 If the method is called asynchronously, 744 returns the request thread. 745 """ 746 747 all_params = ['account_id', 'user_id', 'user_authorizations_request'] 748 all_params.append('callback') 749 all_params.append('_return_http_data_only') 750 all_params.append('_preload_content') 751 all_params.append('_request_timeout') 752 753 params = locals() 754 for key, val in iteritems(params['kwargs']): 755 if key not in all_params: 756 raise TypeError( 757 "Got an unexpected keyword argument '%s'" 758 " to method create_user_authorizations" % key 759 ) 760 params[key] = val 761 del params['kwargs'] 762 # verify the required parameter 'account_id' is set 763 if ('account_id' not in params) or (params['account_id'] is None): 764 raise ValueError("Missing the required parameter `account_id` when calling `create_user_authorizations`") 765 # verify the required parameter 'user_id' is set 766 if ('user_id' not in params) or (params['user_id'] is None): 767 raise ValueError("Missing the required parameter `user_id` when calling `create_user_authorizations`") 768 769 770 collection_formats = {} 771 772 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorizations'.replace('{format}', 'json') 773 path_params = {} 774 if 'account_id' in params: 775 path_params['accountId'] = params['account_id'] 776 if 'user_id' in params: 777 path_params['userId'] = params['user_id'] 778 779 query_params = {} 780 781 header_params = {} 782 783 form_params = [] 784 local_var_files = {} 785 786 body_params = None 787 if 'user_authorizations_request' in params: 788 body_params = params['user_authorizations_request'] 789 # HTTP header `Accept` 790 header_params['Accept'] = self.api_client.\ 791 select_header_accept(['application/json']) 792 793 # Authentication setting 794 auth_settings = [] 795 796 return self.api_client.call_api(resource_path, 'POST', 797 path_params, 798 query_params, 799 header_params, 800 body=body_params, 801 post_params=form_params, 802 files=local_var_files, 803 response_type='UserAuthorizationsResponse', 804 auth_settings=auth_settings, 805 callback=params.get('callback'), 806 _return_http_data_only=params.get('_return_http_data_only'), 807 _preload_content=params.get('_preload_content', True), 808 _request_timeout=params.get('_request_timeout'), 809 collection_formats=collection_formats) 810 811 def delete(self, account_id, **kwargs): 812 """ 813 Deletes the specified account. 814 This closes the specified account. You must be an account admin to close your account. Once closed, an account must be reopened by DocuSign. 815 This method makes a synchronous HTTP request by default. To make an 816 asynchronous HTTP request, please define a `callback` function 817 to be invoked when receiving the response. 818 >>> def callback_function(response): 819 >>> pprint(response) 820 >>> 821 >>> thread = api.delete(account_id, callback=callback_function) 822 823 :param callback function: The callback function 824 for asynchronous request. (optional) 825 :param str account_id: The external account number (int) or account ID Guid. (required) 826 :param str redact_user_data: 827 :return: None 828 If the method is called asynchronously, 829 returns the request thread. 830 """ 831 kwargs['_return_http_data_only'] = True 832 if kwargs.get('callback'): 833 return self.delete_with_http_info(account_id, **kwargs) 834 else: 835 (data) = self.delete_with_http_info(account_id, **kwargs) 836 return data 837 838 def delete_with_http_info(self, account_id, **kwargs): 839 """ 840 Deletes the specified account. 841 This closes the specified account. You must be an account admin to close your account. Once closed, an account must be reopened by DocuSign. 842 This method makes a synchronous HTTP request by default. To make an 843 asynchronous HTTP request, please define a `callback` function 844 to be invoked when receiving the response. 845 >>> def callback_function(response): 846 >>> pprint(response) 847 >>> 848 >>> thread = api.delete_with_http_info(account_id, callback=callback_function) 849 850 :param callback function: The callback function 851 for asynchronous request. (optional) 852 :param str account_id: The external account number (int) or account ID Guid. (required) 853 :param str redact_user_data: 854 :return: None 855 If the method is called asynchronously, 856 returns the request thread. 857 """ 858 859 all_params = ['account_id', 'redact_user_data'] 860 all_params.append('callback') 861 all_params.append('_return_http_data_only') 862 all_params.append('_preload_content') 863 all_params.append('_request_timeout') 864 865 params = locals() 866 for key, val in iteritems(params['kwargs']): 867 if key not in all_params: 868 raise TypeError( 869 "Got an unexpected keyword argument '%s'" 870 " to method delete" % key 871 ) 872 params[key] = val 873 del params['kwargs'] 874 # verify the required parameter 'account_id' is set 875 if ('account_id' not in params) or (params['account_id'] is None): 876 raise ValueError("Missing the required parameter `account_id` when calling `delete`") 877 878 879 collection_formats = {} 880 881 resource_path = '/v2.1/accounts/{accountId}'.replace('{format}', 'json') 882 path_params = {} 883 if 'account_id' in params: 884 path_params['accountId'] = params['account_id'] 885 886 query_params = {} 887 if 'redact_user_data' in params: 888 query_params['redact_user_data'] = params['redact_user_data'] 889 890 header_params = {} 891 892 form_params = [] 893 local_var_files = {} 894 895 body_params = None 896 # HTTP header `Accept` 897 header_params['Accept'] = self.api_client.\ 898 select_header_accept(['application/json']) 899 900 # Authentication setting 901 auth_settings = [] 902 903 return self.api_client.call_api(resource_path, 'DELETE', 904 path_params, 905 query_params, 906 header_params, 907 body=body_params, 908 post_params=form_params, 909 files=local_var_files, 910 response_type=None, 911 auth_settings=auth_settings, 912 callback=params.get('callback'), 913 _return_http_data_only=params.get('_return_http_data_only'), 914 _preload_content=params.get('_preload_content', True), 915 _request_timeout=params.get('_request_timeout'), 916 collection_formats=collection_formats) 917 918 def delete_account_signature(self, account_id, signature_id, **kwargs): 919 """ 920 Close the specified signature by Id. 921 922 This method makes a synchronous HTTP request by default. To make an 923 asynchronous HTTP request, please define a `callback` function 924 to be invoked when receiving the response. 925 >>> def callback_function(response): 926 >>> pprint(response) 927 >>> 928 >>> thread = api.delete_account_signature(account_id, signature_id, callback=callback_function) 929 930 :param callback function: The callback function 931 for asynchronous request. (optional) 932 :param str account_id: The external account number (int) or account ID Guid. (required) 933 :param str signature_id: The ID of the signature being accessed. (required) 934 :return: None 935 If the method is called asynchronously, 936 returns the request thread. 937 """ 938 kwargs['_return_http_data_only'] = True 939 if kwargs.get('callback'): 940 return self.delete_account_signature_with_http_info(account_id, signature_id, **kwargs) 941 else: 942 (data) = self.delete_account_signature_with_http_info(account_id, signature_id, **kwargs) 943 return data 944 945 def delete_account_signature_with_http_info(self, account_id, signature_id, **kwargs): 946 """ 947 Close the specified signature by Id. 948 949 This method makes a synchronous HTTP request by default. To make an 950 asynchronous HTTP request, please define a `callback` function 951 to be invoked when receiving the response. 952 >>> def callback_function(response): 953 >>> pprint(response) 954 >>> 955 >>> thread = api.delete_account_signature_with_http_info(account_id, signature_id, callback=callback_function) 956 957 :param callback function: The callback function 958 for asynchronous request. (optional) 959 :param str account_id: The external account number (int) or account ID Guid. (required) 960 :param str signature_id: The ID of the signature being accessed. (required) 961 :return: None 962 If the method is called asynchronously, 963 returns the request thread. 964 """ 965 966 all_params = ['account_id', 'signature_id'] 967 all_params.append('callback') 968 all_params.append('_return_http_data_only') 969 all_params.append('_preload_content') 970 all_params.append('_request_timeout') 971 972 params = locals() 973 for key, val in iteritems(params['kwargs']): 974 if key not in all_params: 975 raise TypeError( 976 "Got an unexpected keyword argument '%s'" 977 " to method delete_account_signature" % key 978 ) 979 params[key] = val 980 del params['kwargs'] 981 # verify the required parameter 'account_id' is set 982 if ('account_id' not in params) or (params['account_id'] is None): 983 raise ValueError("Missing the required parameter `account_id` when calling `delete_account_signature`") 984 # verify the required parameter 'signature_id' is set 985 if ('signature_id' not in params) or (params['signature_id'] is None): 986 raise ValueError("Missing the required parameter `signature_id` when calling `delete_account_signature`") 987 988 989 collection_formats = {} 990 991 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 992 path_params = {} 993 if 'account_id' in params: 994 path_params['accountId'] = params['account_id'] 995 if 'signature_id' in params: 996 path_params['signatureId'] = params['signature_id'] 997 998 query_params = {} 999 1000 header_params = {} 1001 1002 form_params = [] 1003 local_var_files = {} 1004 1005 body_params = None 1006 # HTTP header `Accept` 1007 header_params['Accept'] = self.api_client.\ 1008 select_header_accept(['application/json']) 1009 1010 # Authentication setting 1011 auth_settings = [] 1012 1013 return self.api_client.call_api(resource_path, 'DELETE', 1014 path_params, 1015 query_params, 1016 header_params, 1017 body=body_params, 1018 post_params=form_params, 1019 files=local_var_files, 1020 response_type=None, 1021 auth_settings=auth_settings, 1022 callback=params.get('callback'), 1023 _return_http_data_only=params.get('_return_http_data_only'), 1024 _preload_content=params.get('_preload_content', True), 1025 _request_timeout=params.get('_request_timeout'), 1026 collection_formats=collection_formats) 1027 1028 def delete_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 1029 """ 1030 Deletes a signature, initials, or stamps image. 1031 1032 This method makes a synchronous HTTP request by default. To make an 1033 asynchronous HTTP request, please define a `callback` function 1034 to be invoked when receiving the response. 1035 >>> def callback_function(response): 1036 >>> pprint(response) 1037 >>> 1038 >>> thread = api.delete_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 1039 1040 :param callback function: The callback function 1041 for asynchronous request. (optional) 1042 :param str account_id: The external account number (int) or account ID Guid. (required) 1043 :param str image_type: One of **signature_image** or **initials_image**. (required) 1044 :param str signature_id: The ID of the signature being accessed. (required) 1045 :return: AccountSignature 1046 If the method is called asynchronously, 1047 returns the request thread. 1048 """ 1049 kwargs['_return_http_data_only'] = True 1050 if kwargs.get('callback'): 1051 return self.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 1052 else: 1053 (data) = self.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 1054 return data 1055 1056 def delete_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 1057 """ 1058 Deletes a signature, initials, or stamps image. 1059 1060 This method makes a synchronous HTTP request by default. To make an 1061 asynchronous HTTP request, please define a `callback` function 1062 to be invoked when receiving the response. 1063 >>> def callback_function(response): 1064 >>> pprint(response) 1065 >>> 1066 >>> thread = api.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 1067 1068 :param callback function: The callback function 1069 for asynchronous request. (optional) 1070 :param str account_id: The external account number (int) or account ID Guid. (required) 1071 :param str image_type: One of **signature_image** or **initials_image**. (required) 1072 :param str signature_id: The ID of the signature being accessed. (required) 1073 :return: AccountSignature 1074 If the method is called asynchronously, 1075 returns the request thread. 1076 """ 1077 1078 all_params = ['account_id', 'image_type', 'signature_id'] 1079 all_params.append('callback') 1080 all_params.append('_return_http_data_only') 1081 all_params.append('_preload_content') 1082 all_params.append('_request_timeout') 1083 1084 params = locals() 1085 for key, val in iteritems(params['kwargs']): 1086 if key not in all_params: 1087 raise TypeError( 1088 "Got an unexpected keyword argument '%s'" 1089 " to method delete_account_signature_image" % key 1090 ) 1091 params[key] = val 1092 del params['kwargs'] 1093 # verify the required parameter 'account_id' is set 1094 if ('account_id' not in params) or (params['account_id'] is None): 1095 raise ValueError("Missing the required parameter `account_id` when calling `delete_account_signature_image`") 1096 # verify the required parameter 'image_type' is set 1097 if ('image_type' not in params) or (params['image_type'] is None): 1098 raise ValueError("Missing the required parameter `image_type` when calling `delete_account_signature_image`") 1099 # verify the required parameter 'signature_id' is set 1100 if ('signature_id' not in params) or (params['signature_id'] is None): 1101 raise ValueError("Missing the required parameter `signature_id` when calling `delete_account_signature_image`") 1102 1103 1104 collection_formats = {} 1105 1106 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 1107 path_params = {} 1108 if 'account_id' in params: 1109 path_params['accountId'] = params['account_id'] 1110 if 'image_type' in params: 1111 path_params['imageType'] = params['image_type'] 1112 if 'signature_id' in params: 1113 path_params['signatureId'] = params['signature_id'] 1114 1115 query_params = {} 1116 1117 header_params = {} 1118 1119 form_params = [] 1120 local_var_files = {} 1121 1122 body_params = None 1123 # HTTP header `Accept` 1124 header_params['Accept'] = self.api_client.\ 1125 select_header_accept(['application/json']) 1126 1127 # Authentication setting 1128 auth_settings = [] 1129 1130 return self.api_client.call_api(resource_path, 'DELETE', 1131 path_params, 1132 query_params, 1133 header_params, 1134 body=body_params, 1135 post_params=form_params, 1136 files=local_var_files, 1137 response_type='AccountSignature', 1138 auth_settings=auth_settings, 1139 callback=params.get('callback'), 1140 _return_http_data_only=params.get('_return_http_data_only'), 1141 _preload_content=params.get('_preload_content', True), 1142 _request_timeout=params.get('_request_timeout'), 1143 collection_formats=collection_formats) 1144 1145 def delete_brand(self, account_id, brand_id, **kwargs): 1146 """ 1147 Removes a brand. 1148 This method deletes a brand from an account. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 1149 This method makes a synchronous HTTP request by default. To make an 1150 asynchronous HTTP request, please define a `callback` function 1151 to be invoked when receiving the response. 1152 >>> def callback_function(response): 1153 >>> pprint(response) 1154 >>> 1155 >>> thread = api.delete_brand(account_id, brand_id, callback=callback_function) 1156 1157 :param callback function: The callback function 1158 for asynchronous request. (optional) 1159 :param str account_id: The external account number (int) or account ID Guid. (required) 1160 :param str brand_id: The unique identifier of a brand. (required) 1161 :return: None 1162 If the method is called asynchronously, 1163 returns the request thread. 1164 """ 1165 kwargs['_return_http_data_only'] = True 1166 if kwargs.get('callback'): 1167 return self.delete_brand_with_http_info(account_id, brand_id, **kwargs) 1168 else: 1169 (data) = self.delete_brand_with_http_info(account_id, brand_id, **kwargs) 1170 return data 1171 1172 def delete_brand_with_http_info(self, account_id, brand_id, **kwargs): 1173 """ 1174 Removes a brand. 1175 This method deletes a brand from an account. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 1176 This method makes a synchronous HTTP request by default. To make an 1177 asynchronous HTTP request, please define a `callback` function 1178 to be invoked when receiving the response. 1179 >>> def callback_function(response): 1180 >>> pprint(response) 1181 >>> 1182 >>> thread = api.delete_brand_with_http_info(account_id, brand_id, callback=callback_function) 1183 1184 :param callback function: The callback function 1185 for asynchronous request. (optional) 1186 :param str account_id: The external account number (int) or account ID Guid. (required) 1187 :param str brand_id: The unique identifier of a brand. (required) 1188 :return: None 1189 If the method is called asynchronously, 1190 returns the request thread. 1191 """ 1192 1193 all_params = ['account_id', 'brand_id'] 1194 all_params.append('callback') 1195 all_params.append('_return_http_data_only') 1196 all_params.append('_preload_content') 1197 all_params.append('_request_timeout') 1198 1199 params = locals() 1200 for key, val in iteritems(params['kwargs']): 1201 if key not in all_params: 1202 raise TypeError( 1203 "Got an unexpected keyword argument '%s'" 1204 " to method delete_brand" % key 1205 ) 1206 params[key] = val 1207 del params['kwargs'] 1208 # verify the required parameter 'account_id' is set 1209 if ('account_id' not in params) or (params['account_id'] is None): 1210 raise ValueError("Missing the required parameter `account_id` when calling `delete_brand`") 1211 # verify the required parameter 'brand_id' is set 1212 if ('brand_id' not in params) or (params['brand_id'] is None): 1213 raise ValueError("Missing the required parameter `brand_id` when calling `delete_brand`") 1214 1215 1216 collection_formats = {} 1217 1218 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 1219 path_params = {} 1220 if 'account_id' in params: 1221 path_params['accountId'] = params['account_id'] 1222 if 'brand_id' in params: 1223 path_params['brandId'] = params['brand_id'] 1224 1225 query_params = {} 1226 1227 header_params = {} 1228 1229 form_params = [] 1230 local_var_files = {} 1231 1232 body_params = None 1233 # HTTP header `Accept` 1234 header_params['Accept'] = self.api_client.\ 1235 select_header_accept(['application/json']) 1236 1237 # Authentication setting 1238 auth_settings = [] 1239 1240 return self.api_client.call_api(resource_path, 'DELETE', 1241 path_params, 1242 query_params, 1243 header_params, 1244 body=body_params, 1245 post_params=form_params, 1246 files=local_var_files, 1247 response_type=None, 1248 auth_settings=auth_settings, 1249 callback=params.get('callback'), 1250 _return_http_data_only=params.get('_return_http_data_only'), 1251 _preload_content=params.get('_preload_content', True), 1252 _request_timeout=params.get('_request_timeout'), 1253 collection_formats=collection_formats) 1254 1255 def delete_brand_logo_by_type(self, account_id, brand_id, logo_type, **kwargs): 1256 """ 1257 Delete one branding logo. 1258 This method deletes a single logo from an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 1259 This method makes a synchronous HTTP request by default. To make an 1260 asynchronous HTTP request, please define a `callback` function 1261 to be invoked when receiving the response. 1262 >>> def callback_function(response): 1263 >>> pprint(response) 1264 >>> 1265 >>> thread = api.delete_brand_logo_by_type(account_id, brand_id, logo_type, callback=callback_function) 1266 1267 :param callback function: The callback function 1268 for asynchronous request. (optional) 1269 :param str account_id: The external account number (int) or account ID Guid. (required) 1270 :param str brand_id: The unique identifier of a brand. (required) 1271 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 1272 :return: None 1273 If the method is called asynchronously, 1274 returns the request thread. 1275 """ 1276 kwargs['_return_http_data_only'] = True 1277 if kwargs.get('callback'): 1278 return self.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 1279 else: 1280 (data) = self.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 1281 return data 1282 1283 def delete_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, **kwargs): 1284 """ 1285 Delete one branding logo. 1286 This method deletes a single logo from an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 1287 This method makes a synchronous HTTP request by default. To make an 1288 asynchronous HTTP request, please define a `callback` function 1289 to be invoked when receiving the response. 1290 >>> def callback_function(response): 1291 >>> pprint(response) 1292 >>> 1293 >>> thread = api.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, callback=callback_function) 1294 1295 :param callback function: The callback function 1296 for asynchronous request. (optional) 1297 :param str account_id: The external account number (int) or account ID Guid. (required) 1298 :param str brand_id: The unique identifier of a brand. (required) 1299 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 1300 :return: None 1301 If the method is called asynchronously, 1302 returns the request thread. 1303 """ 1304 1305 all_params = ['account_id', 'brand_id', 'logo_type'] 1306 all_params.append('callback') 1307 all_params.append('_return_http_data_only') 1308 all_params.append('_preload_content') 1309 all_params.append('_request_timeout') 1310 1311 params = locals() 1312 for key, val in iteritems(params['kwargs']): 1313 if key not in all_params: 1314 raise TypeError( 1315 "Got an unexpected keyword argument '%s'" 1316 " to method delete_brand_logo_by_type" % key 1317 ) 1318 params[key] = val 1319 del params['kwargs'] 1320 # verify the required parameter 'account_id' is set 1321 if ('account_id' not in params) or (params['account_id'] is None): 1322 raise ValueError("Missing the required parameter `account_id` when calling `delete_brand_logo_by_type`") 1323 # verify the required parameter 'brand_id' is set 1324 if ('brand_id' not in params) or (params['brand_id'] is None): 1325 raise ValueError("Missing the required parameter `brand_id` when calling `delete_brand_logo_by_type`") 1326 # verify the required parameter 'logo_type' is set 1327 if ('logo_type' not in params) or (params['logo_type'] is None): 1328 raise ValueError("Missing the required parameter `logo_type` when calling `delete_brand_logo_by_type`") 1329 1330 1331 collection_formats = {} 1332 1333 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 1334 path_params = {} 1335 if 'account_id' in params: 1336 path_params['accountId'] = params['account_id'] 1337 if 'brand_id' in params: 1338 path_params['brandId'] = params['brand_id'] 1339 if 'logo_type' in params: 1340 path_params['logoType'] = params['logo_type'] 1341 1342 query_params = {} 1343 1344 header_params = {} 1345 1346 form_params = [] 1347 local_var_files = {} 1348 1349 body_params = None 1350 # HTTP header `Accept` 1351 header_params['Accept'] = self.api_client.\ 1352 select_header_accept(['application/json']) 1353 1354 # Authentication setting 1355 auth_settings = [] 1356 1357 return self.api_client.call_api(resource_path, 'DELETE', 1358 path_params, 1359 query_params, 1360 header_params, 1361 body=body_params, 1362 post_params=form_params, 1363 files=local_var_files, 1364 response_type=None, 1365 auth_settings=auth_settings, 1366 callback=params.get('callback'), 1367 _return_http_data_only=params.get('_return_http_data_only'), 1368 _preload_content=params.get('_preload_content', True), 1369 _request_timeout=params.get('_request_timeout'), 1370 collection_formats=collection_formats) 1371 1372 def delete_brands(self, account_id, **kwargs): 1373 """ 1374 Deletes one or more brand profiles. 1375 Deletes one or more brand profiles from an account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`) must be set to **true** to use this call. 1376 This method makes a synchronous HTTP request by default. To make an 1377 asynchronous HTTP request, please define a `callback` function 1378 to be invoked when receiving the response. 1379 >>> def callback_function(response): 1380 >>> pprint(response) 1381 >>> 1382 >>> thread = api.delete_brands(account_id, callback=callback_function) 1383 1384 :param callback function: The callback function 1385 for asynchronous request. (optional) 1386 :param str account_id: The external account number (int) or account ID Guid. (required) 1387 :param BrandsRequest brands_request: 1388 :return: BrandsResponse 1389 If the method is called asynchronously, 1390 returns the request thread. 1391 """ 1392 kwargs['_return_http_data_only'] = True 1393 if kwargs.get('callback'): 1394 return self.delete_brands_with_http_info(account_id, **kwargs) 1395 else: 1396 (data) = self.delete_brands_with_http_info(account_id, **kwargs) 1397 return data 1398 1399 def delete_brands_with_http_info(self, account_id, **kwargs): 1400 """ 1401 Deletes one or more brand profiles. 1402 Deletes one or more brand profiles from an account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`) must be set to **true** to use this call. 1403 This method makes a synchronous HTTP request by default. To make an 1404 asynchronous HTTP request, please define a `callback` function 1405 to be invoked when receiving the response. 1406 >>> def callback_function(response): 1407 >>> pprint(response) 1408 >>> 1409 >>> thread = api.delete_brands_with_http_info(account_id, callback=callback_function) 1410 1411 :param callback function: The callback function 1412 for asynchronous request. (optional) 1413 :param str account_id: The external account number (int) or account ID Guid. (required) 1414 :param BrandsRequest brands_request: 1415 :return: BrandsResponse 1416 If the method is called asynchronously, 1417 returns the request thread. 1418 """ 1419 1420 all_params = ['account_id', 'brands_request'] 1421 all_params.append('callback') 1422 all_params.append('_return_http_data_only') 1423 all_params.append('_preload_content') 1424 all_params.append('_request_timeout') 1425 1426 params = locals() 1427 for key, val in iteritems(params['kwargs']): 1428 if key not in all_params: 1429 raise TypeError( 1430 "Got an unexpected keyword argument '%s'" 1431 " to method delete_brands" % key 1432 ) 1433 params[key] = val 1434 del params['kwargs'] 1435 # verify the required parameter 'account_id' is set 1436 if ('account_id' not in params) or (params['account_id'] is None): 1437 raise ValueError("Missing the required parameter `account_id` when calling `delete_brands`") 1438 1439 1440 collection_formats = {} 1441 1442 resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json') 1443 path_params = {} 1444 if 'account_id' in params: 1445 path_params['accountId'] = params['account_id'] 1446 1447 query_params = {} 1448 1449 header_params = {} 1450 1451 form_params = [] 1452 local_var_files = {} 1453 1454 body_params = None 1455 if 'brands_request' in params: 1456 body_params = params['brands_request'] 1457 # HTTP header `Accept` 1458 header_params['Accept'] = self.api_client.\ 1459 select_header_accept(['application/json']) 1460 1461 # Authentication setting 1462 auth_settings = [] 1463 1464 return self.api_client.call_api(resource_path, 'DELETE', 1465 path_params, 1466 query_params, 1467 header_params, 1468 body=body_params, 1469 post_params=form_params, 1470 files=local_var_files, 1471 response_type='BrandsResponse', 1472 auth_settings=auth_settings, 1473 callback=params.get('callback'), 1474 _return_http_data_only=params.get('_return_http_data_only'), 1475 _preload_content=params.get('_preload_content', True), 1476 _request_timeout=params.get('_request_timeout'), 1477 collection_formats=collection_formats) 1478 1479 def delete_captive_recipient(self, account_id, recipient_part, **kwargs): 1480 """ 1481 Deletes the signature for one or more captive recipient records. 1482 Deletes the signature for one or more captive recipient records; it is primarily used for testing. This provides a way to reset the signature associated with a client user ID so that a new signature can be created the next time the client user ID is used. 1483 This method makes a synchronous HTTP request by default. To make an 1484 asynchronous HTTP request, please define a `callback` function 1485 to be invoked when receiving the response. 1486 >>> def callback_function(response): 1487 >>> pprint(response) 1488 >>> 1489 >>> thread = api.delete_captive_recipient(account_id, recipient_part, callback=callback_function) 1490 1491 :param callback function: The callback function 1492 for asynchronous request. (optional) 1493 :param str account_id: The external account number (int) or account ID Guid. (required) 1494 :param str recipient_part: (required) 1495 :param CaptiveRecipientInformation captive_recipient_information: 1496 :return: CaptiveRecipientInformation 1497 If the method is called asynchronously, 1498 returns the request thread. 1499 """ 1500 kwargs['_return_http_data_only'] = True 1501 if kwargs.get('callback'): 1502 return self.delete_captive_recipient_with_http_info(account_id, recipient_part, **kwargs) 1503 else: 1504 (data) = self.delete_captive_recipient_with_http_info(account_id, recipient_part, **kwargs) 1505 return data 1506 1507 def delete_captive_recipient_with_http_info(self, account_id, recipient_part, **kwargs): 1508 """ 1509 Deletes the signature for one or more captive recipient records. 1510 Deletes the signature for one or more captive recipient records; it is primarily used for testing. This provides a way to reset the signature associated with a client user ID so that a new signature can be created the next time the client user ID is used. 1511 This method makes a synchronous HTTP request by default. To make an 1512 asynchronous HTTP request, please define a `callback` function 1513 to be invoked when receiving the response. 1514 >>> def callback_function(response): 1515 >>> pprint(response) 1516 >>> 1517 >>> thread = api.delete_captive_recipient_with_http_info(account_id, recipient_part, callback=callback_function) 1518 1519 :param callback function: The callback function 1520 for asynchronous request. (optional) 1521 :param str account_id: The external account number (int) or account ID Guid. (required) 1522 :param str recipient_part: (required) 1523 :param CaptiveRecipientInformation captive_recipient_information: 1524 :return: CaptiveRecipientInformation 1525 If the method is called asynchronously, 1526 returns the request thread. 1527 """ 1528 1529 all_params = ['account_id', 'recipient_part', 'captive_recipient_information'] 1530 all_params.append('callback') 1531 all_params.append('_return_http_data_only') 1532 all_params.append('_preload_content') 1533 all_params.append('_request_timeout') 1534 1535 params = locals() 1536 for key, val in iteritems(params['kwargs']): 1537 if key not in all_params: 1538 raise TypeError( 1539 "Got an unexpected keyword argument '%s'" 1540 " to method delete_captive_recipient" % key 1541 ) 1542 params[key] = val 1543 del params['kwargs'] 1544 # verify the required parameter 'account_id' is set 1545 if ('account_id' not in params) or (params['account_id'] is None): 1546 raise ValueError("Missing the required parameter `account_id` when calling `delete_captive_recipient`") 1547 # verify the required parameter 'recipient_part' is set 1548 if ('recipient_part' not in params) or (params['recipient_part'] is None): 1549 raise ValueError("Missing the required parameter `recipient_part` when calling `delete_captive_recipient`") 1550 1551 1552 collection_formats = {} 1553 1554 resource_path = '/v2.1/accounts/{accountId}/captive_recipients/{recipientPart}'.replace('{format}', 'json') 1555 path_params = {} 1556 if 'account_id' in params: 1557 path_params['accountId'] = params['account_id'] 1558 if 'recipient_part' in params: 1559 path_params['recipientPart'] = params['recipient_part'] 1560 1561 query_params = {} 1562 1563 header_params = {} 1564 1565 form_params = [] 1566 local_var_files = {} 1567 1568 body_params = None 1569 if 'captive_recipient_information' in params: 1570 body_params = params['captive_recipient_information'] 1571 # HTTP header `Accept` 1572 header_params['Accept'] = self.api_client.\ 1573 select_header_accept(['application/json']) 1574 1575 # Authentication setting 1576 auth_settings = [] 1577 1578 return self.api_client.call_api(resource_path, 'DELETE', 1579 path_params, 1580 query_params, 1581 header_params, 1582 body=body_params, 1583 post_params=form_params, 1584 files=local_var_files, 1585 response_type='CaptiveRecipientInformation', 1586 auth_settings=auth_settings, 1587 callback=params.get('callback'), 1588 _return_http_data_only=params.get('_return_http_data_only'), 1589 _preload_content=params.get('_preload_content', True), 1590 _request_timeout=params.get('_request_timeout'), 1591 collection_formats=collection_formats) 1592 1593 def delete_custom_field(self, account_id, custom_field_id, **kwargs): 1594 """ 1595 Delete an existing account custom field. 1596 This method deletes an existing account custom field. 1597 This method makes a synchronous HTTP request by default. To make an 1598 asynchronous HTTP request, please define a `callback` function 1599 to be invoked when receiving the response. 1600 >>> def callback_function(response): 1601 >>> pprint(response) 1602 >>> 1603 >>> thread = api.delete_custom_field(account_id, custom_field_id, callback=callback_function) 1604 1605 :param callback function: The callback function 1606 for asynchronous request. (optional) 1607 :param str account_id: The external account number (int) or account ID Guid. (required) 1608 :param str custom_field_id: (required) 1609 :param str apply_to_templates: 1610 :return: None 1611 If the method is called asynchronously, 1612 returns the request thread. 1613 """ 1614 kwargs['_return_http_data_only'] = True 1615 if kwargs.get('callback'): 1616 return self.delete_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 1617 else: 1618 (data) = self.delete_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 1619 return data 1620 1621 def delete_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs): 1622 """ 1623 Delete an existing account custom field. 1624 This method deletes an existing account custom field. 1625 This method makes a synchronous HTTP request by default. To make an 1626 asynchronous HTTP request, please define a `callback` function 1627 to be invoked when receiving the response. 1628 >>> def callback_function(response): 1629 >>> pprint(response) 1630 >>> 1631 >>> thread = api.delete_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function) 1632 1633 :param callback function: The callback function 1634 for asynchronous request. (optional) 1635 :param str account_id: The external account number (int) or account ID Guid. (required) 1636 :param str custom_field_id: (required) 1637 :param str apply_to_templates: 1638 :return: None 1639 If the method is called asynchronously, 1640 returns the request thread. 1641 """ 1642 1643 all_params = ['account_id', 'custom_field_id', 'apply_to_templates'] 1644 all_params.append('callback') 1645 all_params.append('_return_http_data_only') 1646 all_params.append('_preload_content') 1647 all_params.append('_request_timeout') 1648 1649 params = locals() 1650 for key, val in iteritems(params['kwargs']): 1651 if key not in all_params: 1652 raise TypeError( 1653 "Got an unexpected keyword argument '%s'" 1654 " to method delete_custom_field" % key 1655 ) 1656 params[key] = val 1657 del params['kwargs'] 1658 # verify the required parameter 'account_id' is set 1659 if ('account_id' not in params) or (params['account_id'] is None): 1660 raise ValueError("Missing the required parameter `account_id` when calling `delete_custom_field`") 1661 # verify the required parameter 'custom_field_id' is set 1662 if ('custom_field_id' not in params) or (params['custom_field_id'] is None): 1663 raise ValueError("Missing the required parameter `custom_field_id` when calling `delete_custom_field`") 1664 1665 1666 collection_formats = {} 1667 1668 resource_path = '/v2.1/accounts/{accountId}/custom_fields/{customFieldId}'.replace('{format}', 'json') 1669 path_params = {} 1670 if 'account_id' in params: 1671 path_params['accountId'] = params['account_id'] 1672 if 'custom_field_id' in params: 1673 path_params['customFieldId'] = params['custom_field_id'] 1674 1675 query_params = {} 1676 if 'apply_to_templates' in params: 1677 query_params['apply_to_templates'] = params['apply_to_templates'] 1678 1679 header_params = {} 1680 1681 form_params = [] 1682 local_var_files = {} 1683 1684 body_params = None 1685 # HTTP header `Accept` 1686 header_params['Accept'] = self.api_client.\ 1687 select_header_accept(['application/json']) 1688 1689 # Authentication setting 1690 auth_settings = [] 1691 1692 return self.api_client.call_api(resource_path, 'DELETE', 1693 path_params, 1694 query_params, 1695 header_params, 1696 body=body_params, 1697 post_params=form_params, 1698 files=local_var_files, 1699 response_type=None, 1700 auth_settings=auth_settings, 1701 callback=params.get('callback'), 1702 _return_http_data_only=params.get('_return_http_data_only'), 1703 _preload_content=params.get('_preload_content', True), 1704 _request_timeout=params.get('_request_timeout'), 1705 collection_formats=collection_formats) 1706 1707 def delete_e_note_configuration(self, account_id, **kwargs): 1708 """ 1709 Deletes configuration information for the eNote eOriginal integration. 1710 1711 This method makes a synchronous HTTP request by default. To make an 1712 asynchronous HTTP request, please define a `callback` function 1713 to be invoked when receiving the response. 1714 >>> def callback_function(response): 1715 >>> pprint(response) 1716 >>> 1717 >>> thread = api.delete_e_note_configuration(account_id, callback=callback_function) 1718 1719 :param callback function: The callback function 1720 for asynchronous request. (optional) 1721 :param str account_id: The external account number (int) or account ID Guid. (required) 1722 :return: None 1723 If the method is called asynchronously, 1724 returns the request thread. 1725 """ 1726 kwargs['_return_http_data_only'] = True 1727 if kwargs.get('callback'): 1728 return self.delete_e_note_configuration_with_http_info(account_id, **kwargs) 1729 else: 1730 (data) = self.delete_e_note_configuration_with_http_info(account_id, **kwargs) 1731 return data 1732 1733 def delete_e_note_configuration_with_http_info(self, account_id, **kwargs): 1734 """ 1735 Deletes configuration information for the eNote eOriginal integration. 1736 1737 This method makes a synchronous HTTP request by default. To make an 1738 asynchronous HTTP request, please define a `callback` function 1739 to be invoked when receiving the response. 1740 >>> def callback_function(response): 1741 >>> pprint(response) 1742 >>> 1743 >>> thread = api.delete_e_note_configuration_with_http_info(account_id, callback=callback_function) 1744 1745 :param callback function: The callback function 1746 for asynchronous request. (optional) 1747 :param str account_id: The external account number (int) or account ID Guid. (required) 1748 :return: None 1749 If the method is called asynchronously, 1750 returns the request thread. 1751 """ 1752 1753 all_params = ['account_id'] 1754 all_params.append('callback') 1755 all_params.append('_return_http_data_only') 1756 all_params.append('_preload_content') 1757 all_params.append('_request_timeout') 1758 1759 params = locals() 1760 for key, val in iteritems(params['kwargs']): 1761 if key not in all_params: 1762 raise TypeError( 1763 "Got an unexpected keyword argument '%s'" 1764 " to method delete_e_note_configuration" % key 1765 ) 1766 params[key] = val 1767 del params['kwargs'] 1768 # verify the required parameter 'account_id' is set 1769 if ('account_id' not in params) or (params['account_id'] is None): 1770 raise ValueError("Missing the required parameter `account_id` when calling `delete_e_note_configuration`") 1771 1772 1773 collection_formats = {} 1774 1775 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 1776 path_params = {} 1777 if 'account_id' in params: 1778 path_params['accountId'] = params['account_id'] 1779 1780 query_params = {} 1781 1782 header_params = {} 1783 1784 form_params = [] 1785 local_var_files = {} 1786 1787 body_params = None 1788 # HTTP header `Accept` 1789 header_params['Accept'] = self.api_client.\ 1790 select_header_accept(['application/json']) 1791 1792 # Authentication setting 1793 auth_settings = [] 1794 1795 return self.api_client.call_api(resource_path, 'DELETE', 1796 path_params, 1797 query_params, 1798 header_params, 1799 body=body_params, 1800 post_params=form_params, 1801 files=local_var_files, 1802 response_type=None, 1803 auth_settings=auth_settings, 1804 callback=params.get('callback'), 1805 _return_http_data_only=params.get('_return_http_data_only'), 1806 _preload_content=params.get('_preload_content', True), 1807 _request_timeout=params.get('_request_timeout'), 1808 collection_formats=collection_formats) 1809 1810 def delete_permission_profile(self, account_id, permission_profile_id, **kwargs): 1811 """ 1812 Deletes a permissions profile within the specified account. 1813 This method deletes a permission profile from an account. To delete a permission profile, it must not have any users associated with it. When you use this method to delete a permission profile, you can reassign the users associated with it to a new permission profile at the same time by using the `move_users_to` query parameter. ### Related topics - [How to delete a permission profile](/docs/esign-rest-api/how-to/permission-profile-deleting/) 1814 This method makes a synchronous HTTP request by default. To make an 1815 asynchronous HTTP request, please define a `callback` function 1816 to be invoked when receiving the response. 1817 >>> def callback_function(response): 1818 >>> pprint(response) 1819 >>> 1820 >>> thread = api.delete_permission_profile(account_id, permission_profile_id, callback=callback_function) 1821 1822 :param callback function: The callback function 1823 for asynchronous request. (optional) 1824 :param str account_id: The external account number (int) or account ID Guid. (required) 1825 :param str permission_profile_id: (required) 1826 :param str move_users_to: 1827 :return: None 1828 If the method is called asynchronously, 1829 returns the request thread. 1830 """ 1831 kwargs['_return_http_data_only'] = True 1832 if kwargs.get('callback'): 1833 return self.delete_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 1834 else: 1835 (data) = self.delete_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 1836 return data 1837 1838 def delete_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 1839 """ 1840 Deletes a permissions profile within the specified account. 1841 This method deletes a permission profile from an account. To delete a permission profile, it must not have any users associated with it. When you use this method to delete a permission profile, you can reassign the users associated with it to a new permission profile at the same time by using the `move_users_to` query parameter. ### Related topics - [How to delete a permission profile](/docs/esign-rest-api/how-to/permission-profile-deleting/) 1842 This method makes a synchronous HTTP request by default. To make an 1843 asynchronous HTTP request, please define a `callback` function 1844 to be invoked when receiving the response. 1845 >>> def callback_function(response): 1846 >>> pprint(response) 1847 >>> 1848 >>> thread = api.delete_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 1849 1850 :param callback function: The callback function 1851 for asynchronous request. (optional) 1852 :param str account_id: The external account number (int) or account ID Guid. (required) 1853 :param str permission_profile_id: (required) 1854 :param str move_users_to: 1855 :return: None 1856 If the method is called asynchronously, 1857 returns the request thread. 1858 """ 1859 1860 all_params = ['account_id', 'permission_profile_id', 'move_users_to'] 1861 all_params.append('callback') 1862 all_params.append('_return_http_data_only') 1863 all_params.append('_preload_content') 1864 all_params.append('_request_timeout') 1865 1866 params = locals() 1867 for key, val in iteritems(params['kwargs']): 1868 if key not in all_params: 1869 raise TypeError( 1870 "Got an unexpected keyword argument '%s'" 1871 " to method delete_permission_profile" % key 1872 ) 1873 params[key] = val 1874 del params['kwargs'] 1875 # verify the required parameter 'account_id' is set 1876 if ('account_id' not in params) or (params['account_id'] is None): 1877 raise ValueError("Missing the required parameter `account_id` when calling `delete_permission_profile`") 1878 # verify the required parameter 'permission_profile_id' is set 1879 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 1880 raise ValueError("Missing the required parameter `permission_profile_id` when calling `delete_permission_profile`") 1881 1882 1883 collection_formats = {} 1884 1885 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 1886 path_params = {} 1887 if 'account_id' in params: 1888 path_params['accountId'] = params['account_id'] 1889 if 'permission_profile_id' in params: 1890 path_params['permissionProfileId'] = params['permission_profile_id'] 1891 1892 query_params = {} 1893 if 'move_users_to' in params: 1894 query_params['move_users_to'] = params['move_users_to'] 1895 1896 header_params = {} 1897 1898 form_params = [] 1899 local_var_files = {} 1900 1901 body_params = None 1902 # HTTP header `Accept` 1903 header_params['Accept'] = self.api_client.\ 1904 select_header_accept(['application/json']) 1905 1906 # Authentication setting 1907 auth_settings = [] 1908 1909 return self.api_client.call_api(resource_path, 'DELETE', 1910 path_params, 1911 query_params, 1912 header_params, 1913 body=body_params, 1914 post_params=form_params, 1915 files=local_var_files, 1916 response_type=None, 1917 auth_settings=auth_settings, 1918 callback=params.get('callback'), 1919 _return_http_data_only=params.get('_return_http_data_only'), 1920 _preload_content=params.get('_preload_content', True), 1921 _request_timeout=params.get('_request_timeout'), 1922 collection_formats=collection_formats) 1923 1924 def delete_user_authorization(self, account_id, authorization_id, user_id, **kwargs): 1925 """ 1926 Deletes the user authorization 1927 This method makes a synchronous HTTP request by default. To make an 1928 asynchronous HTTP request, please define a `callback` function 1929 to be invoked when receiving the response. 1930 >>> def callback_function(response): 1931 >>> pprint(response) 1932 >>> 1933 >>> thread = api.delete_user_authorization(account_id, authorization_id, user_id, callback=callback_function) 1934 1935 :param callback function: The callback function 1936 for asynchronous request. (optional) 1937 :param str account_id: The external account number (int) or account ID Guid. (required) 1938 :param str authorization_id: (required) 1939 :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required) 1940 :return: None 1941 If the method is called asynchronously, 1942 returns the request thread. 1943 """ 1944 kwargs['_return_http_data_only'] = True 1945 if kwargs.get('callback'): 1946 return self.delete_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 1947 else: 1948 (data) = self.delete_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 1949 return data 1950 1951 def delete_user_authorization_with_http_info(self, account_id, authorization_id, user_id, **kwargs): 1952 """ 1953 Deletes the user authorization 1954 This method makes a synchronous HTTP request by default. To make an 1955 asynchronous HTTP request, please define a `callback` function 1956 to be invoked when receiving the response. 1957 >>> def callback_function(response): 1958 >>> pprint(response) 1959 >>> 1960 >>> thread = api.delete_user_authorization_with_http_info(account_id, authorization_id, user_id, callback=callback_function) 1961 1962 :param callback function: The callback function 1963 for asynchronous request. (optional) 1964 :param str account_id: The external account number (int) or account ID Guid. (required) 1965 :param str authorization_id: (required) 1966 :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required) 1967 :return: None 1968 If the method is called asynchronously, 1969 returns the request thread. 1970 """ 1971 1972 all_params = ['account_id', 'authorization_id', 'user_id'] 1973 all_params.append('callback') 1974 all_params.append('_return_http_data_only') 1975 all_params.append('_preload_content') 1976 all_params.append('_request_timeout') 1977 1978 params = locals() 1979 for key, val in iteritems(params['kwargs']): 1980 if key not in all_params: 1981 raise TypeError( 1982 "Got an unexpected keyword argument '%s'" 1983 " to method delete_user_authorization" % key 1984 ) 1985 params[key] = val 1986 del params['kwargs'] 1987 # verify the required parameter 'account_id' is set 1988 if ('account_id' not in params) or (params['account_id'] is None): 1989 raise ValueError("Missing the required parameter `account_id` when calling `delete_user_authorization`") 1990 # verify the required parameter 'authorization_id' is set 1991 if ('authorization_id' not in params) or (params['authorization_id'] is None): 1992 raise ValueError("Missing the required parameter `authorization_id` when calling `delete_user_authorization`") 1993 # verify the required parameter 'user_id' is set 1994 if ('user_id' not in params) or (params['user_id'] is None): 1995 raise ValueError("Missing the required parameter `user_id` when calling `delete_user_authorization`") 1996 1997 1998 collection_formats = {} 1999 2000 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorization/{authorizationId}'.replace('{format}', 'json') 2001 path_params = {} 2002 if 'account_id' in params: 2003 path_params['accountId'] = params['account_id'] 2004 if 'authorization_id' in params: 2005 path_params['authorizationId'] = params['authorization_id'] 2006 if 'user_id' in params: 2007 path_params['userId'] = params['user_id'] 2008 2009 query_params = {} 2010 2011 header_params = {} 2012 2013 form_params = [] 2014 local_var_files = {} 2015 2016 body_params = None 2017 # HTTP header `Accept` 2018 header_params['Accept'] = self.api_client.\ 2019 select_header_accept(['application/json']) 2020 2021 # Authentication setting 2022 auth_settings = [] 2023 2024 return self.api_client.call_api(resource_path, 'DELETE', 2025 path_params, 2026 query_params, 2027 header_params, 2028 body=body_params, 2029 post_params=form_params, 2030 files=local_var_files, 2031 response_type=None, 2032 auth_settings=auth_settings, 2033 callback=params.get('callback'), 2034 _return_http_data_only=params.get('_return_http_data_only'), 2035 _preload_content=params.get('_preload_content', True), 2036 _request_timeout=params.get('_request_timeout'), 2037 collection_formats=collection_formats) 2038 2039 def delete_user_authorizations(self, account_id, user_id, **kwargs): 2040 """ 2041 Creates ot updates user authorizations 2042 This method makes a synchronous HTTP request by default. To make an 2043 asynchronous HTTP request, please define a `callback` function 2044 to be invoked when receiving the response. 2045 >>> def callback_function(response): 2046 >>> pprint(response) 2047 >>> 2048 >>> thread = api.delete_user_authorizations(account_id, user_id, callback=callback_function) 2049 2050 :param callback function: The callback function 2051 for asynchronous request. (optional) 2052 :param str account_id: The external account number (int) or account ID Guid. (required) 2053 :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required) 2054 :param UserAuthorizationsDeleteRequest user_authorizations_delete_request: 2055 :return: UserAuthorizationsDeleteResponse 2056 If the method is called asynchronously, 2057 returns the request thread. 2058 """ 2059 kwargs['_return_http_data_only'] = True 2060 if kwargs.get('callback'): 2061 return self.delete_user_authorizations_with_http_info(account_id, user_id, **kwargs) 2062 else: 2063 (data) = self.delete_user_authorizations_with_http_info(account_id, user_id, **kwargs) 2064 return data 2065 2066 def delete_user_authorizations_with_http_info(self, account_id, user_id, **kwargs): 2067 """ 2068 Creates ot updates user authorizations 2069 This method makes a synchronous HTTP request by default. To make an 2070 asynchronous HTTP request, please define a `callback` function 2071 to be invoked when receiving the response. 2072 >>> def callback_function(response): 2073 >>> pprint(response) 2074 >>> 2075 >>> thread = api.delete_user_authorizations_with_http_info(account_id, user_id, callback=callback_function) 2076 2077 :param callback function: The callback function 2078 for asynchronous request. (optional) 2079 :param str account_id: The external account number (int) or account ID Guid. (required) 2080 :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required) 2081 :param UserAuthorizationsDeleteRequest user_authorizations_delete_request: 2082 :return: UserAuthorizationsDeleteResponse 2083 If the method is called asynchronously, 2084 returns the request thread. 2085 """ 2086 2087 all_params = ['account_id', 'user_id', 'user_authorizations_delete_request'] 2088 all_params.append('callback') 2089 all_params.append('_return_http_data_only') 2090 all_params.append('_preload_content') 2091 all_params.append('_request_timeout') 2092 2093 params = locals() 2094 for key, val in iteritems(params['kwargs']): 2095 if key not in all_params: 2096 raise TypeError( 2097 "Got an unexpected keyword argument '%s'" 2098 " to method delete_user_authorizations" % key 2099 ) 2100 params[key] = val 2101 del params['kwargs'] 2102 # verify the required parameter 'account_id' is set 2103 if ('account_id' not in params) or (params['account_id'] is None): 2104 raise ValueError("Missing the required parameter `account_id` when calling `delete_user_authorizations`") 2105 # verify the required parameter 'user_id' is set 2106 if ('user_id' not in params) or (params['user_id'] is None): 2107 raise ValueError("Missing the required parameter `user_id` when calling `delete_user_authorizations`") 2108 2109 2110 collection_formats = {} 2111 2112 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorizations'.replace('{format}', 'json') 2113 path_params = {} 2114 if 'account_id' in params: 2115 path_params['accountId'] = params['account_id'] 2116 if 'user_id' in params: 2117 path_params['userId'] = params['user_id'] 2118 2119 query_params = {} 2120 2121 header_params = {} 2122 2123 form_params = [] 2124 local_var_files = {} 2125 2126 body_params = None 2127 if 'user_authorizations_delete_request' in params: 2128 body_params = params['user_authorizations_delete_request'] 2129 # HTTP header `Accept` 2130 header_params['Accept'] = self.api_client.\ 2131 select_header_accept(['application/json']) 2132 2133 # Authentication setting 2134 auth_settings = [] 2135 2136 return self.api_client.call_api(resource_path, 'DELETE', 2137 path_params, 2138 query_params, 2139 header_params, 2140 body=body_params, 2141 post_params=form_params, 2142 files=local_var_files, 2143 response_type='UserAuthorizationsDeleteResponse', 2144 auth_settings=auth_settings, 2145 callback=params.get('callback'), 2146 _return_http_data_only=params.get('_return_http_data_only'), 2147 _preload_content=params.get('_preload_content', True), 2148 _request_timeout=params.get('_request_timeout'), 2149 collection_formats=collection_formats) 2150 2151 def get_account_identity_verification(self, account_id, **kwargs): 2152 """ 2153 Get the list of identity verification options for an account 2154 This method returns a list of Identity Verification workflows that are available to an account. **Note:** To use this method, you must either be an account administrator or a sender. ### Related topics - [How to require ID Verification (IDV) for a recipient](/docs/esign-rest-api/how-to/id-verification/) 2155 This method makes a synchronous HTTP request by default. To make an 2156 asynchronous HTTP request, please define a `callback` function 2157 to be invoked when receiving the response. 2158 >>> def callback_function(response): 2159 >>> pprint(response) 2160 >>> 2161 >>> thread = api.get_account_identity_verification(account_id, callback=callback_function) 2162 2163 :param callback function: The callback function 2164 for asynchronous request. (optional) 2165 :param str account_id: The external account number (int) or account ID Guid. (required) 2166 :param str identity_verification_workflow_status: 2167 :return: AccountIdentityVerificationResponse 2168 If the method is called asynchronously, 2169 returns the request thread. 2170 """ 2171 kwargs['_return_http_data_only'] = True 2172 if kwargs.get('callback'): 2173 return self.get_account_identity_verification_with_http_info(account_id, **kwargs) 2174 else: 2175 (data) = self.get_account_identity_verification_with_http_info(account_id, **kwargs) 2176 return data 2177 2178 def get_account_identity_verification_with_http_info(self, account_id, **kwargs): 2179 """ 2180 Get the list of identity verification options for an account 2181 This method returns a list of Identity Verification workflows that are available to an account. **Note:** To use this method, you must either be an account administrator or a sender. ### Related topics - [How to require ID Verification (IDV) for a recipient](/docs/esign-rest-api/how-to/id-verification/) 2182 This method makes a synchronous HTTP request by default. To make an 2183 asynchronous HTTP request, please define a `callback` function 2184 to be invoked when receiving the response. 2185 >>> def callback_function(response): 2186 >>> pprint(response) 2187 >>> 2188 >>> thread = api.get_account_identity_verification_with_http_info(account_id, callback=callback_function) 2189 2190 :param callback function: The callback function 2191 for asynchronous request. (optional) 2192 :param str account_id: The external account number (int) or account ID Guid. (required) 2193 :param str identity_verification_workflow_status: 2194 :return: AccountIdentityVerificationResponse 2195 If the method is called asynchronously, 2196 returns the request thread. 2197 """ 2198 2199 all_params = ['account_id', 'identity_verification_workflow_status'] 2200 all_params.append('callback') 2201 all_params.append('_return_http_data_only') 2202 all_params.append('_preload_content') 2203 all_params.append('_request_timeout') 2204 2205 params = locals() 2206 for key, val in iteritems(params['kwargs']): 2207 if key not in all_params: 2208 raise TypeError( 2209 "Got an unexpected keyword argument '%s'" 2210 " to method get_account_identity_verification" % key 2211 ) 2212 params[key] = val 2213 del params['kwargs'] 2214 # verify the required parameter 'account_id' is set 2215 if ('account_id' not in params) or (params['account_id'] is None): 2216 raise ValueError("Missing the required parameter `account_id` when calling `get_account_identity_verification`") 2217 2218 2219 collection_formats = {} 2220 2221 resource_path = '/v2.1/accounts/{accountId}/identity_verification'.replace('{format}', 'json') 2222 path_params = {} 2223 if 'account_id' in params: 2224 path_params['accountId'] = params['account_id'] 2225 2226 query_params = {} 2227 if 'identity_verification_workflow_status' in params: 2228 query_params['identity_verification_workflow_status'] = params['identity_verification_workflow_status'] 2229 2230 header_params = {} 2231 2232 form_params = [] 2233 local_var_files = {} 2234 2235 body_params = None 2236 # HTTP header `Accept` 2237 header_params['Accept'] = self.api_client.\ 2238 select_header_accept(['application/json']) 2239 2240 # Authentication setting 2241 auth_settings = [] 2242 2243 return self.api_client.call_api(resource_path, 'GET', 2244 path_params, 2245 query_params, 2246 header_params, 2247 body=body_params, 2248 post_params=form_params, 2249 files=local_var_files, 2250 response_type='AccountIdentityVerificationResponse', 2251 auth_settings=auth_settings, 2252 callback=params.get('callback'), 2253 _return_http_data_only=params.get('_return_http_data_only'), 2254 _preload_content=params.get('_preload_content', True), 2255 _request_timeout=params.get('_request_timeout'), 2256 collection_formats=collection_formats) 2257 2258 def get_account_information(self, account_id, **kwargs): 2259 """ 2260 Retrieves the account information for the specified account. 2261 Retrieves the account information for the specified account. **Response** The `canUpgrade` property contains is a Boolean that indicates whether the account can be upgraded through the API. 2262 This method makes a synchronous HTTP request by default. To make an 2263 asynchronous HTTP request, please define a `callback` function 2264 to be invoked when receiving the response. 2265 >>> def callback_function(response): 2266 >>> pprint(response) 2267 >>> 2268 >>> thread = api.get_account_information(account_id, callback=callback_function) 2269 2270 :param callback function: The callback function 2271 for asynchronous request. (optional) 2272 :param str account_id: The external account number (int) or account ID Guid. (required) 2273 :param str include_account_settings: When set to **true**, includes the account settings for the account in the response. 2274 :return: AccountInformation 2275 If the method is called asynchronously, 2276 returns the request thread. 2277 """ 2278 kwargs['_return_http_data_only'] = True 2279 if kwargs.get('callback'): 2280 return self.get_account_information_with_http_info(account_id, **kwargs) 2281 else: 2282 (data) = self.get_account_information_with_http_info(account_id, **kwargs) 2283 return data 2284 2285 def get_account_information_with_http_info(self, account_id, **kwargs): 2286 """ 2287 Retrieves the account information for the specified account. 2288 Retrieves the account information for the specified account. **Response** The `canUpgrade` property contains is a Boolean that indicates whether the account can be upgraded through the API. 2289 This method makes a synchronous HTTP request by default. To make an 2290 asynchronous HTTP request, please define a `callback` function 2291 to be invoked when receiving the response. 2292 >>> def callback_function(response): 2293 >>> pprint(response) 2294 >>> 2295 >>> thread = api.get_account_information_with_http_info(account_id, callback=callback_function) 2296 2297 :param callback function: The callback function 2298 for asynchronous request. (optional) 2299 :param str account_id: The external account number (int) or account ID Guid. (required) 2300 :param str include_account_settings: When set to **true**, includes the account settings for the account in the response. 2301 :return: AccountInformation 2302 If the method is called asynchronously, 2303 returns the request thread. 2304 """ 2305 2306 all_params = ['account_id', 'include_account_settings'] 2307 all_params.append('callback') 2308 all_params.append('_return_http_data_only') 2309 all_params.append('_preload_content') 2310 all_params.append('_request_timeout') 2311 2312 params = locals() 2313 for key, val in iteritems(params['kwargs']): 2314 if key not in all_params: 2315 raise TypeError( 2316 "Got an unexpected keyword argument '%s'" 2317 " to method get_account_information" % key 2318 ) 2319 params[key] = val 2320 del params['kwargs'] 2321 # verify the required parameter 'account_id' is set 2322 if ('account_id' not in params) or (params['account_id'] is None): 2323 raise ValueError("Missing the required parameter `account_id` when calling `get_account_information`") 2324 2325 2326 collection_formats = {} 2327 2328 resource_path = '/v2.1/accounts/{accountId}'.replace('{format}', 'json') 2329 path_params = {} 2330 if 'account_id' in params: 2331 path_params['accountId'] = params['account_id'] 2332 2333 query_params = {} 2334 if 'include_account_settings' in params: 2335 query_params['include_account_settings'] = params['include_account_settings'] 2336 2337 header_params = {} 2338 2339 form_params = [] 2340 local_var_files = {} 2341 2342 body_params = None 2343 # HTTP header `Accept` 2344 header_params['Accept'] = self.api_client.\ 2345 select_header_accept(['application/json']) 2346 2347 # Authentication setting 2348 auth_settings = [] 2349 2350 return self.api_client.call_api(resource_path, 'GET', 2351 path_params, 2352 query_params, 2353 header_params, 2354 body=body_params, 2355 post_params=form_params, 2356 files=local_var_files, 2357 response_type='AccountInformation', 2358 auth_settings=auth_settings, 2359 callback=params.get('callback'), 2360 _return_http_data_only=params.get('_return_http_data_only'), 2361 _preload_content=params.get('_preload_content', True), 2362 _request_timeout=params.get('_request_timeout'), 2363 collection_formats=collection_formats) 2364 2365 def get_account_signature(self, account_id, signature_id, **kwargs): 2366 """ 2367 Returns information about a single signature by specifed signatureId. 2368 2369 This method makes a synchronous HTTP request by default. To make an 2370 asynchronous HTTP request, please define a `callback` function 2371 to be invoked when receiving the response. 2372 >>> def callback_function(response): 2373 >>> pprint(response) 2374 >>> 2375 >>> thread = api.get_account_signature(account_id, signature_id, callback=callback_function) 2376 2377 :param callback function: The callback function 2378 for asynchronous request. (optional) 2379 :param str account_id: The external account number (int) or account ID Guid. (required) 2380 :param str signature_id: The ID of the signature being accessed. (required) 2381 :return: AccountSignature 2382 If the method is called asynchronously, 2383 returns the request thread. 2384 """ 2385 kwargs['_return_http_data_only'] = True 2386 if kwargs.get('callback'): 2387 return self.get_account_signature_with_http_info(account_id, signature_id, **kwargs) 2388 else: 2389 (data) = self.get_account_signature_with_http_info(account_id, signature_id, **kwargs) 2390 return data 2391 2392 def get_account_signature_with_http_info(self, account_id, signature_id, **kwargs): 2393 """ 2394 Returns information about a single signature by specifed signatureId. 2395 2396 This method makes a synchronous HTTP request by default. To make an 2397 asynchronous HTTP request, please define a `callback` function 2398 to be invoked when receiving the response. 2399 >>> def callback_function(response): 2400 >>> pprint(response) 2401 >>> 2402 >>> thread = api.get_account_signature_with_http_info(account_id, signature_id, callback=callback_function) 2403 2404 :param callback function: The callback function 2405 for asynchronous request. (optional) 2406 :param str account_id: The external account number (int) or account ID Guid. (required) 2407 :param str signature_id: The ID of the signature being accessed. (required) 2408 :return: AccountSignature 2409 If the method is called asynchronously, 2410 returns the request thread. 2411 """ 2412 2413 all_params = ['account_id', 'signature_id'] 2414 all_params.append('callback') 2415 all_params.append('_return_http_data_only') 2416 all_params.append('_preload_content') 2417 all_params.append('_request_timeout') 2418 2419 params = locals() 2420 for key, val in iteritems(params['kwargs']): 2421 if key not in all_params: 2422 raise TypeError( 2423 "Got an unexpected keyword argument '%s'" 2424 " to method get_account_signature" % key 2425 ) 2426 params[key] = val 2427 del params['kwargs'] 2428 # verify the required parameter 'account_id' is set 2429 if ('account_id' not in params) or (params['account_id'] is None): 2430 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signature`") 2431 # verify the required parameter 'signature_id' is set 2432 if ('signature_id' not in params) or (params['signature_id'] is None): 2433 raise ValueError("Missing the required parameter `signature_id` when calling `get_account_signature`") 2434 2435 2436 collection_formats = {} 2437 2438 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 2439 path_params = {} 2440 if 'account_id' in params: 2441 path_params['accountId'] = params['account_id'] 2442 if 'signature_id' in params: 2443 path_params['signatureId'] = params['signature_id'] 2444 2445 query_params = {} 2446 2447 header_params = {} 2448 2449 form_params = [] 2450 local_var_files = {} 2451 2452 body_params = None 2453 # HTTP header `Accept` 2454 header_params['Accept'] = self.api_client.\ 2455 select_header_accept(['application/json']) 2456 2457 # Authentication setting 2458 auth_settings = [] 2459 2460 return self.api_client.call_api(resource_path, 'GET', 2461 path_params, 2462 query_params, 2463 header_params, 2464 body=body_params, 2465 post_params=form_params, 2466 files=local_var_files, 2467 response_type='AccountSignature', 2468 auth_settings=auth_settings, 2469 callback=params.get('callback'), 2470 _return_http_data_only=params.get('_return_http_data_only'), 2471 _preload_content=params.get('_preload_content', True), 2472 _request_timeout=params.get('_request_timeout'), 2473 collection_formats=collection_formats) 2474 2475 def get_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 2476 """ 2477 Returns a signature, initials, or stamps image. 2478 2479 This method makes a synchronous HTTP request by default. To make an 2480 asynchronous HTTP request, please define a `callback` function 2481 to be invoked when receiving the response. 2482 >>> def callback_function(response): 2483 >>> pprint(response) 2484 >>> 2485 >>> thread = api.get_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 2486 2487 :param callback function: The callback function 2488 for asynchronous request. (optional) 2489 :param str account_id: The external account number (int) or account ID Guid. (required) 2490 :param str image_type: One of **signature_image** or **initials_image**. (required) 2491 :param str signature_id: The ID of the signature being accessed. (required) 2492 :param str include_chrome: 2493 :return: file 2494 If the method is called asynchronously, 2495 returns the request thread. 2496 """ 2497 kwargs['_return_http_data_only'] = True 2498 if kwargs.get('callback'): 2499 return self.get_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 2500 else: 2501 (data) = self.get_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 2502 return data 2503 2504 def get_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 2505 """ 2506 Returns a signature, initials, or stamps image. 2507 2508 This method makes a synchronous HTTP request by default. To make an 2509 asynchronous HTTP request, please define a `callback` function 2510 to be invoked when receiving the response. 2511 >>> def callback_function(response): 2512 >>> pprint(response) 2513 >>> 2514 >>> thread = api.get_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 2515 2516 :param callback function: The callback function 2517 for asynchronous request. (optional) 2518 :param str account_id: The external account number (int) or account ID Guid. (required) 2519 :param str image_type: One of **signature_image** or **initials_image**. (required) 2520 :param str signature_id: The ID of the signature being accessed. (required) 2521 :param str include_chrome: 2522 :return: file 2523 If the method is called asynchronously, 2524 returns the request thread. 2525 """ 2526 2527 all_params = ['account_id', 'image_type', 'signature_id', 'include_chrome'] 2528 all_params.append('callback') 2529 all_params.append('_return_http_data_only') 2530 all_params.append('_preload_content') 2531 all_params.append('_request_timeout') 2532 2533 params = locals() 2534 for key, val in iteritems(params['kwargs']): 2535 if key not in all_params: 2536 raise TypeError( 2537 "Got an unexpected keyword argument '%s'" 2538 " to method get_account_signature_image" % key 2539 ) 2540 params[key] = val 2541 del params['kwargs'] 2542 # verify the required parameter 'account_id' is set 2543 if ('account_id' not in params) or (params['account_id'] is None): 2544 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signature_image`") 2545 # verify the required parameter 'image_type' is set 2546 if ('image_type' not in params) or (params['image_type'] is None): 2547 raise ValueError("Missing the required parameter `image_type` when calling `get_account_signature_image`") 2548 # verify the required parameter 'signature_id' is set 2549 if ('signature_id' not in params) or (params['signature_id'] is None): 2550 raise ValueError("Missing the required parameter `signature_id` when calling `get_account_signature_image`") 2551 2552 2553 collection_formats = {} 2554 2555 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 2556 path_params = {} 2557 if 'account_id' in params: 2558 path_params['accountId'] = params['account_id'] 2559 if 'image_type' in params: 2560 path_params['imageType'] = params['image_type'] 2561 if 'signature_id' in params: 2562 path_params['signatureId'] = params['signature_id'] 2563 2564 query_params = {} 2565 if 'include_chrome' in params: 2566 query_params['include_chrome'] = params['include_chrome'] 2567 2568 header_params = {} 2569 2570 form_params = [] 2571 local_var_files = {} 2572 2573 body_params = None 2574 # HTTP header `Accept` 2575 header_params['Accept'] = self.api_client.\ 2576 select_header_accept(['image/gif']) 2577 2578 # Authentication setting 2579 auth_settings = [] 2580 2581 return self.api_client.call_api(resource_path, 'GET', 2582 path_params, 2583 query_params, 2584 header_params, 2585 body=body_params, 2586 post_params=form_params, 2587 files=local_var_files, 2588 response_type='file', 2589 auth_settings=auth_settings, 2590 callback=params.get('callback'), 2591 _return_http_data_only=params.get('_return_http_data_only'), 2592 _preload_content=params.get('_preload_content', True), 2593 _request_timeout=params.get('_request_timeout'), 2594 collection_formats=collection_formats) 2595 2596 def get_account_signatures(self, account_id, **kwargs): 2597 """ 2598 Returns the managed signature definitions for the account 2599 2600 This method makes a synchronous HTTP request by default. To make an 2601 asynchronous HTTP request, please define a `callback` function 2602 to be invoked when receiving the response. 2603 >>> def callback_function(response): 2604 >>> pprint(response) 2605 >>> 2606 >>> thread = api.get_account_signatures(account_id, callback=callback_function) 2607 2608 :param callback function: The callback function 2609 for asynchronous request. (optional) 2610 :param str account_id: The external account number (int) or account ID Guid. (required) 2611 :param str stamp_format: 2612 :param str stamp_name: 2613 :param str stamp_type: 2614 :return: AccountSignaturesInformation 2615 If the method is called asynchronously, 2616 returns the request thread. 2617 """ 2618 kwargs['_return_http_data_only'] = True 2619 if kwargs.get('callback'): 2620 return self.get_account_signatures_with_http_info(account_id, **kwargs) 2621 else: 2622 (data) = self.get_account_signatures_with_http_info(account_id, **kwargs) 2623 return data 2624 2625 def get_account_signatures_with_http_info(self, account_id, **kwargs): 2626 """ 2627 Returns the managed signature definitions for the account 2628 2629 This method makes a synchronous HTTP request by default. To make an 2630 asynchronous HTTP request, please define a `callback` function 2631 to be invoked when receiving the response. 2632 >>> def callback_function(response): 2633 >>> pprint(response) 2634 >>> 2635 >>> thread = api.get_account_signatures_with_http_info(account_id, callback=callback_function) 2636 2637 :param callback function: The callback function 2638 for asynchronous request. (optional) 2639 :param str account_id: The external account number (int) or account ID Guid. (required) 2640 :param str stamp_format: 2641 :param str stamp_name: 2642 :param str stamp_type: 2643 :return: AccountSignaturesInformation 2644 If the method is called asynchronously, 2645 returns the request thread. 2646 """ 2647 2648 all_params = ['account_id', 'stamp_format', 'stamp_name', 'stamp_type'] 2649 all_params.append('callback') 2650 all_params.append('_return_http_data_only') 2651 all_params.append('_preload_content') 2652 all_params.append('_request_timeout') 2653 2654 params = locals() 2655 for key, val in iteritems(params['kwargs']): 2656 if key not in all_params: 2657 raise TypeError( 2658 "Got an unexpected keyword argument '%s'" 2659 " to method get_account_signatures" % key 2660 ) 2661 params[key] = val 2662 del params['kwargs'] 2663 # verify the required parameter 'account_id' is set 2664 if ('account_id' not in params) or (params['account_id'] is None): 2665 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signatures`") 2666 2667 2668 collection_formats = {} 2669 2670 resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json') 2671 path_params = {} 2672 if 'account_id' in params: 2673 path_params['accountId'] = params['account_id'] 2674 2675 query_params = {} 2676 if 'stamp_format' in params: 2677 query_params['stamp_format'] = params['stamp_format'] 2678 if 'stamp_name' in params: 2679 query_params['stamp_name'] = params['stamp_name'] 2680 if 'stamp_type' in params: 2681 query_params['stamp_type'] = params['stamp_type'] 2682 2683 header_params = {} 2684 2685 form_params = [] 2686 local_var_files = {} 2687 2688 body_params = None 2689 # HTTP header `Accept` 2690 header_params['Accept'] = self.api_client.\ 2691 select_header_accept(['application/json']) 2692 2693 # Authentication setting 2694 auth_settings = [] 2695 2696 return self.api_client.call_api(resource_path, 'GET', 2697 path_params, 2698 query_params, 2699 header_params, 2700 body=body_params, 2701 post_params=form_params, 2702 files=local_var_files, 2703 response_type='AccountSignaturesInformation', 2704 auth_settings=auth_settings, 2705 callback=params.get('callback'), 2706 _return_http_data_only=params.get('_return_http_data_only'), 2707 _preload_content=params.get('_preload_content', True), 2708 _request_timeout=params.get('_request_timeout'), 2709 collection_formats=collection_formats) 2710 2711 def get_account_tab_settings(self, account_id, **kwargs): 2712 """ 2713 Returns tab settings list for specified account 2714 This method returns information about the tab types and tab functionality that is currently enabled for an account. 2715 This method makes a synchronous HTTP request by default. To make an 2716 asynchronous HTTP request, please define a `callback` function 2717 to be invoked when receiving the response. 2718 >>> def callback_function(response): 2719 >>> pprint(response) 2720 >>> 2721 >>> thread = api.get_account_tab_settings(account_id, callback=callback_function) 2722 2723 :param callback function: The callback function 2724 for asynchronous request. (optional) 2725 :param str account_id: The external account number (int) or account ID Guid. (required) 2726 :return: TabAccountSettings 2727 If the method is called asynchronously, 2728 returns the request thread. 2729 """ 2730 kwargs['_return_http_data_only'] = True 2731 if kwargs.get('callback'): 2732 return self.get_account_tab_settings_with_http_info(account_id, **kwargs) 2733 else: 2734 (data) = self.get_account_tab_settings_with_http_info(account_id, **kwargs) 2735 return data 2736 2737 def get_account_tab_settings_with_http_info(self, account_id, **kwargs): 2738 """ 2739 Returns tab settings list for specified account 2740 This method returns information about the tab types and tab functionality that is currently enabled for an account. 2741 This method makes a synchronous HTTP request by default. To make an 2742 asynchronous HTTP request, please define a `callback` function 2743 to be invoked when receiving the response. 2744 >>> def callback_function(response): 2745 >>> pprint(response) 2746 >>> 2747 >>> thread = api.get_account_tab_settings_with_http_info(account_id, callback=callback_function) 2748 2749 :param callback function: The callback function 2750 for asynchronous request. (optional) 2751 :param str account_id: The external account number (int) or account ID Guid. (required) 2752 :return: TabAccountSettings 2753 If the method is called asynchronously, 2754 returns the request thread. 2755 """ 2756 2757 all_params = ['account_id'] 2758 all_params.append('callback') 2759 all_params.append('_return_http_data_only') 2760 all_params.append('_preload_content') 2761 all_params.append('_request_timeout') 2762 2763 params = locals() 2764 for key, val in iteritems(params['kwargs']): 2765 if key not in all_params: 2766 raise TypeError( 2767 "Got an unexpected keyword argument '%s'" 2768 " to method get_account_tab_settings" % key 2769 ) 2770 params[key] = val 2771 del params['kwargs'] 2772 # verify the required parameter 'account_id' is set 2773 if ('account_id' not in params) or (params['account_id'] is None): 2774 raise ValueError("Missing the required parameter `account_id` when calling `get_account_tab_settings`") 2775 2776 2777 collection_formats = {} 2778 2779 resource_path = '/v2.1/accounts/{accountId}/settings/tabs'.replace('{format}', 'json') 2780 path_params = {} 2781 if 'account_id' in params: 2782 path_params['accountId'] = params['account_id'] 2783 2784 query_params = {} 2785 2786 header_params = {} 2787 2788 form_params = [] 2789 local_var_files = {} 2790 2791 body_params = None 2792 # HTTP header `Accept` 2793 header_params['Accept'] = self.api_client.\ 2794 select_header_accept(['application/json']) 2795 2796 # Authentication setting 2797 auth_settings = [] 2798 2799 return self.api_client.call_api(resource_path, 'GET', 2800 path_params, 2801 query_params, 2802 header_params, 2803 body=body_params, 2804 post_params=form_params, 2805 files=local_var_files, 2806 response_type='TabAccountSettings', 2807 auth_settings=auth_settings, 2808 callback=params.get('callback'), 2809 _return_http_data_only=params.get('_return_http_data_only'), 2810 _preload_content=params.get('_preload_content', True), 2811 _request_timeout=params.get('_request_timeout'), 2812 collection_formats=collection_formats) 2813 2814 def get_agent_user_authorizations(self, account_id, user_id, **kwargs): 2815 """ 2816 Returns the agent user authorizations 2817 This method makes a synchronous HTTP request by default. To make an 2818 asynchronous HTTP request, please define a `callback` function 2819 to be invoked when receiving the response. 2820 >>> def callback_function(response): 2821 >>> pprint(response) 2822 >>> 2823 >>> thread = api.get_agent_user_authorizations(account_id, user_id, callback=callback_function) 2824 2825 :param callback function: The callback function 2826 for asynchronous request. (optional) 2827 :param str account_id: The external account number (int) or account ID Guid. (required) 2828 :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required) 2829 :param str active_only: 2830 :param str count: 2831 :param str email_substring: Part (substring) of email we are searching for. 2832 :param str include_closed_users: 2833 :param str permissions: 2834 :param str start_position: 2835 :param str user_name_substring: 2836 :return: UserAuthorizations 2837 If the method is called asynchronously, 2838 returns the request thread. 2839 """ 2840 kwargs['_return_http_data_only'] = True 2841 if kwargs.get('callback'): 2842 return self.get_agent_user_authorizations_with_http_info(account_id, user_id, **kwargs) 2843 else: 2844 (data) = self.get_agent_user_authorizations_with_http_info(account_id, user_id, **kwargs) 2845 return data 2846 2847 def get_agent_user_authorizations_with_http_info(self, account_id, user_id, **kwargs): 2848 """ 2849 Returns the agent user authorizations 2850 This method makes a synchronous HTTP request by default. To make an 2851 asynchronous HTTP request, please define a `callback` function 2852 to be invoked when receiving the response. 2853 >>> def callback_function(response): 2854 >>> pprint(response) 2855 >>> 2856 >>> thread = api.get_agent_user_authorizations_with_http_info(account_id, user_id, callback=callback_function) 2857 2858 :param callback function: The callback function 2859 for asynchronous request. (optional) 2860 :param str account_id: The external account number (int) or account ID Guid. (required) 2861 :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required) 2862 :param str active_only: 2863 :param str count: 2864 :param str email_substring: Part (substring) of email we are searching for. 2865 :param str include_closed_users: 2866 :param str permissions: 2867 :param str start_position: 2868 :param str user_name_substring: 2869 :return: UserAuthorizations 2870 If the method is called asynchronously, 2871 returns the request thread. 2872 """ 2873 2874 all_params = ['account_id', 'user_id', 'active_only', 'count', 'email_substring', 'include_closed_users', 'permissions', 'start_position', 'user_name_substring'] 2875 all_params.append('callback') 2876 all_params.append('_return_http_data_only') 2877 all_params.append('_preload_content') 2878 all_params.append('_request_timeout') 2879 2880 params = locals() 2881 for key, val in iteritems(params['kwargs']): 2882 if key not in all_params: 2883 raise TypeError( 2884 "Got an unexpected keyword argument '%s'" 2885 " to method get_agent_user_authorizations" % key 2886 ) 2887 params[key] = val 2888 del params['kwargs'] 2889 # verify the required parameter 'account_id' is set 2890 if ('account_id' not in params) or (params['account_id'] is None): 2891 raise ValueError("Missing the required parameter `account_id` when calling `get_agent_user_authorizations`") 2892 # verify the required parameter 'user_id' is set 2893 if ('user_id' not in params) or (params['user_id'] is None): 2894 raise ValueError("Missing the required parameter `user_id` when calling `get_agent_user_authorizations`") 2895 2896 2897 collection_formats = {} 2898 2899 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorizations/agent'.replace('{format}', 'json') 2900 path_params = {} 2901 if 'account_id' in params: 2902 path_params['accountId'] = params['account_id'] 2903 if 'user_id' in params: 2904 path_params['userId'] = params['user_id'] 2905 2906 query_params = {} 2907 if 'active_only' in params: 2908 query_params['active_only'] = params['active_only'] 2909 if 'count' in params: 2910 query_params['count'] = params['count'] 2911 if 'email_substring' in params: 2912 query_params['email_substring'] = params['email_substring'] 2913 if 'include_closed_users' in params: 2914 query_params['include_closed_users'] = params['include_closed_users'] 2915 if 'permissions' in params: 2916 query_params['permissions'] = params['permissions'] 2917 if 'start_position' in params: 2918 query_params['start_position'] = params['start_position'] 2919 if 'user_name_substring' in params: 2920 query_params['user_name_substring'] = params['user_name_substring'] 2921 2922 header_params = {} 2923 2924 form_params = [] 2925 local_var_files = {} 2926 2927 body_params = None 2928 # HTTP header `Accept` 2929 header_params['Accept'] = self.api_client.\ 2930 select_header_accept(['application/json']) 2931 2932 # Authentication setting 2933 auth_settings = [] 2934 2935 return self.api_client.call_api(resource_path, 'GET', 2936 path_params, 2937 query_params, 2938 header_params, 2939 body=body_params, 2940 post_params=form_params, 2941 files=local_var_files, 2942 response_type='UserAuthorizations', 2943 auth_settings=auth_settings, 2944 callback=params.get('callback'), 2945 _return_http_data_only=params.get('_return_http_data_only'), 2946 _preload_content=params.get('_preload_content', True), 2947 _request_timeout=params.get('_request_timeout'), 2948 collection_formats=collection_formats) 2949 2950 def get_all_payment_gateway_accounts(self, account_id, **kwargs): 2951 """ 2952 Get all payment gateway account for the provided accountId 2953 This method returns a list of payment gateway accounts and basic information about them. 2954 This method makes a synchronous HTTP request by default. To make an 2955 asynchronous HTTP request, please define a `callback` function 2956 to be invoked when receiving the response. 2957 >>> def callback_function(response): 2958 >>> pprint(response) 2959 >>> 2960 >>> thread = api.get_all_payment_gateway_accounts(account_id, callback=callback_function) 2961 2962 :param callback function: The callback function 2963 for asynchronous request. (optional) 2964 :param str account_id: The external account number (int) or account ID Guid. (required) 2965 :return: PaymentGatewayAccountsInfo 2966 If the method is called asynchronously, 2967 returns the request thread. 2968 """ 2969 kwargs['_return_http_data_only'] = True 2970 if kwargs.get('callback'): 2971 return self.get_all_payment_gateway_accounts_with_http_info(account_id, **kwargs) 2972 else: 2973 (data) = self.get_all_payment_gateway_accounts_with_http_info(account_id, **kwargs) 2974 return data 2975 2976 def get_all_payment_gateway_accounts_with_http_info(self, account_id, **kwargs): 2977 """ 2978 Get all payment gateway account for the provided accountId 2979 This method returns a list of payment gateway accounts and basic information about them. 2980 This method makes a synchronous HTTP request by default. To make an 2981 asynchronous HTTP request, please define a `callback` function 2982 to be invoked when receiving the response. 2983 >>> def callback_function(response): 2984 >>> pprint(response) 2985 >>> 2986 >>> thread = api.get_all_payment_gateway_accounts_with_http_info(account_id, callback=callback_function) 2987 2988 :param callback function: The callback function 2989 for asynchronous request. (optional) 2990 :param str account_id: The external account number (int) or account ID Guid. (required) 2991 :return: PaymentGatewayAccountsInfo 2992 If the method is called asynchronously, 2993 returns the request thread. 2994 """ 2995 2996 all_params = ['account_id'] 2997 all_params.append('callback') 2998 all_params.append('_return_http_data_only') 2999 all_params.append('_preload_content') 3000 all_params.append('_request_timeout') 3001 3002 params = locals() 3003 for key, val in iteritems(params['kwargs']): 3004 if key not in all_params: 3005 raise TypeError( 3006 "Got an unexpected keyword argument '%s'" 3007 " to method get_all_payment_gateway_accounts" % key 3008 ) 3009 params[key] = val 3010 del params['kwargs'] 3011 # verify the required parameter 'account_id' is set 3012 if ('account_id' not in params) or (params['account_id'] is None): 3013 raise ValueError("Missing the required parameter `account_id` when calling `get_all_payment_gateway_accounts`") 3014 3015 3016 collection_formats = {} 3017 3018 resource_path = '/v2.1/accounts/{accountId}/payment_gateway_accounts'.replace('{format}', 'json') 3019 path_params = {} 3020 if 'account_id' in params: 3021 path_params['accountId'] = params['account_id'] 3022 3023 query_params = {} 3024 3025 header_params = {} 3026 3027 form_params = [] 3028 local_var_files = {} 3029 3030 body_params = None 3031 # HTTP header `Accept` 3032 header_params['Accept'] = self.api_client.\ 3033 select_header_accept(['application/json']) 3034 3035 # Authentication setting 3036 auth_settings = [] 3037 3038 return self.api_client.call_api(resource_path, 'GET', 3039 path_params, 3040 query_params, 3041 header_params, 3042 body=body_params, 3043 post_params=form_params, 3044 files=local_var_files, 3045 response_type='PaymentGatewayAccountsInfo', 3046 auth_settings=auth_settings, 3047 callback=params.get('callback'), 3048 _return_http_data_only=params.get('_return_http_data_only'), 3049 _preload_content=params.get('_preload_content', True), 3050 _request_timeout=params.get('_request_timeout'), 3051 collection_formats=collection_formats) 3052 3053 def get_billing_charges(self, account_id, **kwargs): 3054 """ 3055 Gets list of recurring and usage charges for the account. 3056 Retrieves the list of recurring and usage charges for the account. This can be used to determine the charge structure and usage of charge plan items. Privileges required: account administrator 3057 This method makes a synchronous HTTP request by default. To make an 3058 asynchronous HTTP request, please define a `callback` function 3059 to be invoked when receiving the response. 3060 >>> def callback_function(response): 3061 >>> pprint(response) 3062 >>> 3063 >>> thread = api.get_billing_charges(account_id, callback=callback_function) 3064 3065 :param callback function: The callback function 3066 for asynchronous request. (optional) 3067 :param str account_id: The external account number (int) or account ID Guid. (required) 3068 :param str include_charges: Specifies which billing charges to return. Valid values are: * envelopes * seats 3069 :return: BillingChargeResponse 3070 If the method is called asynchronously, 3071 returns the request thread. 3072 """ 3073 kwargs['_return_http_data_only'] = True 3074 if kwargs.get('callback'): 3075 return self.get_billing_charges_with_http_info(account_id, **kwargs) 3076 else: 3077 (data) = self.get_billing_charges_with_http_info(account_id, **kwargs) 3078 return data 3079 3080 def get_billing_charges_with_http_info(self, account_id, **kwargs): 3081 """ 3082 Gets list of recurring and usage charges for the account. 3083 Retrieves the list of recurring and usage charges for the account. This can be used to determine the charge structure and usage of charge plan items. Privileges required: account administrator 3084 This method makes a synchronous HTTP request by default. To make an 3085 asynchronous HTTP request, please define a `callback` function 3086 to be invoked when receiving the response. 3087 >>> def callback_function(response): 3088 >>> pprint(response) 3089 >>> 3090 >>> thread = api.get_billing_charges_with_http_info(account_id, callback=callback_function) 3091 3092 :param callback function: The callback function 3093 for asynchronous request. (optional) 3094 :param str account_id: The external account number (int) or account ID Guid. (required) 3095 :param str include_charges: Specifies which billing charges to return. Valid values are: * envelopes * seats 3096 :return: BillingChargeResponse 3097 If the method is called asynchronously, 3098 returns the request thread. 3099 """ 3100 3101 all_params = ['account_id', 'include_charges'] 3102 all_params.append('callback') 3103 all_params.append('_return_http_data_only') 3104 all_params.append('_preload_content') 3105 all_params.append('_request_timeout') 3106 3107 params = locals() 3108 for key, val in iteritems(params['kwargs']): 3109 if key not in all_params: 3110 raise TypeError( 3111 "Got an unexpected keyword argument '%s'" 3112 " to method get_billing_charges" % key 3113 ) 3114 params[key] = val 3115 del params['kwargs'] 3116 # verify the required parameter 'account_id' is set 3117 if ('account_id' not in params) or (params['account_id'] is None): 3118 raise ValueError("Missing the required parameter `account_id` when calling `get_billing_charges`") 3119 3120 3121 collection_formats = {} 3122 3123 resource_path = '/v2.1/accounts/{accountId}/billing_charges'.replace('{format}', 'json') 3124 path_params = {} 3125 if 'account_id' in params: 3126 path_params['accountId'] = params['account_id'] 3127 3128 query_params = {} 3129 if 'include_charges' in params: 3130 query_params['include_charges'] = params['include_charges'] 3131 3132 header_params = {} 3133 3134 form_params = [] 3135 local_var_files = {} 3136 3137 body_params = None 3138 # HTTP header `Accept` 3139 header_params['Accept'] = self.api_client.\ 3140 select_header_accept(['application/json']) 3141 3142 # Authentication setting 3143 auth_settings = [] 3144 3145 return self.api_client.call_api(resource_path, 'GET', 3146 path_params, 3147 query_params, 3148 header_params, 3149 body=body_params, 3150 post_params=form_params, 3151 files=local_var_files, 3152 response_type='BillingChargeResponse', 3153 auth_settings=auth_settings, 3154 callback=params.get('callback'), 3155 _return_http_data_only=params.get('_return_http_data_only'), 3156 _preload_content=params.get('_preload_content', True), 3157 _request_timeout=params.get('_request_timeout'), 3158 collection_formats=collection_formats) 3159 3160 def get_brand(self, account_id, brand_id, **kwargs): 3161 """ 3162 Get information for a specific brand. 3163 This method returns details about an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 3164 This method makes a synchronous HTTP request by default. To make an 3165 asynchronous HTTP request, please define a `callback` function 3166 to be invoked when receiving the response. 3167 >>> def callback_function(response): 3168 >>> pprint(response) 3169 >>> 3170 >>> thread = api.get_brand(account_id, brand_id, callback=callback_function) 3171 3172 :param callback function: The callback function 3173 for asynchronous request. (optional) 3174 :param str account_id: The external account number (int) or account ID Guid. (required) 3175 :param str brand_id: The unique identifier of a brand. (required) 3176 :param str include_external_references: 3177 :param str include_logos: 3178 :return: Brand 3179 If the method is called asynchronously, 3180 returns the request thread. 3181 """ 3182 kwargs['_return_http_data_only'] = True 3183 if kwargs.get('callback'): 3184 return self.get_brand_with_http_info(account_id, brand_id, **kwargs) 3185 else: 3186 (data) = self.get_brand_with_http_info(account_id, brand_id, **kwargs) 3187 return data 3188 3189 def get_brand_with_http_info(self, account_id, brand_id, **kwargs): 3190 """ 3191 Get information for a specific brand. 3192 This method returns details about an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 3193 This method makes a synchronous HTTP request by default. To make an 3194 asynchronous HTTP request, please define a `callback` function 3195 to be invoked when receiving the response. 3196 >>> def callback_function(response): 3197 >>> pprint(response) 3198 >>> 3199 >>> thread = api.get_brand_with_http_info(account_id, brand_id, callback=callback_function) 3200 3201 :param callback function: The callback function 3202 for asynchronous request. (optional) 3203 :param str account_id: The external account number (int) or account ID Guid. (required) 3204 :param str brand_id: The unique identifier of a brand. (required) 3205 :param str include_external_references: 3206 :param str include_logos: 3207 :return: Brand 3208 If the method is called asynchronously, 3209 returns the request thread. 3210 """ 3211 3212 all_params = ['account_id', 'brand_id', 'include_external_references', 'include_logos'] 3213 all_params.append('callback') 3214 all_params.append('_return_http_data_only') 3215 all_params.append('_preload_content') 3216 all_params.append('_request_timeout') 3217 3218 params = locals() 3219 for key, val in iteritems(params['kwargs']): 3220 if key not in all_params: 3221 raise TypeError( 3222 "Got an unexpected keyword argument '%s'" 3223 " to method get_brand" % key 3224 ) 3225 params[key] = val 3226 del params['kwargs'] 3227 # verify the required parameter 'account_id' is set 3228 if ('account_id' not in params) or (params['account_id'] is None): 3229 raise ValueError("Missing the required parameter `account_id` when calling `get_brand`") 3230 # verify the required parameter 'brand_id' is set 3231 if ('brand_id' not in params) or (params['brand_id'] is None): 3232 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand`") 3233 3234 3235 collection_formats = {} 3236 3237 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 3238 path_params = {} 3239 if 'account_id' in params: 3240 path_params['accountId'] = params['account_id'] 3241 if 'brand_id' in params: 3242 path_params['brandId'] = params['brand_id'] 3243 3244 query_params = {} 3245 if 'include_external_references' in params: 3246 query_params['include_external_references'] = params['include_external_references'] 3247 if 'include_logos' in params: 3248 query_params['include_logos'] = params['include_logos'] 3249 3250 header_params = {} 3251 3252 form_params = [] 3253 local_var_files = {} 3254 3255 body_params = None 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, 'GET', 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='Brand', 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 get_brand_export_file(self, account_id, brand_id, **kwargs): 3279 """ 3280 Export a specific brand. 3281 This method exports information about a brand to an XML file. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 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.get_brand_export_file(account_id, brand_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 brand_id: The unique identifier of a brand. (required) 3294 :return: None 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.get_brand_export_file_with_http_info(account_id, brand_id, **kwargs) 3301 else: 3302 (data) = self.get_brand_export_file_with_http_info(account_id, brand_id, **kwargs) 3303 return data 3304 3305 def get_brand_export_file_with_http_info(self, account_id, brand_id, **kwargs): 3306 """ 3307 Export a specific brand. 3308 This method exports information about a brand to an XML file. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 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.get_brand_export_file_with_http_info(account_id, brand_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 brand_id: The unique identifier of a brand. (required) 3321 :return: None 3322 If the method is called asynchronously, 3323 returns the request thread. 3324 """ 3325 3326 all_params = ['account_id', 'brand_id'] 3327 all_params.append('callback') 3328 all_params.append('_return_http_data_only') 3329 all_params.append('_preload_content') 3330 all_params.append('_request_timeout') 3331 3332 params = locals() 3333 for key, val in iteritems(params['kwargs']): 3334 if key not in all_params: 3335 raise TypeError( 3336 "Got an unexpected keyword argument '%s'" 3337 " to method get_brand_export_file" % key 3338 ) 3339 params[key] = val 3340 del params['kwargs'] 3341 # verify the required parameter 'account_id' is set 3342 if ('account_id' not in params) or (params['account_id'] is None): 3343 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_export_file`") 3344 # verify the required parameter 'brand_id' is set 3345 if ('brand_id' not in params) or (params['brand_id'] is None): 3346 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_export_file`") 3347 3348 3349 collection_formats = {} 3350 3351 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/file'.replace('{format}', 'json') 3352 path_params = {} 3353 if 'account_id' in params: 3354 path_params['accountId'] = params['account_id'] 3355 if 'brand_id' in params: 3356 path_params['brandId'] = params['brand_id'] 3357 3358 query_params = {} 3359 3360 header_params = {} 3361 3362 form_params = [] 3363 local_var_files = {} 3364 3365 body_params = None 3366 # HTTP header `Accept` 3367 header_params['Accept'] = self.api_client.\ 3368 select_header_accept(['application/json']) 3369 3370 # Authentication setting 3371 auth_settings = [] 3372 3373 return self.api_client.call_api(resource_path, 'GET', 3374 path_params, 3375 query_params, 3376 header_params, 3377 body=body_params, 3378 post_params=form_params, 3379 files=local_var_files, 3380 response_type=None, 3381 auth_settings=auth_settings, 3382 callback=params.get('callback'), 3383 _return_http_data_only=params.get('_return_http_data_only'), 3384 _preload_content=params.get('_preload_content', True), 3385 _request_timeout=params.get('_request_timeout'), 3386 collection_formats=collection_formats) 3387 3388 def get_brand_logo_by_type(self, account_id, brand_id, logo_type, **kwargs): 3389 """ 3390 Obtains the specified image for a brand. 3391 This method returns a specific logo that is used in a brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 3392 This method makes a synchronous HTTP request by default. To make an 3393 asynchronous HTTP request, please define a `callback` function 3394 to be invoked when receiving the response. 3395 >>> def callback_function(response): 3396 >>> pprint(response) 3397 >>> 3398 >>> thread = api.get_brand_logo_by_type(account_id, brand_id, logo_type, callback=callback_function) 3399 3400 :param callback function: The callback function 3401 for asynchronous request. (optional) 3402 :param str account_id: The external account number (int) or account ID Guid. (required) 3403 :param str brand_id: The unique identifier of a brand. (required) 3404 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 3405 :return: file 3406 If the method is called asynchronously, 3407 returns the request thread. 3408 """ 3409 kwargs['_return_http_data_only'] = True 3410 if kwargs.get('callback'): 3411 return self.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 3412 else: 3413 (data) = self.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 3414 return data 3415 3416 def get_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, **kwargs): 3417 """ 3418 Obtains the specified image for a brand. 3419 This method returns a specific logo that is used in a brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 3420 This method makes a synchronous HTTP request by default. To make an 3421 asynchronous HTTP request, please define a `callback` function 3422 to be invoked when receiving the response. 3423 >>> def callback_function(response): 3424 >>> pprint(response) 3425 >>> 3426 >>> thread = api.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, callback=callback_function) 3427 3428 :param callback function: The callback function 3429 for asynchronous request. (optional) 3430 :param str account_id: The external account number (int) or account ID Guid. (required) 3431 :param str brand_id: The unique identifier of a brand. (required) 3432 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 3433 :return: file 3434 If the method is called asynchronously, 3435 returns the request thread. 3436 """ 3437 3438 all_params = ['account_id', 'brand_id', 'logo_type'] 3439 all_params.append('callback') 3440 all_params.append('_return_http_data_only') 3441 all_params.append('_preload_content') 3442 all_params.append('_request_timeout') 3443 3444 params = locals() 3445 for key, val in iteritems(params['kwargs']): 3446 if key not in all_params: 3447 raise TypeError( 3448 "Got an unexpected keyword argument '%s'" 3449 " to method get_brand_logo_by_type" % key 3450 ) 3451 params[key] = val 3452 del params['kwargs'] 3453 # verify the required parameter 'account_id' is set 3454 if ('account_id' not in params) or (params['account_id'] is None): 3455 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_logo_by_type`") 3456 # verify the required parameter 'brand_id' is set 3457 if ('brand_id' not in params) or (params['brand_id'] is None): 3458 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_logo_by_type`") 3459 # verify the required parameter 'logo_type' is set 3460 if ('logo_type' not in params) or (params['logo_type'] is None): 3461 raise ValueError("Missing the required parameter `logo_type` when calling `get_brand_logo_by_type`") 3462 3463 3464 collection_formats = {} 3465 3466 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 3467 path_params = {} 3468 if 'account_id' in params: 3469 path_params['accountId'] = params['account_id'] 3470 if 'brand_id' in params: 3471 path_params['brandId'] = params['brand_id'] 3472 if 'logo_type' in params: 3473 path_params['logoType'] = params['logo_type'] 3474 3475 query_params = {} 3476 3477 header_params = {} 3478 3479 form_params = [] 3480 local_var_files = {} 3481 3482 body_params = None 3483 # HTTP header `Accept` 3484 header_params['Accept'] = self.api_client.\ 3485 select_header_accept(['image/png']) 3486 3487 # Authentication setting 3488 auth_settings = [] 3489 3490 return self.api_client.call_api(resource_path, 'GET', 3491 path_params, 3492 query_params, 3493 header_params, 3494 body=body_params, 3495 post_params=form_params, 3496 files=local_var_files, 3497 response_type='file', 3498 auth_settings=auth_settings, 3499 callback=params.get('callback'), 3500 _return_http_data_only=params.get('_return_http_data_only'), 3501 _preload_content=params.get('_preload_content', True), 3502 _request_timeout=params.get('_request_timeout'), 3503 collection_formats=collection_formats) 3504 3505 def get_brand_resources(self, account_id, brand_id, **kwargs): 3506 """ 3507 Returns the specified account's list of branding resources (metadata). 3508 This method returns metadata about the branding resources that are associated with an account. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 3509 This method makes a synchronous HTTP request by default. To make an 3510 asynchronous HTTP request, please define a `callback` function 3511 to be invoked when receiving the response. 3512 >>> def callback_function(response): 3513 >>> pprint(response) 3514 >>> 3515 >>> thread = api.get_brand_resources(account_id, brand_id, callback=callback_function) 3516 3517 :param callback function: The callback function 3518 for asynchronous request. (optional) 3519 :param str account_id: The external account number (int) or account ID Guid. (required) 3520 :param str brand_id: The unique identifier of a brand. (required) 3521 :return: BrandResourcesList 3522 If the method is called asynchronously, 3523 returns the request thread. 3524 """ 3525 kwargs['_return_http_data_only'] = True 3526 if kwargs.get('callback'): 3527 return self.get_brand_resources_with_http_info(account_id, brand_id, **kwargs) 3528 else: 3529 (data) = self.get_brand_resources_with_http_info(account_id, brand_id, **kwargs) 3530 return data 3531 3532 def get_brand_resources_with_http_info(self, account_id, brand_id, **kwargs): 3533 """ 3534 Returns the specified account's list of branding resources (metadata). 3535 This method returns metadata about the branding resources that are associated with an account. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 3536 This method makes a synchronous HTTP request by default. To make an 3537 asynchronous HTTP request, please define a `callback` function 3538 to be invoked when receiving the response. 3539 >>> def callback_function(response): 3540 >>> pprint(response) 3541 >>> 3542 >>> thread = api.get_brand_resources_with_http_info(account_id, brand_id, callback=callback_function) 3543 3544 :param callback function: The callback function 3545 for asynchronous request. (optional) 3546 :param str account_id: The external account number (int) or account ID Guid. (required) 3547 :param str brand_id: The unique identifier of a brand. (required) 3548 :return: BrandResourcesList 3549 If the method is called asynchronously, 3550 returns the request thread. 3551 """ 3552 3553 all_params = ['account_id', 'brand_id'] 3554 all_params.append('callback') 3555 all_params.append('_return_http_data_only') 3556 all_params.append('_preload_content') 3557 all_params.append('_request_timeout') 3558 3559 params = locals() 3560 for key, val in iteritems(params['kwargs']): 3561 if key not in all_params: 3562 raise TypeError( 3563 "Got an unexpected keyword argument '%s'" 3564 " to method get_brand_resources" % key 3565 ) 3566 params[key] = val 3567 del params['kwargs'] 3568 # verify the required parameter 'account_id' is set 3569 if ('account_id' not in params) or (params['account_id'] is None): 3570 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_resources`") 3571 # verify the required parameter 'brand_id' is set 3572 if ('brand_id' not in params) or (params['brand_id'] is None): 3573 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_resources`") 3574 3575 3576 collection_formats = {} 3577 3578 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources'.replace('{format}', 'json') 3579 path_params = {} 3580 if 'account_id' in params: 3581 path_params['accountId'] = params['account_id'] 3582 if 'brand_id' in params: 3583 path_params['brandId'] = params['brand_id'] 3584 3585 query_params = {} 3586 3587 header_params = {} 3588 3589 form_params = [] 3590 local_var_files = {} 3591 3592 body_params = None 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, 'GET', 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='BrandResourcesList', 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 get_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, **kwargs): 3616 """ 3617 Returns the specified branding resource file. 3618 This method returns a specific branding resource file. A brand uses a set of brand resource files to control the sending, signing, email message, and captive (embedded) signing experiences. You can modify the default email messages and formats in these files and upload them to your brand to customize the user experience. **Important:** When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 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.get_brand_resources_by_content_type(account_id, brand_id, resource_content_type, 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 brand_id: The unique identifier of a brand. (required) 3631 :param str resource_content_type: (required) 3632 :param str langcode: 3633 :param str return_master: 3634 :return: None 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.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, **kwargs) 3641 else: 3642 (data) = self.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, **kwargs) 3643 return data 3644 3645 def get_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, **kwargs): 3646 """ 3647 Returns the specified branding resource file. 3648 This method returns a specific branding resource file. A brand uses a set of brand resource files to control the sending, signing, email message, and captive (embedded) signing experiences. You can modify the default email messages and formats in these files and upload them to your brand to customize the user experience. **Important:** When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 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.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, 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 brand_id: The unique identifier of a brand. (required) 3661 :param str resource_content_type: (required) 3662 :param str langcode: 3663 :param str return_master: 3664 :return: None 3665 If the method is called asynchronously, 3666 returns the request thread. 3667 """ 3668 3669 all_params = ['account_id', 'brand_id', 'resource_content_type', 'langcode', 'return_master'] 3670 all_params.append('callback') 3671 all_params.append('_return_http_data_only') 3672 all_params.append('_preload_content') 3673 all_params.append('_request_timeout') 3674 3675 params = locals() 3676 for key, val in iteritems(params['kwargs']): 3677 if key not in all_params: 3678 raise TypeError( 3679 "Got an unexpected keyword argument '%s'" 3680 " to method get_brand_resources_by_content_type" % key 3681 ) 3682 params[key] = val 3683 del params['kwargs'] 3684 # verify the required parameter 'account_id' is set 3685 if ('account_id' not in params) or (params['account_id'] is None): 3686 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_resources_by_content_type`") 3687 # verify the required parameter 'brand_id' is set 3688 if ('brand_id' not in params) or (params['brand_id'] is None): 3689 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_resources_by_content_type`") 3690 # verify the required parameter 'resource_content_type' is set 3691 if ('resource_content_type' not in params) or (params['resource_content_type'] is None): 3692 raise ValueError("Missing the required parameter `resource_content_type` when calling `get_brand_resources_by_content_type`") 3693 3694 3695 collection_formats = {} 3696 3697 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources/{resourceContentType}'.replace('{format}', 'json') 3698 path_params = {} 3699 if 'account_id' in params: 3700 path_params['accountId'] = params['account_id'] 3701 if 'brand_id' in params: 3702 path_params['brandId'] = params['brand_id'] 3703 if 'resource_content_type' in params: 3704 path_params['resourceContentType'] = params['resource_content_type'] 3705 3706 query_params = {} 3707 if 'langcode' in params: 3708 query_params['langcode'] = params['langcode'] 3709 if 'return_master' in params: 3710 query_params['return_master'] = params['return_master'] 3711 3712 header_params = {} 3713 3714 form_params = [] 3715 local_var_files = {} 3716 3717 body_params = None 3718 # HTTP header `Accept` 3719 header_params['Accept'] = self.api_client.\ 3720 select_header_accept(['application/json']) 3721 3722 # Authentication setting 3723 auth_settings = [] 3724 3725 return self.api_client.call_api(resource_path, 'GET', 3726 path_params, 3727 query_params, 3728 header_params, 3729 body=body_params, 3730 post_params=form_params, 3731 files=local_var_files, 3732 response_type=None, 3733 auth_settings=auth_settings, 3734 callback=params.get('callback'), 3735 _return_http_data_only=params.get('_return_http_data_only'), 3736 _preload_content=params.get('_preload_content', True), 3737 _request_timeout=params.get('_request_timeout'), 3738 collection_formats=collection_formats) 3739 3740 def get_consumer_disclosure(self, account_id, lang_code, **kwargs): 3741 """ 3742 Gets the Electronic Record and Signature Disclosure. 3743 Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, for the requested envelope recipient. This might be different than the current account disclosure depending on account settings, such as branding, and when the account disclosure was last updated. An optional query string can be included to return the language for the disclosure. 3744 This method makes a synchronous HTTP request by default. To make an 3745 asynchronous HTTP request, please define a `callback` function 3746 to be invoked when receiving the response. 3747 >>> def callback_function(response): 3748 >>> pprint(response) 3749 >>> 3750 >>> thread = api.get_consumer_disclosure(account_id, lang_code, callback=callback_function) 3751 3752 :param callback function: The callback function 3753 for asynchronous request. (optional) 3754 :param str account_id: The external account number (int) or account ID Guid. (required) 3755 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 3756 :return: ConsumerDisclosure 3757 If the method is called asynchronously, 3758 returns the request thread. 3759 """ 3760 kwargs['_return_http_data_only'] = True 3761 if kwargs.get('callback'): 3762 return self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 3763 else: 3764 (data) = self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 3765 return data 3766 3767 def get_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs): 3768 """ 3769 Gets the Electronic Record and Signature Disclosure. 3770 Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, for the requested envelope recipient. This might be different than the current account disclosure depending on account settings, such as branding, and when the account disclosure was last updated. An optional query string can be included to return the language for the disclosure. 3771 This method makes a synchronous HTTP request by default. To make an 3772 asynchronous HTTP request, please define a `callback` function 3773 to be invoked when receiving the response. 3774 >>> def callback_function(response): 3775 >>> pprint(response) 3776 >>> 3777 >>> thread = api.get_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function) 3778 3779 :param callback function: The callback function 3780 for asynchronous request. (optional) 3781 :param str account_id: The external account number (int) or account ID Guid. (required) 3782 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 3783 :return: ConsumerDisclosure 3784 If the method is called asynchronously, 3785 returns the request thread. 3786 """ 3787 3788 all_params = ['account_id', 'lang_code'] 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 get_consumer_disclosure" % 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 `get_consumer_disclosure`") 3806 # verify the required parameter 'lang_code' is set 3807 if ('lang_code' not in params) or (params['lang_code'] is None): 3808 raise ValueError("Missing the required parameter `lang_code` when calling `get_consumer_disclosure`") 3809 3810 3811 collection_formats = {} 3812 3813 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 3814 path_params = {} 3815 if 'account_id' in params: 3816 path_params['accountId'] = params['account_id'] 3817 if 'lang_code' in params: 3818 path_params['langCode'] = params['lang_code'] 3819 3820 query_params = {} 3821 3822 header_params = {} 3823 3824 form_params = [] 3825 local_var_files = {} 3826 3827 body_params = None 3828 # HTTP header `Accept` 3829 header_params['Accept'] = self.api_client.\ 3830 select_header_accept(['application/json']) 3831 3832 # Authentication setting 3833 auth_settings = [] 3834 3835 return self.api_client.call_api(resource_path, 'GET', 3836 path_params, 3837 query_params, 3838 header_params, 3839 body=body_params, 3840 post_params=form_params, 3841 files=local_var_files, 3842 response_type='ConsumerDisclosure', 3843 auth_settings=auth_settings, 3844 callback=params.get('callback'), 3845 _return_http_data_only=params.get('_return_http_data_only'), 3846 _preload_content=params.get('_preload_content', True), 3847 _request_timeout=params.get('_request_timeout'), 3848 collection_formats=collection_formats) 3849 3850 def get_consumer_disclosure_default(self, account_id, **kwargs): 3851 """ 3852 Gets the Electronic Record and Signature Disclosure for the account. 3853 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. 3854 This method makes a synchronous HTTP request by default. To make an 3855 asynchronous HTTP request, please define a `callback` function 3856 to be invoked when receiving the response. 3857 >>> def callback_function(response): 3858 >>> pprint(response) 3859 >>> 3860 >>> thread = api.get_consumer_disclosure_default(account_id, callback=callback_function) 3861 3862 :param callback function: The callback function 3863 for asynchronous request. (optional) 3864 :param str account_id: The external account number (int) or account ID Guid. (required) 3865 :param str lang_code: Specifies 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. 3866 :return: ConsumerDisclosure 3867 If the method is called asynchronously, 3868 returns the request thread. 3869 """ 3870 kwargs['_return_http_data_only'] = True 3871 if kwargs.get('callback'): 3872 return self.get_consumer_disclosure_default_with_http_info(account_id, **kwargs) 3873 else: 3874 (data) = self.get_consumer_disclosure_default_with_http_info(account_id, **kwargs) 3875 return data 3876 3877 def get_consumer_disclosure_default_with_http_info(self, account_id, **kwargs): 3878 """ 3879 Gets the Electronic Record and Signature Disclosure for the account. 3880 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. 3881 This method makes a synchronous HTTP request by default. To make an 3882 asynchronous HTTP request, please define a `callback` function 3883 to be invoked when receiving the response. 3884 >>> def callback_function(response): 3885 >>> pprint(response) 3886 >>> 3887 >>> thread = api.get_consumer_disclosure_default_with_http_info(account_id, callback=callback_function) 3888 3889 :param callback function: The callback function 3890 for asynchronous request. (optional) 3891 :param str account_id: The external account number (int) or account ID Guid. (required) 3892 :param str lang_code: Specifies 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. 3893 :return: ConsumerDisclosure 3894 If the method is called asynchronously, 3895 returns the request thread. 3896 """ 3897 3898 all_params = ['account_id', 'lang_code'] 3899 all_params.append('callback') 3900 all_params.append('_return_http_data_only') 3901 all_params.append('_preload_content') 3902 all_params.append('_request_timeout') 3903 3904 params = locals() 3905 for key, val in iteritems(params['kwargs']): 3906 if key not in all_params: 3907 raise TypeError( 3908 "Got an unexpected keyword argument '%s'" 3909 " to method get_consumer_disclosure_default" % key 3910 ) 3911 params[key] = val 3912 del params['kwargs'] 3913 # verify the required parameter 'account_id' is set 3914 if ('account_id' not in params) or (params['account_id'] is None): 3915 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure_default`") 3916 3917 3918 collection_formats = {} 3919 3920 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure'.replace('{format}', 'json') 3921 path_params = {} 3922 if 'account_id' in params: 3923 path_params['accountId'] = params['account_id'] 3924 3925 query_params = {} 3926 if 'lang_code' in params: 3927 query_params['langCode'] = params['lang_code'] 3928 3929 header_params = {} 3930 3931 form_params = [] 3932 local_var_files = {} 3933 3934 body_params = None 3935 # HTTP header `Accept` 3936 header_params['Accept'] = self.api_client.\ 3937 select_header_accept(['application/json']) 3938 3939 # Authentication setting 3940 auth_settings = [] 3941 3942 return self.api_client.call_api(resource_path, 'GET', 3943 path_params, 3944 query_params, 3945 header_params, 3946 body=body_params, 3947 post_params=form_params, 3948 files=local_var_files, 3949 response_type='ConsumerDisclosure', 3950 auth_settings=auth_settings, 3951 callback=params.get('callback'), 3952 _return_http_data_only=params.get('_return_http_data_only'), 3953 _preload_content=params.get('_preload_content', True), 3954 _request_timeout=params.get('_request_timeout'), 3955 collection_formats=collection_formats) 3956 3957 def get_e_note_configuration(self, account_id, **kwargs): 3958 """ 3959 Returns the configuration information for the eNote eOriginal integration. 3960 3961 This method makes a synchronous HTTP request by default. To make an 3962 asynchronous HTTP request, please define a `callback` function 3963 to be invoked when receiving the response. 3964 >>> def callback_function(response): 3965 >>> pprint(response) 3966 >>> 3967 >>> thread = api.get_e_note_configuration(account_id, callback=callback_function) 3968 3969 :param callback function: The callback function 3970 for asynchronous request. (optional) 3971 :param str account_id: The external account number (int) or account ID Guid. (required) 3972 :return: ENoteConfiguration 3973 If the method is called asynchronously, 3974 returns the request thread. 3975 """ 3976 kwargs['_return_http_data_only'] = True 3977 if kwargs.get('callback'): 3978 return self.get_e_note_configuration_with_http_info(account_id, **kwargs) 3979 else: 3980 (data) = self.get_e_note_configuration_with_http_info(account_id, **kwargs) 3981 return data 3982 3983 def get_e_note_configuration_with_http_info(self, account_id, **kwargs): 3984 """ 3985 Returns the configuration information for the eNote eOriginal integration. 3986 3987 This method makes a synchronous HTTP request by default. To make an 3988 asynchronous HTTP request, please define a `callback` function 3989 to be invoked when receiving the response. 3990 >>> def callback_function(response): 3991 >>> pprint(response) 3992 >>> 3993 >>> thread = api.get_e_note_configuration_with_http_info(account_id, callback=callback_function) 3994 3995 :param callback function: The callback function 3996 for asynchronous request. (optional) 3997 :param str account_id: The external account number (int) or account ID Guid. (required) 3998 :return: ENoteConfiguration 3999 If the method is called asynchronously, 4000 returns the request thread. 4001 """ 4002 4003 all_params = ['account_id'] 4004 all_params.append('callback') 4005 all_params.append('_return_http_data_only') 4006 all_params.append('_preload_content') 4007 all_params.append('_request_timeout') 4008 4009 params = locals() 4010 for key, val in iteritems(params['kwargs']): 4011 if key not in all_params: 4012 raise TypeError( 4013 "Got an unexpected keyword argument '%s'" 4014 " to method get_e_note_configuration" % key 4015 ) 4016 params[key] = val 4017 del params['kwargs'] 4018 # verify the required parameter 'account_id' is set 4019 if ('account_id' not in params) or (params['account_id'] is None): 4020 raise ValueError("Missing the required parameter `account_id` when calling `get_e_note_configuration`") 4021 4022 4023 collection_formats = {} 4024 4025 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 4026 path_params = {} 4027 if 'account_id' in params: 4028 path_params['accountId'] = params['account_id'] 4029 4030 query_params = {} 4031 4032 header_params = {} 4033 4034 form_params = [] 4035 local_var_files = {} 4036 4037 body_params = None 4038 # HTTP header `Accept` 4039 header_params['Accept'] = self.api_client.\ 4040 select_header_accept(['application/json']) 4041 4042 # Authentication setting 4043 auth_settings = [] 4044 4045 return self.api_client.call_api(resource_path, 'GET', 4046 path_params, 4047 query_params, 4048 header_params, 4049 body=body_params, 4050 post_params=form_params, 4051 files=local_var_files, 4052 response_type='ENoteConfiguration', 4053 auth_settings=auth_settings, 4054 callback=params.get('callback'), 4055 _return_http_data_only=params.get('_return_http_data_only'), 4056 _preload_content=params.get('_preload_content', True), 4057 _request_timeout=params.get('_request_timeout'), 4058 collection_formats=collection_formats) 4059 4060 def get_envelope_purge_configuration(self, account_id, **kwargs): 4061 """ 4062 Select envelope purge configuration. 4063 An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method retrieves the current envelope purge configuration for your account. **Note:** To use this method, you must be an account administrator. 4064 This method makes a synchronous HTTP request by default. To make an 4065 asynchronous HTTP request, please define a `callback` function 4066 to be invoked when receiving the response. 4067 >>> def callback_function(response): 4068 >>> pprint(response) 4069 >>> 4070 >>> thread = api.get_envelope_purge_configuration(account_id, callback=callback_function) 4071 4072 :param callback function: The callback function 4073 for asynchronous request. (optional) 4074 :param str account_id: The external account number (int) or account ID Guid. (required) 4075 :return: EnvelopePurgeConfiguration 4076 If the method is called asynchronously, 4077 returns the request thread. 4078 """ 4079 kwargs['_return_http_data_only'] = True 4080 if kwargs.get('callback'): 4081 return self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs) 4082 else: 4083 (data) = self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs) 4084 return data 4085 4086 def get_envelope_purge_configuration_with_http_info(self, account_id, **kwargs): 4087 """ 4088 Select envelope purge configuration. 4089 An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method retrieves the current envelope purge configuration for your account. **Note:** To use this method, you must be an account administrator. 4090 This method makes a synchronous HTTP request by default. To make an 4091 asynchronous HTTP request, please define a `callback` function 4092 to be invoked when receiving the response. 4093 >>> def callback_function(response): 4094 >>> pprint(response) 4095 >>> 4096 >>> thread = api.get_envelope_purge_configuration_with_http_info(account_id, callback=callback_function) 4097 4098 :param callback function: The callback function 4099 for asynchronous request. (optional) 4100 :param str account_id: The external account number (int) or account ID Guid. (required) 4101 :return: EnvelopePurgeConfiguration 4102 If the method is called asynchronously, 4103 returns the request thread. 4104 """ 4105 4106 all_params = ['account_id'] 4107 all_params.append('callback') 4108 all_params.append('_return_http_data_only') 4109 all_params.append('_preload_content') 4110 all_params.append('_request_timeout') 4111 4112 params = locals() 4113 for key, val in iteritems(params['kwargs']): 4114 if key not in all_params: 4115 raise TypeError( 4116 "Got an unexpected keyword argument '%s'" 4117 " to method get_envelope_purge_configuration" % key 4118 ) 4119 params[key] = val 4120 del params['kwargs'] 4121 # verify the required parameter 'account_id' is set 4122 if ('account_id' not in params) or (params['account_id'] is None): 4123 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_purge_configuration`") 4124 4125 4126 collection_formats = {} 4127 4128 resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json') 4129 path_params = {} 4130 if 'account_id' in params: 4131 path_params['accountId'] = params['account_id'] 4132 4133 query_params = {} 4134 4135 header_params = {} 4136 4137 form_params = [] 4138 local_var_files = {} 4139 4140 body_params = None 4141 # HTTP header `Accept` 4142 header_params['Accept'] = self.api_client.\ 4143 select_header_accept(['application/json']) 4144 4145 # Authentication setting 4146 auth_settings = [] 4147 4148 return self.api_client.call_api(resource_path, 'GET', 4149 path_params, 4150 query_params, 4151 header_params, 4152 body=body_params, 4153 post_params=form_params, 4154 files=local_var_files, 4155 response_type='EnvelopePurgeConfiguration', 4156 auth_settings=auth_settings, 4157 callback=params.get('callback'), 4158 _return_http_data_only=params.get('_return_http_data_only'), 4159 _preload_content=params.get('_preload_content', True), 4160 _request_timeout=params.get('_request_timeout'), 4161 collection_formats=collection_formats) 4162 4163 def get_favorite_templates(self, account_id, **kwargs): 4164 """ 4165 Retrieves the list of favorited templates for this caller 4166 4167 This method makes a synchronous HTTP request by default. To make an 4168 asynchronous HTTP request, please define a `callback` function 4169 to be invoked when receiving the response. 4170 >>> def callback_function(response): 4171 >>> pprint(response) 4172 >>> 4173 >>> thread = api.get_favorite_templates(account_id, callback=callback_function) 4174 4175 :param callback function: The callback function 4176 for asynchronous request. (optional) 4177 :param str account_id: The external account number (int) or account ID Guid. (required) 4178 :return: FavoriteTemplatesInfo 4179 If the method is called asynchronously, 4180 returns the request thread. 4181 """ 4182 kwargs['_return_http_data_only'] = True 4183 if kwargs.get('callback'): 4184 return self.get_favorite_templates_with_http_info(account_id, **kwargs) 4185 else: 4186 (data) = self.get_favorite_templates_with_http_info(account_id, **kwargs) 4187 return data 4188 4189 def get_favorite_templates_with_http_info(self, account_id, **kwargs): 4190 """ 4191 Retrieves the list of favorited templates for this caller 4192 4193 This method makes a synchronous HTTP request by default. To make an 4194 asynchronous HTTP request, please define a `callback` function 4195 to be invoked when receiving the response. 4196 >>> def callback_function(response): 4197 >>> pprint(response) 4198 >>> 4199 >>> thread = api.get_favorite_templates_with_http_info(account_id, callback=callback_function) 4200 4201 :param callback function: The callback function 4202 for asynchronous request. (optional) 4203 :param str account_id: The external account number (int) or account ID Guid. (required) 4204 :return: FavoriteTemplatesInfo 4205 If the method is called asynchronously, 4206 returns the request thread. 4207 """ 4208 4209 all_params = ['account_id'] 4210 all_params.append('callback') 4211 all_params.append('_return_http_data_only') 4212 all_params.append('_preload_content') 4213 all_params.append('_request_timeout') 4214 4215 params = locals() 4216 for key, val in iteritems(params['kwargs']): 4217 if key not in all_params: 4218 raise TypeError( 4219 "Got an unexpected keyword argument '%s'" 4220 " to method get_favorite_templates" % key 4221 ) 4222 params[key] = val 4223 del params['kwargs'] 4224 # verify the required parameter 'account_id' is set 4225 if ('account_id' not in params) or (params['account_id'] is None): 4226 raise ValueError("Missing the required parameter `account_id` when calling `get_favorite_templates`") 4227 4228 4229 collection_formats = {} 4230 4231 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 4232 path_params = {} 4233 if 'account_id' in params: 4234 path_params['accountId'] = params['account_id'] 4235 4236 query_params = {} 4237 4238 header_params = {} 4239 4240 form_params = [] 4241 local_var_files = {} 4242 4243 body_params = None 4244 # HTTP header `Accept` 4245 header_params['Accept'] = self.api_client.\ 4246 select_header_accept(['application/json']) 4247 4248 # Authentication setting 4249 auth_settings = [] 4250 4251 return self.api_client.call_api(resource_path, 'GET', 4252 path_params, 4253 query_params, 4254 header_params, 4255 body=body_params, 4256 post_params=form_params, 4257 files=local_var_files, 4258 response_type='FavoriteTemplatesInfo', 4259 auth_settings=auth_settings, 4260 callback=params.get('callback'), 4261 _return_http_data_only=params.get('_return_http_data_only'), 4262 _preload_content=params.get('_preload_content', True), 4263 _request_timeout=params.get('_request_timeout'), 4264 collection_formats=collection_formats) 4265 4266 def get_notification_defaults(self, account_id, **kwargs): 4267 """ 4268 Returns default user level settings for a specified account 4269 This method returns the default settings for the email notifications that signers and senders receive about envelopes. 4270 This method makes a synchronous HTTP request by default. To make an 4271 asynchronous HTTP request, please define a `callback` function 4272 to be invoked when receiving the response. 4273 >>> def callback_function(response): 4274 >>> pprint(response) 4275 >>> 4276 >>> thread = api.get_notification_defaults(account_id, callback=callback_function) 4277 4278 :param callback function: The callback function 4279 for asynchronous request. (optional) 4280 :param str account_id: The external account number (int) or account ID Guid. (required) 4281 :return: NotificationDefaults 4282 If the method is called asynchronously, 4283 returns the request thread. 4284 """ 4285 kwargs['_return_http_data_only'] = True 4286 if kwargs.get('callback'): 4287 return self.get_notification_defaults_with_http_info(account_id, **kwargs) 4288 else: 4289 (data) = self.get_notification_defaults_with_http_info(account_id, **kwargs) 4290 return data 4291 4292 def get_notification_defaults_with_http_info(self, account_id, **kwargs): 4293 """ 4294 Returns default user level settings for a specified account 4295 This method returns the default settings for the email notifications that signers and senders receive about envelopes. 4296 This method makes a synchronous HTTP request by default. To make an 4297 asynchronous HTTP request, please define a `callback` function 4298 to be invoked when receiving the response. 4299 >>> def callback_function(response): 4300 >>> pprint(response) 4301 >>> 4302 >>> thread = api.get_notification_defaults_with_http_info(account_id, callback=callback_function) 4303 4304 :param callback function: The callback function 4305 for asynchronous request. (optional) 4306 :param str account_id: The external account number (int) or account ID Guid. (required) 4307 :return: NotificationDefaults 4308 If the method is called asynchronously, 4309 returns the request thread. 4310 """ 4311 4312 all_params = ['account_id'] 4313 all_params.append('callback') 4314 all_params.append('_return_http_data_only') 4315 all_params.append('_preload_content') 4316 all_params.append('_request_timeout') 4317 4318 params = locals() 4319 for key, val in iteritems(params['kwargs']): 4320 if key not in all_params: 4321 raise TypeError( 4322 "Got an unexpected keyword argument '%s'" 4323 " to method get_notification_defaults" % key 4324 ) 4325 params[key] = val 4326 del params['kwargs'] 4327 # verify the required parameter 'account_id' is set 4328 if ('account_id' not in params) or (params['account_id'] is None): 4329 raise ValueError("Missing the required parameter `account_id` when calling `get_notification_defaults`") 4330 4331 4332 collection_formats = {} 4333 4334 resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json') 4335 path_params = {} 4336 if 'account_id' in params: 4337 path_params['accountId'] = params['account_id'] 4338 4339 query_params = {} 4340 4341 header_params = {} 4342 4343 form_params = [] 4344 local_var_files = {} 4345 4346 body_params = None 4347 # HTTP header `Accept` 4348 header_params['Accept'] = self.api_client.\ 4349 select_header_accept(['application/json']) 4350 4351 # Authentication setting 4352 auth_settings = [] 4353 4354 return self.api_client.call_api(resource_path, 'GET', 4355 path_params, 4356 query_params, 4357 header_params, 4358 body=body_params, 4359 post_params=form_params, 4360 files=local_var_files, 4361 response_type='NotificationDefaults', 4362 auth_settings=auth_settings, 4363 callback=params.get('callback'), 4364 _return_http_data_only=params.get('_return_http_data_only'), 4365 _preload_content=params.get('_preload_content', True), 4366 _request_timeout=params.get('_request_timeout'), 4367 collection_formats=collection_formats) 4368 4369 def get_password_rules(self, account_id, **kwargs): 4370 """ 4371 Get the password rules 4372 This method retrieves the password rules for an account. 4373 This method makes a synchronous HTTP request by default. To make an 4374 asynchronous HTTP request, please define a `callback` function 4375 to be invoked when receiving the response. 4376 >>> def callback_function(response): 4377 >>> pprint(response) 4378 >>> 4379 >>> thread = api.get_password_rules(account_id, callback=callback_function) 4380 4381 :param callback function: The callback function 4382 for asynchronous request. (optional) 4383 :param str account_id: The external account number (int) or account ID Guid. (required) 4384 :return: AccountPasswordRules 4385 If the method is called asynchronously, 4386 returns the request thread. 4387 """ 4388 kwargs['_return_http_data_only'] = True 4389 if kwargs.get('callback'): 4390 return self.get_password_rules_with_http_info(account_id, **kwargs) 4391 else: 4392 (data) = self.get_password_rules_with_http_info(account_id, **kwargs) 4393 return data 4394 4395 def get_password_rules_with_http_info(self, account_id, **kwargs): 4396 """ 4397 Get the password rules 4398 This method retrieves the password rules for an account. 4399 This method makes a synchronous HTTP request by default. To make an 4400 asynchronous HTTP request, please define a `callback` function 4401 to be invoked when receiving the response. 4402 >>> def callback_function(response): 4403 >>> pprint(response) 4404 >>> 4405 >>> thread = api.get_password_rules_with_http_info(account_id, callback=callback_function) 4406 4407 :param callback function: The callback function 4408 for asynchronous request. (optional) 4409 :param str account_id: The external account number (int) or account ID Guid. (required) 4410 :return: AccountPasswordRules 4411 If the method is called asynchronously, 4412 returns the request thread. 4413 """ 4414 4415 all_params = ['account_id'] 4416 all_params.append('callback') 4417 all_params.append('_return_http_data_only') 4418 all_params.append('_preload_content') 4419 all_params.append('_request_timeout') 4420 4421 params = locals() 4422 for key, val in iteritems(params['kwargs']): 4423 if key not in all_params: 4424 raise TypeError( 4425 "Got an unexpected keyword argument '%s'" 4426 " to method get_password_rules" % key 4427 ) 4428 params[key] = val 4429 del params['kwargs'] 4430 # verify the required parameter 'account_id' is set 4431 if ('account_id' not in params) or (params['account_id'] is None): 4432 raise ValueError("Missing the required parameter `account_id` when calling `get_password_rules`") 4433 4434 4435 collection_formats = {} 4436 4437 resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json') 4438 path_params = {} 4439 if 'account_id' in params: 4440 path_params['accountId'] = params['account_id'] 4441 4442 query_params = {} 4443 4444 header_params = {} 4445 4446 form_params = [] 4447 local_var_files = {} 4448 4449 body_params = None 4450 # HTTP header `Accept` 4451 header_params['Accept'] = self.api_client.\ 4452 select_header_accept(['application/json']) 4453 4454 # Authentication setting 4455 auth_settings = [] 4456 4457 return self.api_client.call_api(resource_path, 'GET', 4458 path_params, 4459 query_params, 4460 header_params, 4461 body=body_params, 4462 post_params=form_params, 4463 files=local_var_files, 4464 response_type='AccountPasswordRules', 4465 auth_settings=auth_settings, 4466 callback=params.get('callback'), 4467 _return_http_data_only=params.get('_return_http_data_only'), 4468 _preload_content=params.get('_preload_content', True), 4469 _request_timeout=params.get('_request_timeout'), 4470 collection_formats=collection_formats) 4471 4472 def get_password_rules_0(self, **kwargs): 4473 """ 4474 Get membership account password rules 4475 4476 This method makes a synchronous HTTP request by default. To make an 4477 asynchronous HTTP request, please define a `callback` function 4478 to be invoked when receiving the response. 4479 >>> def callback_function(response): 4480 >>> pprint(response) 4481 >>> 4482 >>> thread = api.get_password_rules_0(callback=callback_function) 4483 4484 :param callback function: The callback function 4485 for asynchronous request. (optional) 4486 :return: UserPasswordRules 4487 If the method is called asynchronously, 4488 returns the request thread. 4489 """ 4490 kwargs['_return_http_data_only'] = True 4491 if kwargs.get('callback'): 4492 return self.get_password_rules_0_with_http_info(**kwargs) 4493 else: 4494 (data) = self.get_password_rules_0_with_http_info(**kwargs) 4495 return data 4496 4497 def get_password_rules_0_with_http_info(self, **kwargs): 4498 """ 4499 Get membership account password rules 4500 4501 This method makes a synchronous HTTP request by default. To make an 4502 asynchronous HTTP request, please define a `callback` function 4503 to be invoked when receiving the response. 4504 >>> def callback_function(response): 4505 >>> pprint(response) 4506 >>> 4507 >>> thread = api.get_password_rules_0_with_http_info(callback=callback_function) 4508 4509 :param callback function: The callback function 4510 for asynchronous request. (optional) 4511 :return: UserPasswordRules 4512 If the method is called asynchronously, 4513 returns the request thread. 4514 """ 4515 4516 all_params = [] 4517 all_params.append('callback') 4518 all_params.append('_return_http_data_only') 4519 all_params.append('_preload_content') 4520 all_params.append('_request_timeout') 4521 4522 params = locals() 4523 for key, val in iteritems(params['kwargs']): 4524 if key not in all_params: 4525 raise TypeError( 4526 "Got an unexpected keyword argument '%s'" 4527 " to method get_password_rules_0" % key 4528 ) 4529 params[key] = val 4530 del params['kwargs'] 4531 4532 collection_formats = {} 4533 4534 resource_path = '/v2.1/current_user/password_rules'.replace('{format}', 'json') 4535 path_params = {} 4536 4537 query_params = {} 4538 4539 header_params = {} 4540 4541 form_params = [] 4542 local_var_files = {} 4543 4544 body_params = None 4545 # HTTP header `Accept` 4546 header_params['Accept'] = self.api_client.\ 4547 select_header_accept(['application/json']) 4548 4549 # Authentication setting 4550 auth_settings = [] 4551 4552 return self.api_client.call_api(resource_path, 'GET', 4553 path_params, 4554 query_params, 4555 header_params, 4556 body=body_params, 4557 post_params=form_params, 4558 files=local_var_files, 4559 response_type='UserPasswordRules', 4560 auth_settings=auth_settings, 4561 callback=params.get('callback'), 4562 _return_http_data_only=params.get('_return_http_data_only'), 4563 _preload_content=params.get('_preload_content', True), 4564 _request_timeout=params.get('_request_timeout'), 4565 collection_formats=collection_formats) 4566 4567 def get_permission_profile(self, account_id, permission_profile_id, **kwargs): 4568 """ 4569 Returns a permissions profile in the specified account. 4570 This method returns information about a specific permission profile that is associated with an account. ### Related topics - [How to set a permission profile](/docs/esign-rest-api/how-to/permission-profile-setting/) 4571 This method makes a synchronous HTTP request by default. To make an 4572 asynchronous HTTP request, please define a `callback` function 4573 to be invoked when receiving the response. 4574 >>> def callback_function(response): 4575 >>> pprint(response) 4576 >>> 4577 >>> thread = api.get_permission_profile(account_id, permission_profile_id, callback=callback_function) 4578 4579 :param callback function: The callback function 4580 for asynchronous request. (optional) 4581 :param str account_id: The external account number (int) or account ID Guid. (required) 4582 :param str permission_profile_id: (required) 4583 :param str include: 4584 :return: PermissionProfile 4585 If the method is called asynchronously, 4586 returns the request thread. 4587 """ 4588 kwargs['_return_http_data_only'] = True 4589 if kwargs.get('callback'): 4590 return self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 4591 else: 4592 (data) = self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 4593 return data 4594 4595 def get_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 4596 """ 4597 Returns a permissions profile in the specified account. 4598 This method returns information about a specific permission profile that is associated with an account. ### Related topics - [How to set a permission profile](/docs/esign-rest-api/how-to/permission-profile-setting/) 4599 This method makes a synchronous HTTP request by default. To make an 4600 asynchronous HTTP request, please define a `callback` function 4601 to be invoked when receiving the response. 4602 >>> def callback_function(response): 4603 >>> pprint(response) 4604 >>> 4605 >>> thread = api.get_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 4606 4607 :param callback function: The callback function 4608 for asynchronous request. (optional) 4609 :param str account_id: The external account number (int) or account ID Guid. (required) 4610 :param str permission_profile_id: (required) 4611 :param str include: 4612 :return: PermissionProfile 4613 If the method is called asynchronously, 4614 returns the request thread. 4615 """ 4616 4617 all_params = ['account_id', 'permission_profile_id', 'include'] 4618 all_params.append('callback') 4619 all_params.append('_return_http_data_only') 4620 all_params.append('_preload_content') 4621 all_params.append('_request_timeout') 4622 4623 params = locals() 4624 for key, val in iteritems(params['kwargs']): 4625 if key not in all_params: 4626 raise TypeError( 4627 "Got an unexpected keyword argument '%s'" 4628 " to method get_permission_profile" % key 4629 ) 4630 params[key] = val 4631 del params['kwargs'] 4632 # verify the required parameter 'account_id' is set 4633 if ('account_id' not in params) or (params['account_id'] is None): 4634 raise ValueError("Missing the required parameter `account_id` when calling `get_permission_profile`") 4635 # verify the required parameter 'permission_profile_id' is set 4636 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 4637 raise ValueError("Missing the required parameter `permission_profile_id` when calling `get_permission_profile`") 4638 4639 4640 collection_formats = {} 4641 4642 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 4643 path_params = {} 4644 if 'account_id' in params: 4645 path_params['accountId'] = params['account_id'] 4646 if 'permission_profile_id' in params: 4647 path_params['permissionProfileId'] = params['permission_profile_id'] 4648 4649 query_params = {} 4650 if 'include' in params: 4651 query_params['include'] = params['include'] 4652 4653 header_params = {} 4654 4655 form_params = [] 4656 local_var_files = {} 4657 4658 body_params = None 4659 # HTTP header `Accept` 4660 header_params['Accept'] = self.api_client.\ 4661 select_header_accept(['application/json']) 4662 4663 # Authentication setting 4664 auth_settings = [] 4665 4666 return self.api_client.call_api(resource_path, 'GET', 4667 path_params, 4668 query_params, 4669 header_params, 4670 body=body_params, 4671 post_params=form_params, 4672 files=local_var_files, 4673 response_type='PermissionProfile', 4674 auth_settings=auth_settings, 4675 callback=params.get('callback'), 4676 _return_http_data_only=params.get('_return_http_data_only'), 4677 _preload_content=params.get('_preload_content', True), 4678 _request_timeout=params.get('_request_timeout'), 4679 collection_formats=collection_formats) 4680 4681 def get_principal_user_authorizations(self, account_id, user_id, **kwargs): 4682 """ 4683 Returns the principal user authorizations 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.get_principal_user_authorizations(account_id, user_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 user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required) 4696 :param str active_only: 4697 :param str count: 4698 :param str email_substring: Part (substring) of email we are searching for. 4699 :param str include_closed_users: 4700 :param str permissions: 4701 :param str start_position: 4702 :param str user_name_substring: 4703 :return: UserAuthorizations 4704 If the method is called asynchronously, 4705 returns the request thread. 4706 """ 4707 kwargs['_return_http_data_only'] = True 4708 if kwargs.get('callback'): 4709 return self.get_principal_user_authorizations_with_http_info(account_id, user_id, **kwargs) 4710 else: 4711 (data) = self.get_principal_user_authorizations_with_http_info(account_id, user_id, **kwargs) 4712 return data 4713 4714 def get_principal_user_authorizations_with_http_info(self, account_id, user_id, **kwargs): 4715 """ 4716 Returns the principal user authorizations 4717 This method makes a synchronous HTTP request by default. To make an 4718 asynchronous HTTP request, please define a `callback` function 4719 to be invoked when receiving the response. 4720 >>> def callback_function(response): 4721 >>> pprint(response) 4722 >>> 4723 >>> thread = api.get_principal_user_authorizations_with_http_info(account_id, user_id, callback=callback_function) 4724 4725 :param callback function: The callback function 4726 for asynchronous request. (optional) 4727 :param str account_id: The external account number (int) or account ID Guid. (required) 4728 :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required) 4729 :param str active_only: 4730 :param str count: 4731 :param str email_substring: Part (substring) of email we are searching for. 4732 :param str include_closed_users: 4733 :param str permissions: 4734 :param str start_position: 4735 :param str user_name_substring: 4736 :return: UserAuthorizations 4737 If the method is called asynchronously, 4738 returns the request thread. 4739 """ 4740 4741 all_params = ['account_id', 'user_id', 'active_only', 'count', 'email_substring', 'include_closed_users', 'permissions', 'start_position', 'user_name_substring'] 4742 all_params.append('callback') 4743 all_params.append('_return_http_data_only') 4744 all_params.append('_preload_content') 4745 all_params.append('_request_timeout') 4746 4747 params = locals() 4748 for key, val in iteritems(params['kwargs']): 4749 if key not in all_params: 4750 raise TypeError( 4751 "Got an unexpected keyword argument '%s'" 4752 " to method get_principal_user_authorizations" % key 4753 ) 4754 params[key] = val 4755 del params['kwargs'] 4756 # verify the required parameter 'account_id' is set 4757 if ('account_id' not in params) or (params['account_id'] is None): 4758 raise ValueError("Missing the required parameter `account_id` when calling `get_principal_user_authorizations`") 4759 # verify the required parameter 'user_id' is set 4760 if ('user_id' not in params) or (params['user_id'] is None): 4761 raise ValueError("Missing the required parameter `user_id` when calling `get_principal_user_authorizations`") 4762 4763 4764 collection_formats = {} 4765 4766 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorizations'.replace('{format}', 'json') 4767 path_params = {} 4768 if 'account_id' in params: 4769 path_params['accountId'] = params['account_id'] 4770 if 'user_id' in params: 4771 path_params['userId'] = params['user_id'] 4772 4773 query_params = {} 4774 if 'active_only' in params: 4775 query_params['active_only'] = params['active_only'] 4776 if 'count' in params: 4777 query_params['count'] = params['count'] 4778 if 'email_substring' in params: 4779 query_params['email_substring'] = params['email_substring'] 4780 if 'include_closed_users' in params: 4781 query_params['include_closed_users'] = params['include_closed_users'] 4782 if 'permissions' in params: 4783 query_params['permissions'] = params['permissions'] 4784 if 'start_position' in params: 4785 query_params['start_position'] = params['start_position'] 4786 if 'user_name_substring' in params: 4787 query_params['user_name_substring'] = params['user_name_substring'] 4788 4789 header_params = {} 4790 4791 form_params = [] 4792 local_var_files = {} 4793 4794 body_params = None 4795 # HTTP header `Accept` 4796 header_params['Accept'] = self.api_client.\ 4797 select_header_accept(['application/json']) 4798 4799 # Authentication setting 4800 auth_settings = [] 4801 4802 return self.api_client.call_api(resource_path, 'GET', 4803 path_params, 4804 query_params, 4805 header_params, 4806 body=body_params, 4807 post_params=form_params, 4808 files=local_var_files, 4809 response_type='UserAuthorizations', 4810 auth_settings=auth_settings, 4811 callback=params.get('callback'), 4812 _return_http_data_only=params.get('_return_http_data_only'), 4813 _preload_content=params.get('_preload_content', True), 4814 _request_timeout=params.get('_request_timeout'), 4815 collection_formats=collection_formats) 4816 4817 def get_provisioning(self, **kwargs): 4818 """ 4819 Retrieves the account provisioning information for the account. 4820 Retrieves the account provisioning information for the account. 4821 This method makes a synchronous HTTP request by default. To make an 4822 asynchronous HTTP request, please define a `callback` function 4823 to be invoked when receiving the response. 4824 >>> def callback_function(response): 4825 >>> pprint(response) 4826 >>> 4827 >>> thread = api.get_provisioning(callback=callback_function) 4828 4829 :param callback function: The callback function 4830 for asynchronous request. (optional) 4831 :return: ProvisioningInformation 4832 If the method is called asynchronously, 4833 returns the request thread. 4834 """ 4835 kwargs['_return_http_data_only'] = True 4836 if kwargs.get('callback'): 4837 return self.get_provisioning_with_http_info(**kwargs) 4838 else: 4839 (data) = self.get_provisioning_with_http_info(**kwargs) 4840 return data 4841 4842 def get_provisioning_with_http_info(self, **kwargs): 4843 """ 4844 Retrieves the account provisioning information for the account. 4845 Retrieves the account provisioning information for the account. 4846 This method makes a synchronous HTTP request by default. To make an 4847 asynchronous HTTP request, please define a `callback` function 4848 to be invoked when receiving the response. 4849 >>> def callback_function(response): 4850 >>> pprint(response) 4851 >>> 4852 >>> thread = api.get_provisioning_with_http_info(callback=callback_function) 4853 4854 :param callback function: The callback function 4855 for asynchronous request. (optional) 4856 :return: ProvisioningInformation 4857 If the method is called asynchronously, 4858 returns the request thread. 4859 """ 4860 4861 all_params = [] 4862 all_params.append('callback') 4863 all_params.append('_return_http_data_only') 4864 all_params.append('_preload_content') 4865 all_params.append('_request_timeout') 4866 4867 params = locals() 4868 for key, val in iteritems(params['kwargs']): 4869 if key not in all_params: 4870 raise TypeError( 4871 "Got an unexpected keyword argument '%s'" 4872 " to method get_provisioning" % key 4873 ) 4874 params[key] = val 4875 del params['kwargs'] 4876 4877 collection_formats = {} 4878 4879 resource_path = '/v2.1/accounts/provisioning'.replace('{format}', 'json') 4880 path_params = {} 4881 4882 query_params = {} 4883 4884 header_params = {} 4885 4886 form_params = [] 4887 local_var_files = {} 4888 4889 body_params = None 4890 # HTTP header `Accept` 4891 header_params['Accept'] = self.api_client.\ 4892 select_header_accept(['application/json']) 4893 4894 # Authentication setting 4895 auth_settings = [] 4896 4897 return self.api_client.call_api(resource_path, 'GET', 4898 path_params, 4899 query_params, 4900 header_params, 4901 body=body_params, 4902 post_params=form_params, 4903 files=local_var_files, 4904 response_type='ProvisioningInformation', 4905 auth_settings=auth_settings, 4906 callback=params.get('callback'), 4907 _return_http_data_only=params.get('_return_http_data_only'), 4908 _preload_content=params.get('_preload_content', True), 4909 _request_timeout=params.get('_request_timeout'), 4910 collection_formats=collection_formats) 4911 4912 def get_supported_languages(self, account_id, **kwargs): 4913 """ 4914 Gets list of supported languages for recipient language setting. 4915 Retrieves a list of supported languages that you can set for an individual recipient when creating an envelope, as well as their simple type enumeration values. These are the languages that you can set for the standard email format and signing view for each recipient. For example, in the recipient's email notification, this setting affects elements such as the standard introductory text describing the request to sign. It also determines the language used for buttons and tabs in both the email notification and the signing experience. **Note:** Setting a language for a recipient affects only the DocuSign standard text. Any custom text that you enter for the `emailBody` and `emailSubject` of the notification is not translated, and appears exactly as you enter it. For more information, see [Set Recipient Language and Specify Custom Email Messages](https://support.docusign.com/en/guides/ndse-user-guide-recipient-language). 4916 This method makes a synchronous HTTP request by default. To make an 4917 asynchronous HTTP request, please define a `callback` function 4918 to be invoked when receiving the response. 4919 >>> def callback_function(response): 4920 >>> pprint(response) 4921 >>> 4922 >>> thread = api.get_supported_languages(account_id, callback=callback_function) 4923 4924 :param callback function: The callback function 4925 for asynchronous request. (optional) 4926 :param str account_id: The external account number (int) or account ID Guid. (required) 4927 :return: SupportedLanguages 4928 If the method is called asynchronously, 4929 returns the request thread. 4930 """ 4931 kwargs['_return_http_data_only'] = True 4932 if kwargs.get('callback'): 4933 return self.get_supported_languages_with_http_info(account_id, **kwargs) 4934 else: 4935 (data) = self.get_supported_languages_with_http_info(account_id, **kwargs) 4936 return data 4937 4938 def get_supported_languages_with_http_info(self, account_id, **kwargs): 4939 """ 4940 Gets list of supported languages for recipient language setting. 4941 Retrieves a list of supported languages that you can set for an individual recipient when creating an envelope, as well as their simple type enumeration values. These are the languages that you can set for the standard email format and signing view for each recipient. For example, in the recipient's email notification, this setting affects elements such as the standard introductory text describing the request to sign. It also determines the language used for buttons and tabs in both the email notification and the signing experience. **Note:** Setting a language for a recipient affects only the DocuSign standard text. Any custom text that you enter for the `emailBody` and `emailSubject` of the notification is not translated, and appears exactly as you enter it. For more information, see [Set Recipient Language and Specify Custom Email Messages](https://support.docusign.com/en/guides/ndse-user-guide-recipient-language). 4942 This method makes a synchronous HTTP request by default. To make an 4943 asynchronous HTTP request, please define a `callback` function 4944 to be invoked when receiving the response. 4945 >>> def callback_function(response): 4946 >>> pprint(response) 4947 >>> 4948 >>> thread = api.get_supported_languages_with_http_info(account_id, callback=callback_function) 4949 4950 :param callback function: The callback function 4951 for asynchronous request. (optional) 4952 :param str account_id: The external account number (int) or account ID Guid. (required) 4953 :return: SupportedLanguages 4954 If the method is called asynchronously, 4955 returns the request thread. 4956 """ 4957 4958 all_params = ['account_id'] 4959 all_params.append('callback') 4960 all_params.append('_return_http_data_only') 4961 all_params.append('_preload_content') 4962 all_params.append('_request_timeout') 4963 4964 params = locals() 4965 for key, val in iteritems(params['kwargs']): 4966 if key not in all_params: 4967 raise TypeError( 4968 "Got an unexpected keyword argument '%s'" 4969 " to method get_supported_languages" % key 4970 ) 4971 params[key] = val 4972 del params['kwargs'] 4973 # verify the required parameter 'account_id' is set 4974 if ('account_id' not in params) or (params['account_id'] is None): 4975 raise ValueError("Missing the required parameter `account_id` when calling `get_supported_languages`") 4976 4977 4978 collection_formats = {} 4979 4980 resource_path = '/v2.1/accounts/{accountId}/supported_languages'.replace('{format}', 'json') 4981 path_params = {} 4982 if 'account_id' in params: 4983 path_params['accountId'] = params['account_id'] 4984 4985 query_params = {} 4986 4987 header_params = {} 4988 4989 form_params = [] 4990 local_var_files = {} 4991 4992 body_params = None 4993 # HTTP header `Accept` 4994 header_params['Accept'] = self.api_client.\ 4995 select_header_accept(['application/json']) 4996 4997 # Authentication setting 4998 auth_settings = [] 4999 5000 return self.api_client.call_api(resource_path, 'GET', 5001 path_params, 5002 query_params, 5003 header_params, 5004 body=body_params, 5005 post_params=form_params, 5006 files=local_var_files, 5007 response_type='SupportedLanguages', 5008 auth_settings=auth_settings, 5009 callback=params.get('callback'), 5010 _return_http_data_only=params.get('_return_http_data_only'), 5011 _preload_content=params.get('_preload_content', True), 5012 _request_timeout=params.get('_request_timeout'), 5013 collection_formats=collection_formats) 5014 5015 def get_user_authorization(self, account_id, authorization_id, user_id, **kwargs): 5016 """ 5017 Returns the user authorization for a given authorization id 5018 This method makes a synchronous HTTP request by default. To make an 5019 asynchronous HTTP request, please define a `callback` function 5020 to be invoked when receiving the response. 5021 >>> def callback_function(response): 5022 >>> pprint(response) 5023 >>> 5024 >>> thread = api.get_user_authorization(account_id, authorization_id, user_id, callback=callback_function) 5025 5026 :param callback function: The callback function 5027 for asynchronous request. (optional) 5028 :param str account_id: The external account number (int) or account ID Guid. (required) 5029 :param str authorization_id: (required) 5030 :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required) 5031 :return: UserAuthorization 5032 If the method is called asynchronously, 5033 returns the request thread. 5034 """ 5035 kwargs['_return_http_data_only'] = True 5036 if kwargs.get('callback'): 5037 return self.get_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 5038 else: 5039 (data) = self.get_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 5040 return data 5041 5042 def get_user_authorization_with_http_info(self, account_id, authorization_id, user_id, **kwargs): 5043 """ 5044 Returns the user authorization for a given authorization id 5045 This method makes a synchronous HTTP request by default. To make an 5046 asynchronous HTTP request, please define a `callback` function 5047 to be invoked when receiving the response. 5048 >>> def callback_function(response): 5049 >>> pprint(response) 5050 >>> 5051 >>> thread = api.get_user_authorization_with_http_info(account_id, authorization_id, user_id, callback=callback_function) 5052 5053 :param callback function: The callback function 5054 for asynchronous request. (optional) 5055 :param str account_id: The external account number (int) or account ID Guid. (required) 5056 :param str authorization_id: (required) 5057 :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required) 5058 :return: UserAuthorization 5059 If the method is called asynchronously, 5060 returns the request thread. 5061 """ 5062 5063 all_params = ['account_id', 'authorization_id', 'user_id'] 5064 all_params.append('callback') 5065 all_params.append('_return_http_data_only') 5066 all_params.append('_preload_content') 5067 all_params.append('_request_timeout') 5068 5069 params = locals() 5070 for key, val in iteritems(params['kwargs']): 5071 if key not in all_params: 5072 raise TypeError( 5073 "Got an unexpected keyword argument '%s'" 5074 " to method get_user_authorization" % key 5075 ) 5076 params[key] = val 5077 del params['kwargs'] 5078 # verify the required parameter 'account_id' is set 5079 if ('account_id' not in params) or (params['account_id'] is None): 5080 raise ValueError("Missing the required parameter `account_id` when calling `get_user_authorization`") 5081 # verify the required parameter 'authorization_id' is set 5082 if ('authorization_id' not in params) or (params['authorization_id'] is None): 5083 raise ValueError("Missing the required parameter `authorization_id` when calling `get_user_authorization`") 5084 # verify the required parameter 'user_id' is set 5085 if ('user_id' not in params) or (params['user_id'] is None): 5086 raise ValueError("Missing the required parameter `user_id` when calling `get_user_authorization`") 5087 5088 5089 collection_formats = {} 5090 5091 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorization/{authorizationId}'.replace('{format}', 'json') 5092 path_params = {} 5093 if 'account_id' in params: 5094 path_params['accountId'] = params['account_id'] 5095 if 'authorization_id' in params: 5096 path_params['authorizationId'] = params['authorization_id'] 5097 if 'user_id' in params: 5098 path_params['userId'] = params['user_id'] 5099 5100 query_params = {} 5101 5102 header_params = {} 5103 5104 form_params = [] 5105 local_var_files = {} 5106 5107 body_params = None 5108 # HTTP header `Accept` 5109 header_params['Accept'] = self.api_client.\ 5110 select_header_accept(['application/json']) 5111 5112 # Authentication setting 5113 auth_settings = [] 5114 5115 return self.api_client.call_api(resource_path, 'GET', 5116 path_params, 5117 query_params, 5118 header_params, 5119 body=body_params, 5120 post_params=form_params, 5121 files=local_var_files, 5122 response_type='UserAuthorization', 5123 auth_settings=auth_settings, 5124 callback=params.get('callback'), 5125 _return_http_data_only=params.get('_return_http_data_only'), 5126 _preload_content=params.get('_preload_content', True), 5127 _request_timeout=params.get('_request_timeout'), 5128 collection_formats=collection_formats) 5129 5130 def get_watermark(self, account_id, **kwargs): 5131 """ 5132 Get watermark information. 5133 5134 This method makes a synchronous HTTP request by default. To make an 5135 asynchronous HTTP request, please define a `callback` function 5136 to be invoked when receiving the response. 5137 >>> def callback_function(response): 5138 >>> pprint(response) 5139 >>> 5140 >>> thread = api.get_watermark(account_id, callback=callback_function) 5141 5142 :param callback function: The callback function 5143 for asynchronous request. (optional) 5144 :param str account_id: The external account number (int) or account ID Guid. (required) 5145 :return: Watermark 5146 If the method is called asynchronously, 5147 returns the request thread. 5148 """ 5149 kwargs['_return_http_data_only'] = True 5150 if kwargs.get('callback'): 5151 return self.get_watermark_with_http_info(account_id, **kwargs) 5152 else: 5153 (data) = self.get_watermark_with_http_info(account_id, **kwargs) 5154 return data 5155 5156 def get_watermark_with_http_info(self, account_id, **kwargs): 5157 """ 5158 Get watermark information. 5159 5160 This method makes a synchronous HTTP request by default. To make an 5161 asynchronous HTTP request, please define a `callback` function 5162 to be invoked when receiving the response. 5163 >>> def callback_function(response): 5164 >>> pprint(response) 5165 >>> 5166 >>> thread = api.get_watermark_with_http_info(account_id, callback=callback_function) 5167 5168 :param callback function: The callback function 5169 for asynchronous request. (optional) 5170 :param str account_id: The external account number (int) or account ID Guid. (required) 5171 :return: Watermark 5172 If the method is called asynchronously, 5173 returns the request thread. 5174 """ 5175 5176 all_params = ['account_id'] 5177 all_params.append('callback') 5178 all_params.append('_return_http_data_only') 5179 all_params.append('_preload_content') 5180 all_params.append('_request_timeout') 5181 5182 params = locals() 5183 for key, val in iteritems(params['kwargs']): 5184 if key not in all_params: 5185 raise TypeError( 5186 "Got an unexpected keyword argument '%s'" 5187 " to method get_watermark" % key 5188 ) 5189 params[key] = val 5190 del params['kwargs'] 5191 # verify the required parameter 'account_id' is set 5192 if ('account_id' not in params) or (params['account_id'] is None): 5193 raise ValueError("Missing the required parameter `account_id` when calling `get_watermark`") 5194 5195 5196 collection_formats = {} 5197 5198 resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json') 5199 path_params = {} 5200 if 'account_id' in params: 5201 path_params['accountId'] = params['account_id'] 5202 5203 query_params = {} 5204 5205 header_params = {} 5206 5207 form_params = [] 5208 local_var_files = {} 5209 5210 body_params = None 5211 # HTTP header `Accept` 5212 header_params['Accept'] = self.api_client.\ 5213 select_header_accept(['application/json']) 5214 5215 # Authentication setting 5216 auth_settings = [] 5217 5218 return self.api_client.call_api(resource_path, 'GET', 5219 path_params, 5220 query_params, 5221 header_params, 5222 body=body_params, 5223 post_params=form_params, 5224 files=local_var_files, 5225 response_type='Watermark', 5226 auth_settings=auth_settings, 5227 callback=params.get('callback'), 5228 _return_http_data_only=params.get('_return_http_data_only'), 5229 _preload_content=params.get('_preload_content', True), 5230 _request_timeout=params.get('_request_timeout'), 5231 collection_formats=collection_formats) 5232 5233 def get_watermark_preview(self, account_id, **kwargs): 5234 """ 5235 Get watermark preview. 5236 5237 This method makes a synchronous HTTP request by default. To make an 5238 asynchronous HTTP request, please define a `callback` function 5239 to be invoked when receiving the response. 5240 >>> def callback_function(response): 5241 >>> pprint(response) 5242 >>> 5243 >>> thread = api.get_watermark_preview(account_id, callback=callback_function) 5244 5245 :param callback function: The callback function 5246 for asynchronous request. (optional) 5247 :param str account_id: The external account number (int) or account ID Guid. (required) 5248 :param Watermark watermark: 5249 :return: Watermark 5250 If the method is called asynchronously, 5251 returns the request thread. 5252 """ 5253 kwargs['_return_http_data_only'] = True 5254 if kwargs.get('callback'): 5255 return self.get_watermark_preview_with_http_info(account_id, **kwargs) 5256 else: 5257 (data) = self.get_watermark_preview_with_http_info(account_id, **kwargs) 5258 return data 5259 5260 def get_watermark_preview_with_http_info(self, account_id, **kwargs): 5261 """ 5262 Get watermark preview. 5263 5264 This method makes a synchronous HTTP request by default. To make an 5265 asynchronous HTTP request, please define a `callback` function 5266 to be invoked when receiving the response. 5267 >>> def callback_function(response): 5268 >>> pprint(response) 5269 >>> 5270 >>> thread = api.get_watermark_preview_with_http_info(account_id, callback=callback_function) 5271 5272 :param callback function: The callback function 5273 for asynchronous request. (optional) 5274 :param str account_id: The external account number (int) or account ID Guid. (required) 5275 :param Watermark watermark: 5276 :return: Watermark 5277 If the method is called asynchronously, 5278 returns the request thread. 5279 """ 5280 5281 all_params = ['account_id', 'watermark'] 5282 all_params.append('callback') 5283 all_params.append('_return_http_data_only') 5284 all_params.append('_preload_content') 5285 all_params.append('_request_timeout') 5286 5287 params = locals() 5288 for key, val in iteritems(params['kwargs']): 5289 if key not in all_params: 5290 raise TypeError( 5291 "Got an unexpected keyword argument '%s'" 5292 " to method get_watermark_preview" % key 5293 ) 5294 params[key] = val 5295 del params['kwargs'] 5296 # verify the required parameter 'account_id' is set 5297 if ('account_id' not in params) or (params['account_id'] is None): 5298 raise ValueError("Missing the required parameter `account_id` when calling `get_watermark_preview`") 5299 5300 5301 collection_formats = {} 5302 5303 resource_path = '/v2.1/accounts/{accountId}/watermark/preview'.replace('{format}', 'json') 5304 path_params = {} 5305 if 'account_id' in params: 5306 path_params['accountId'] = params['account_id'] 5307 5308 query_params = {} 5309 5310 header_params = {} 5311 5312 form_params = [] 5313 local_var_files = {} 5314 5315 body_params = None 5316 if 'watermark' in params: 5317 body_params = params['watermark'] 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, 'PUT', 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='Watermark', 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 list_brands(self, account_id, **kwargs): 5341 """ 5342 Gets a list of brand profiles. 5343 Retrieves the list of brand profiles associated with the account and the default brand profiles. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`) must be set to **true** for the account to use this call. 5344 This method makes a synchronous HTTP request by default. To make an 5345 asynchronous HTTP request, please define a `callback` function 5346 to be invoked when receiving the response. 5347 >>> def callback_function(response): 5348 >>> pprint(response) 5349 >>> 5350 >>> thread = api.list_brands(account_id, callback=callback_function) 5351 5352 :param callback function: The callback function 5353 for asynchronous request. (optional) 5354 :param str account_id: The external account number (int) or account ID Guid. (required) 5355 :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set. 5356 :param str include_logos: When set to **true**, returns the logos associated with the brand. 5357 :return: BrandsResponse 5358 If the method is called asynchronously, 5359 returns the request thread. 5360 """ 5361 kwargs['_return_http_data_only'] = True 5362 if kwargs.get('callback'): 5363 return self.list_brands_with_http_info(account_id, **kwargs) 5364 else: 5365 (data) = self.list_brands_with_http_info(account_id, **kwargs) 5366 return data 5367 5368 def list_brands_with_http_info(self, account_id, **kwargs): 5369 """ 5370 Gets a list of brand profiles. 5371 Retrieves the list of brand profiles associated with the account and the default brand profiles. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`) must be set to **true** for the account to use this call. 5372 This method makes a synchronous HTTP request by default. To make an 5373 asynchronous HTTP request, please define a `callback` function 5374 to be invoked when receiving the response. 5375 >>> def callback_function(response): 5376 >>> pprint(response) 5377 >>> 5378 >>> thread = api.list_brands_with_http_info(account_id, callback=callback_function) 5379 5380 :param callback function: The callback function 5381 for asynchronous request. (optional) 5382 :param str account_id: The external account number (int) or account ID Guid. (required) 5383 :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set. 5384 :param str include_logos: When set to **true**, returns the logos associated with the brand. 5385 :return: BrandsResponse 5386 If the method is called asynchronously, 5387 returns the request thread. 5388 """ 5389 5390 all_params = ['account_id', 'exclude_distributor_brand', 'include_logos'] 5391 all_params.append('callback') 5392 all_params.append('_return_http_data_only') 5393 all_params.append('_preload_content') 5394 all_params.append('_request_timeout') 5395 5396 params = locals() 5397 for key, val in iteritems(params['kwargs']): 5398 if key not in all_params: 5399 raise TypeError( 5400 "Got an unexpected keyword argument '%s'" 5401 " to method list_brands" % key 5402 ) 5403 params[key] = val 5404 del params['kwargs'] 5405 # verify the required parameter 'account_id' is set 5406 if ('account_id' not in params) or (params['account_id'] is None): 5407 raise ValueError("Missing the required parameter `account_id` when calling `list_brands`") 5408 5409 5410 collection_formats = {} 5411 5412 resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json') 5413 path_params = {} 5414 if 'account_id' in params: 5415 path_params['accountId'] = params['account_id'] 5416 5417 query_params = {} 5418 if 'exclude_distributor_brand' in params: 5419 query_params['exclude_distributor_brand'] = params['exclude_distributor_brand'] 5420 if 'include_logos' in params: 5421 query_params['include_logos'] = params['include_logos'] 5422 5423 header_params = {} 5424 5425 form_params = [] 5426 local_var_files = {} 5427 5428 body_params = None 5429 # HTTP header `Accept` 5430 header_params['Accept'] = self.api_client.\ 5431 select_header_accept(['application/json']) 5432 5433 # Authentication setting 5434 auth_settings = [] 5435 5436 return self.api_client.call_api(resource_path, 'GET', 5437 path_params, 5438 query_params, 5439 header_params, 5440 body=body_params, 5441 post_params=form_params, 5442 files=local_var_files, 5443 response_type='BrandsResponse', 5444 auth_settings=auth_settings, 5445 callback=params.get('callback'), 5446 _return_http_data_only=params.get('_return_http_data_only'), 5447 _preload_content=params.get('_preload_content', True), 5448 _request_timeout=params.get('_request_timeout'), 5449 collection_formats=collection_formats) 5450 5451 def list_custom_fields(self, account_id, **kwargs): 5452 """ 5453 Gets a list of custom fields associated with the account. 5454 Retrieves a list of envelope custom fields associated with the account. 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. The list custom field lets the sender select the value of the field from a list you provide. 5455 This method makes a synchronous HTTP request by default. To make an 5456 asynchronous HTTP request, please define a `callback` function 5457 to be invoked when receiving the response. 5458 >>> def callback_function(response): 5459 >>> pprint(response) 5460 >>> 5461 >>> thread = api.list_custom_fields(account_id, callback=callback_function) 5462 5463 :param callback function: The callback function 5464 for asynchronous request. (optional) 5465 :param str account_id: The external account number (int) or account ID Guid. (required) 5466 :return: CustomFields 5467 If the method is called asynchronously, 5468 returns the request thread. 5469 """ 5470 kwargs['_return_http_data_only'] = True 5471 if kwargs.get('callback'): 5472 return self.list_custom_fields_with_http_info(account_id, **kwargs) 5473 else: 5474 (data) = self.list_custom_fields_with_http_info(account_id, **kwargs) 5475 return data 5476 5477 def list_custom_fields_with_http_info(self, account_id, **kwargs): 5478 """ 5479 Gets a list of custom fields associated with the account. 5480 Retrieves a list of envelope custom fields associated with the account. 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. The list custom field lets the sender select the value of the field from a list you provide. 5481 This method makes a synchronous HTTP request by default. To make an 5482 asynchronous HTTP request, please define a `callback` function 5483 to be invoked when receiving the response. 5484 >>> def callback_function(response): 5485 >>> pprint(response) 5486 >>> 5487 >>> thread = api.list_custom_fields_with_http_info(account_id, callback=callback_function) 5488 5489 :param callback function: The callback function 5490 for asynchronous request. (optional) 5491 :param str account_id: The external account number (int) or account ID Guid. (required) 5492 :return: CustomFields 5493 If the method is called asynchronously, 5494 returns the request thread. 5495 """ 5496 5497 all_params = ['account_id'] 5498 all_params.append('callback') 5499 all_params.append('_return_http_data_only') 5500 all_params.append('_preload_content') 5501 all_params.append('_request_timeout') 5502 5503 params = locals() 5504 for key, val in iteritems(params['kwargs']): 5505 if key not in all_params: 5506 raise TypeError( 5507 "Got an unexpected keyword argument '%s'" 5508 " to method list_custom_fields" % key 5509 ) 5510 params[key] = val 5511 del params['kwargs'] 5512 # verify the required parameter 'account_id' is set 5513 if ('account_id' not in params) or (params['account_id'] is None): 5514 raise ValueError("Missing the required parameter `account_id` when calling `list_custom_fields`") 5515 5516 5517 collection_formats = {} 5518 5519 resource_path = '/v2.1/accounts/{accountId}/custom_fields'.replace('{format}', 'json') 5520 path_params = {} 5521 if 'account_id' in params: 5522 path_params['accountId'] = params['account_id'] 5523 5524 query_params = {} 5525 5526 header_params = {} 5527 5528 form_params = [] 5529 local_var_files = {} 5530 5531 body_params = None 5532 # HTTP header `Accept` 5533 header_params['Accept'] = self.api_client.\ 5534 select_header_accept(['application/json']) 5535 5536 # Authentication setting 5537 auth_settings = [] 5538 5539 return self.api_client.call_api(resource_path, 'GET', 5540 path_params, 5541 query_params, 5542 header_params, 5543 body=body_params, 5544 post_params=form_params, 5545 files=local_var_files, 5546 response_type='CustomFields', 5547 auth_settings=auth_settings, 5548 callback=params.get('callback'), 5549 _return_http_data_only=params.get('_return_http_data_only'), 5550 _preload_content=params.get('_preload_content', True), 5551 _request_timeout=params.get('_request_timeout'), 5552 collection_formats=collection_formats) 5553 5554 def list_permissions(self, account_id, **kwargs): 5555 """ 5556 Gets a list of permission profiles. 5557 Retrieves a list of Permission Profiles. Permission Profiles are a standard set of user permissions that you can apply to individual users or users in a Group. This makes it easier to manage user permissions for a large number of users, without having to change permissions on a user-by-user basis. Currently, Permission Profiles can only be created and modified in the DocuSign console. 5558 This method makes a synchronous HTTP request by default. To make an 5559 asynchronous HTTP request, please define a `callback` function 5560 to be invoked when receiving the response. 5561 >>> def callback_function(response): 5562 >>> pprint(response) 5563 >>> 5564 >>> thread = api.list_permissions(account_id, callback=callback_function) 5565 5566 :param callback function: The callback function 5567 for asynchronous request. (optional) 5568 :param str account_id: The external account number (int) or account ID Guid. (required) 5569 :param str include: 5570 :return: PermissionProfileInformation 5571 If the method is called asynchronously, 5572 returns the request thread. 5573 """ 5574 kwargs['_return_http_data_only'] = True 5575 if kwargs.get('callback'): 5576 return self.list_permissions_with_http_info(account_id, **kwargs) 5577 else: 5578 (data) = self.list_permissions_with_http_info(account_id, **kwargs) 5579 return data 5580 5581 def list_permissions_with_http_info(self, account_id, **kwargs): 5582 """ 5583 Gets a list of permission profiles. 5584 Retrieves a list of Permission Profiles. Permission Profiles are a standard set of user permissions that you can apply to individual users or users in a Group. This makes it easier to manage user permissions for a large number of users, without having to change permissions on a user-by-user basis. Currently, Permission Profiles can only be created and modified in the DocuSign console. 5585 This method makes a synchronous HTTP request by default. To make an 5586 asynchronous HTTP request, please define a `callback` function 5587 to be invoked when receiving the response. 5588 >>> def callback_function(response): 5589 >>> pprint(response) 5590 >>> 5591 >>> thread = api.list_permissions_with_http_info(account_id, callback=callback_function) 5592 5593 :param callback function: The callback function 5594 for asynchronous request. (optional) 5595 :param str account_id: The external account number (int) or account ID Guid. (required) 5596 :param str include: 5597 :return: PermissionProfileInformation 5598 If the method is called asynchronously, 5599 returns the request thread. 5600 """ 5601 5602 all_params = ['account_id', 'include'] 5603 all_params.append('callback') 5604 all_params.append('_return_http_data_only') 5605 all_params.append('_preload_content') 5606 all_params.append('_request_timeout') 5607 5608 params = locals() 5609 for key, val in iteritems(params['kwargs']): 5610 if key not in all_params: 5611 raise TypeError( 5612 "Got an unexpected keyword argument '%s'" 5613 " to method list_permissions" % key 5614 ) 5615 params[key] = val 5616 del params['kwargs'] 5617 # verify the required parameter 'account_id' is set 5618 if ('account_id' not in params) or (params['account_id'] is None): 5619 raise ValueError("Missing the required parameter `account_id` when calling `list_permissions`") 5620 5621 5622 collection_formats = {} 5623 5624 resource_path = '/v2.1/accounts/{accountId}/permission_profiles'.replace('{format}', 'json') 5625 path_params = {} 5626 if 'account_id' in params: 5627 path_params['accountId'] = params['account_id'] 5628 5629 query_params = {} 5630 if 'include' in params: 5631 query_params['include'] = params['include'] 5632 5633 header_params = {} 5634 5635 form_params = [] 5636 local_var_files = {} 5637 5638 body_params = None 5639 # HTTP header `Accept` 5640 header_params['Accept'] = self.api_client.\ 5641 select_header_accept(['application/json']) 5642 5643 # Authentication setting 5644 auth_settings = [] 5645 5646 return self.api_client.call_api(resource_path, 'GET', 5647 path_params, 5648 query_params, 5649 header_params, 5650 body=body_params, 5651 post_params=form_params, 5652 files=local_var_files, 5653 response_type='PermissionProfileInformation', 5654 auth_settings=auth_settings, 5655 callback=params.get('callback'), 5656 _return_http_data_only=params.get('_return_http_data_only'), 5657 _preload_content=params.get('_preload_content', True), 5658 _request_timeout=params.get('_request_timeout'), 5659 collection_formats=collection_formats) 5660 5661 def list_recipient_names_by_email(self, account_id, **kwargs): 5662 """ 5663 Gets recipient names associated with an email address. 5664 Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string. 5665 This method makes a synchronous HTTP request by default. To make an 5666 asynchronous HTTP request, please define a `callback` function 5667 to be invoked when receiving the response. 5668 >>> def callback_function(response): 5669 >>> pprint(response) 5670 >>> 5671 >>> thread = api.list_recipient_names_by_email(account_id, callback=callback_function) 5672 5673 :param callback function: The callback function 5674 for asynchronous request. (optional) 5675 :param str account_id: The external account number (int) or account ID Guid. (required) 5676 :param str email: The email address for the user 5677 :return: RecipientNamesResponse 5678 If the method is called asynchronously, 5679 returns the request thread. 5680 """ 5681 kwargs['_return_http_data_only'] = True 5682 if kwargs.get('callback'): 5683 return self.list_recipient_names_by_email_with_http_info(account_id, **kwargs) 5684 else: 5685 (data) = self.list_recipient_names_by_email_with_http_info(account_id, **kwargs) 5686 return data 5687 5688 def list_recipient_names_by_email_with_http_info(self, account_id, **kwargs): 5689 """ 5690 Gets recipient names associated with an email address. 5691 Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string. 5692 This method makes a synchronous HTTP request by default. To make an 5693 asynchronous HTTP request, please define a `callback` function 5694 to be invoked when receiving the response. 5695 >>> def callback_function(response): 5696 >>> pprint(response) 5697 >>> 5698 >>> thread = api.list_recipient_names_by_email_with_http_info(account_id, callback=callback_function) 5699 5700 :param callback function: The callback function 5701 for asynchronous request. (optional) 5702 :param str account_id: The external account number (int) or account ID Guid. (required) 5703 :param str email: The email address for the user 5704 :return: RecipientNamesResponse 5705 If the method is called asynchronously, 5706 returns the request thread. 5707 """ 5708 5709 all_params = ['account_id', 'email'] 5710 all_params.append('callback') 5711 all_params.append('_return_http_data_only') 5712 all_params.append('_preload_content') 5713 all_params.append('_request_timeout') 5714 5715 params = locals() 5716 for key, val in iteritems(params['kwargs']): 5717 if key not in all_params: 5718 raise TypeError( 5719 "Got an unexpected keyword argument '%s'" 5720 " to method list_recipient_names_by_email" % key 5721 ) 5722 params[key] = val 5723 del params['kwargs'] 5724 # verify the required parameter 'account_id' is set 5725 if ('account_id' not in params) or (params['account_id'] is None): 5726 raise ValueError("Missing the required parameter `account_id` when calling `list_recipient_names_by_email`") 5727 5728 5729 collection_formats = {} 5730 5731 resource_path = '/v2.1/accounts/{accountId}/recipient_names'.replace('{format}', 'json') 5732 path_params = {} 5733 if 'account_id' in params: 5734 path_params['accountId'] = params['account_id'] 5735 5736 query_params = {} 5737 if 'email' in params: 5738 query_params['email'] = params['email'] 5739 5740 header_params = {} 5741 5742 form_params = [] 5743 local_var_files = {} 5744 5745 body_params = None 5746 # HTTP header `Accept` 5747 header_params['Accept'] = self.api_client.\ 5748 select_header_accept(['application/json']) 5749 5750 # Authentication setting 5751 auth_settings = [] 5752 5753 return self.api_client.call_api(resource_path, 'GET', 5754 path_params, 5755 query_params, 5756 header_params, 5757 body=body_params, 5758 post_params=form_params, 5759 files=local_var_files, 5760 response_type='RecipientNamesResponse', 5761 auth_settings=auth_settings, 5762 callback=params.get('callback'), 5763 _return_http_data_only=params.get('_return_http_data_only'), 5764 _preload_content=params.get('_preload_content', True), 5765 _request_timeout=params.get('_request_timeout'), 5766 collection_formats=collection_formats) 5767 5768 def list_settings(self, account_id, **kwargs): 5769 """ 5770 Gets account settings information. 5771 Retrieves the account settings information for the specified account. 5772 This method makes a synchronous HTTP request by default. To make an 5773 asynchronous HTTP request, please define a `callback` function 5774 to be invoked when receiving the response. 5775 >>> def callback_function(response): 5776 >>> pprint(response) 5777 >>> 5778 >>> thread = api.list_settings(account_id, callback=callback_function) 5779 5780 :param callback function: The callback function 5781 for asynchronous request. (optional) 5782 :param str account_id: The external account number (int) or account ID Guid. (required) 5783 :return: AccountSettingsInformation 5784 If the method is called asynchronously, 5785 returns the request thread. 5786 """ 5787 kwargs['_return_http_data_only'] = True 5788 if kwargs.get('callback'): 5789 return self.list_settings_with_http_info(account_id, **kwargs) 5790 else: 5791 (data) = self.list_settings_with_http_info(account_id, **kwargs) 5792 return data 5793 5794 def list_settings_with_http_info(self, account_id, **kwargs): 5795 """ 5796 Gets account settings information. 5797 Retrieves the account settings information for the specified account. 5798 This method makes a synchronous HTTP request by default. To make an 5799 asynchronous HTTP request, please define a `callback` function 5800 to be invoked when receiving the response. 5801 >>> def callback_function(response): 5802 >>> pprint(response) 5803 >>> 5804 >>> thread = api.list_settings_with_http_info(account_id, callback=callback_function) 5805 5806 :param callback function: The callback function 5807 for asynchronous request. (optional) 5808 :param str account_id: The external account number (int) or account ID Guid. (required) 5809 :return: AccountSettingsInformation 5810 If the method is called asynchronously, 5811 returns the request thread. 5812 """ 5813 5814 all_params = ['account_id'] 5815 all_params.append('callback') 5816 all_params.append('_return_http_data_only') 5817 all_params.append('_preload_content') 5818 all_params.append('_request_timeout') 5819 5820 params = locals() 5821 for key, val in iteritems(params['kwargs']): 5822 if key not in all_params: 5823 raise TypeError( 5824 "Got an unexpected keyword argument '%s'" 5825 " to method list_settings" % key 5826 ) 5827 params[key] = val 5828 del params['kwargs'] 5829 # verify the required parameter 'account_id' is set 5830 if ('account_id' not in params) or (params['account_id'] is None): 5831 raise ValueError("Missing the required parameter `account_id` when calling `list_settings`") 5832 5833 5834 collection_formats = {} 5835 5836 resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json') 5837 path_params = {} 5838 if 'account_id' in params: 5839 path_params['accountId'] = params['account_id'] 5840 5841 query_params = {} 5842 5843 header_params = {} 5844 5845 form_params = [] 5846 local_var_files = {} 5847 5848 body_params = None 5849 # HTTP header `Accept` 5850 header_params['Accept'] = self.api_client.\ 5851 select_header_accept(['application/json']) 5852 5853 # Authentication setting 5854 auth_settings = [] 5855 5856 return self.api_client.call_api(resource_path, 'GET', 5857 path_params, 5858 query_params, 5859 header_params, 5860 body=body_params, 5861 post_params=form_params, 5862 files=local_var_files, 5863 response_type='AccountSettingsInformation', 5864 auth_settings=auth_settings, 5865 callback=params.get('callback'), 5866 _return_http_data_only=params.get('_return_http_data_only'), 5867 _preload_content=params.get('_preload_content', True), 5868 _request_timeout=params.get('_request_timeout'), 5869 collection_formats=collection_formats) 5870 5871 def list_shared_access(self, account_id, **kwargs): 5872 """ 5873 Reserved: Gets the shared item status for one or more users. 5874 Reserved: Retrieves shared item status for one or more users and types of items. Users with account administration privileges can retrieve shared access information for all account users. Users without account administrator privileges can only retrieve shared access information for themselves and the returned information is limited to the retrieving the status of all members of the account that are sharing their folders to the user. This is equivalent to setting the shared=shared_from. 5875 This method makes a synchronous HTTP request by default. To make an 5876 asynchronous HTTP request, please define a `callback` function 5877 to be invoked when receiving the response. 5878 >>> def callback_function(response): 5879 >>> pprint(response) 5880 >>> 5881 >>> thread = api.list_shared_access(account_id, callback=callback_function) 5882 5883 :param callback function: The callback function 5884 for asynchronous request. (optional) 5885 :param str account_id: The external account number (int) or account ID Guid. (required) 5886 :param str count: Specifies maximum number of results included in the response. If no value is specified, this defaults to 1000. 5887 :param str envelopes_not_shared_user_status: 5888 :param str folder_ids: 5889 :param str item_type: Specifies the type of shared item being requested. The accepted values are: -envelopes: returns information about envelope sharing between users. 5890 :param str search_text: This can be used to filter user names in the response. The wild-card '*' (asterisk) can be used around the string. 5891 :param str shared: Specifies which users should be included in the response. Multiple values can be used in the query by using a comma separated list of shared values. If the requestor does not have account administrator privileges, the shared_to value is used. Requestors that do not have account administrator privileges can only use the shared_to, any other setting will result in an error. The accepted values are: -not_shared: Returns account users that the specified item type is not being shared with and that are not sharing the specified item type with the user. User X (Share) X Account user -shared_to: Returns account users that the specified item type is not being shared with and who are sharing the specified item type with the user (only shared to the user). User X (Share) Account user -shared_from: Returns account users that the specified item type is being shared with and who are not sharing the specified item type with the user (only shared from the user). User (Share) >> Account user -shared_to_and_from: Returns account users that the specified item type is being shared with and who are sharing the specified item type with the user. User << (Share) >> Account user 5892 :param str start_position: If the response set exceeds Count, this can be used to specify that the method should return users starting at the specified index. The first index is 0, and should be used in the first GET call. Typically this number is a multiple of Count. If no value is specified, this defaults to be 0. 5893 :param str user_ids: A comma separated list of userIds for whom the shared item information is being requested. 5894 :return: AccountSharedAccess 5895 If the method is called asynchronously, 5896 returns the request thread. 5897 """ 5898 kwargs['_return_http_data_only'] = True 5899 if kwargs.get('callback'): 5900 return self.list_shared_access_with_http_info(account_id, **kwargs) 5901 else: 5902 (data) = self.list_shared_access_with_http_info(account_id, **kwargs) 5903 return data 5904 5905 def list_shared_access_with_http_info(self, account_id, **kwargs): 5906 """ 5907 Reserved: Gets the shared item status for one or more users. 5908 Reserved: Retrieves shared item status for one or more users and types of items. Users with account administration privileges can retrieve shared access information for all account users. Users without account administrator privileges can only retrieve shared access information for themselves and the returned information is limited to the retrieving the status of all members of the account that are sharing their folders to the user. This is equivalent to setting the shared=shared_from. 5909 This method makes a synchronous HTTP request by default. To make an 5910 asynchronous HTTP request, please define a `callback` function 5911 to be invoked when receiving the response. 5912 >>> def callback_function(response): 5913 >>> pprint(response) 5914 >>> 5915 >>> thread = api.list_shared_access_with_http_info(account_id, callback=callback_function) 5916 5917 :param callback function: The callback function 5918 for asynchronous request. (optional) 5919 :param str account_id: The external account number (int) or account ID Guid. (required) 5920 :param str count: Specifies maximum number of results included in the response. If no value is specified, this defaults to 1000. 5921 :param str envelopes_not_shared_user_status: 5922 :param str folder_ids: 5923 :param str item_type: Specifies the type of shared item being requested. The accepted values are: -envelopes: returns information about envelope sharing between users. 5924 :param str search_text: This can be used to filter user names in the response. The wild-card '*' (asterisk) can be used around the string. 5925 :param str shared: Specifies which users should be included in the response. Multiple values can be used in the query by using a comma separated list of shared values. If the requestor does not have account administrator privileges, the shared_to value is used. Requestors that do not have account administrator privileges can only use the shared_to, any other setting will result in an error. The accepted values are: -not_shared: Returns account users that the specified item type is not being shared with and that are not sharing the specified item type with the user. User X (Share) X Account user -shared_to: Returns account users that the specified item type is not being shared with and who are sharing the specified item type with the user (only shared to the user). User X (Share) Account user -shared_from: Returns account users that the specified item type is being shared with and who are not sharing the specified item type with the user (only shared from the user). User (Share) >> Account user -shared_to_and_from: Returns account users that the specified item type is being shared with and who are sharing the specified item type with the user. User << (Share) >> Account user 5926 :param str start_position: If the response set exceeds Count, this can be used to specify that the method should return users starting at the specified index. The first index is 0, and should be used in the first GET call. Typically this number is a multiple of Count. If no value is specified, this defaults to be 0. 5927 :param str user_ids: A comma separated list of userIds for whom the shared item information is being requested. 5928 :return: AccountSharedAccess 5929 If the method is called asynchronously, 5930 returns the request thread. 5931 """ 5932 5933 all_params = ['account_id', 'count', 'envelopes_not_shared_user_status', 'folder_ids', 'item_type', 'search_text', 'shared', 'start_position', 'user_ids'] 5934 all_params.append('callback') 5935 all_params.append('_return_http_data_only') 5936 all_params.append('_preload_content') 5937 all_params.append('_request_timeout') 5938 5939 params = locals() 5940 for key, val in iteritems(params['kwargs']): 5941 if key not in all_params: 5942 raise TypeError( 5943 "Got an unexpected keyword argument '%s'" 5944 " to method list_shared_access" % key 5945 ) 5946 params[key] = val 5947 del params['kwargs'] 5948 # verify the required parameter 'account_id' is set 5949 if ('account_id' not in params) or (params['account_id'] is None): 5950 raise ValueError("Missing the required parameter `account_id` when calling `list_shared_access`") 5951 5952 5953 collection_formats = {} 5954 5955 resource_path = '/v2.1/accounts/{accountId}/shared_access'.replace('{format}', 'json') 5956 path_params = {} 5957 if 'account_id' in params: 5958 path_params['accountId'] = params['account_id'] 5959 5960 query_params = {} 5961 if 'count' in params: 5962 query_params['count'] = params['count'] 5963 if 'envelopes_not_shared_user_status' in params: 5964 query_params['envelopes_not_shared_user_status'] = params['envelopes_not_shared_user_status'] 5965 if 'folder_ids' in params: 5966 query_params['folder_ids'] = params['folder_ids'] 5967 if 'item_type' in params: 5968 query_params['item_type'] = params['item_type'] 5969 if 'search_text' in params: 5970 query_params['search_text'] = params['search_text'] 5971 if 'shared' in params: 5972 query_params['shared'] = params['shared'] 5973 if 'start_position' in params: 5974 query_params['start_position'] = params['start_position'] 5975 if 'user_ids' in params: 5976 query_params['user_ids'] = params['user_ids'] 5977 5978 header_params = {} 5979 5980 form_params = [] 5981 local_var_files = {} 5982 5983 body_params = None 5984 # HTTP header `Accept` 5985 header_params['Accept'] = self.api_client.\ 5986 select_header_accept(['application/json']) 5987 5988 # Authentication setting 5989 auth_settings = [] 5990 5991 return self.api_client.call_api(resource_path, 'GET', 5992 path_params, 5993 query_params, 5994 header_params, 5995 body=body_params, 5996 post_params=form_params, 5997 files=local_var_files, 5998 response_type='AccountSharedAccess', 5999 auth_settings=auth_settings, 6000 callback=params.get('callback'), 6001 _return_http_data_only=params.get('_return_http_data_only'), 6002 _preload_content=params.get('_preload_content', True), 6003 _request_timeout=params.get('_request_timeout'), 6004 collection_formats=collection_formats) 6005 6006 def list_signature_providers(self, account_id, **kwargs): 6007 """ 6008 Returns Account available signature providers for specified account. 6009 Returns a list of signature providers that the specified account can use. 6010 This method makes a synchronous HTTP request by default. To make an 6011 asynchronous HTTP request, please define a `callback` function 6012 to be invoked when receiving the response. 6013 >>> def callback_function(response): 6014 >>> pprint(response) 6015 >>> 6016 >>> thread = api.list_signature_providers(account_id, callback=callback_function) 6017 6018 :param callback function: The callback function 6019 for asynchronous request. (optional) 6020 :param str account_id: The external account number (int) or account ID Guid. (required) 6021 :return: AccountSignatureProviders 6022 If the method is called asynchronously, 6023 returns the request thread. 6024 """ 6025 kwargs['_return_http_data_only'] = True 6026 if kwargs.get('callback'): 6027 return self.list_signature_providers_with_http_info(account_id, **kwargs) 6028 else: 6029 (data) = self.list_signature_providers_with_http_info(account_id, **kwargs) 6030 return data 6031 6032 def list_signature_providers_with_http_info(self, account_id, **kwargs): 6033 """ 6034 Returns Account available signature providers for specified account. 6035 Returns a list of signature providers that the specified account can use. 6036 This method makes a synchronous HTTP request by default. To make an 6037 asynchronous HTTP request, please define a `callback` function 6038 to be invoked when receiving the response. 6039 >>> def callback_function(response): 6040 >>> pprint(response) 6041 >>> 6042 >>> thread = api.list_signature_providers_with_http_info(account_id, callback=callback_function) 6043 6044 :param callback function: The callback function 6045 for asynchronous request. (optional) 6046 :param str account_id: The external account number (int) or account ID Guid. (required) 6047 :return: AccountSignatureProviders 6048 If the method is called asynchronously, 6049 returns the request thread. 6050 """ 6051 6052 all_params = ['account_id'] 6053 all_params.append('callback') 6054 all_params.append('_return_http_data_only') 6055 all_params.append('_preload_content') 6056 all_params.append('_request_timeout') 6057 6058 params = locals() 6059 for key, val in iteritems(params['kwargs']): 6060 if key not in all_params: 6061 raise TypeError( 6062 "Got an unexpected keyword argument '%s'" 6063 " to method list_signature_providers" % key 6064 ) 6065 params[key] = val 6066 del params['kwargs'] 6067 # verify the required parameter 'account_id' is set 6068 if ('account_id' not in params) or (params['account_id'] is None): 6069 raise ValueError("Missing the required parameter `account_id` when calling `list_signature_providers`") 6070 6071 6072 collection_formats = {} 6073 6074 resource_path = '/v2.1/accounts/{accountId}/signatureProviders'.replace('{format}', 'json') 6075 path_params = {} 6076 if 'account_id' in params: 6077 path_params['accountId'] = params['account_id'] 6078 6079 query_params = {} 6080 6081 header_params = {} 6082 6083 form_params = [] 6084 local_var_files = {} 6085 6086 body_params = None 6087 # HTTP header `Accept` 6088 header_params['Accept'] = self.api_client.\ 6089 select_header_accept(['application/json']) 6090 6091 # Authentication setting 6092 auth_settings = [] 6093 6094 return self.api_client.call_api(resource_path, 'GET', 6095 path_params, 6096 query_params, 6097 header_params, 6098 body=body_params, 6099 post_params=form_params, 6100 files=local_var_files, 6101 response_type='AccountSignatureProviders', 6102 auth_settings=auth_settings, 6103 callback=params.get('callback'), 6104 _return_http_data_only=params.get('_return_http_data_only'), 6105 _preload_content=params.get('_preload_content', True), 6106 _request_timeout=params.get('_request_timeout'), 6107 collection_formats=collection_formats) 6108 6109 def list_unsupported_file_types(self, account_id, **kwargs): 6110 """ 6111 Gets a list of unsupported file types. 6112 Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system. 6113 This method makes a synchronous HTTP request by default. To make an 6114 asynchronous HTTP request, please define a `callback` function 6115 to be invoked when receiving the response. 6116 >>> def callback_function(response): 6117 >>> pprint(response) 6118 >>> 6119 >>> thread = api.list_unsupported_file_types(account_id, callback=callback_function) 6120 6121 :param callback function: The callback function 6122 for asynchronous request. (optional) 6123 :param str account_id: The external account number (int) or account ID Guid. (required) 6124 :return: FileTypeList 6125 If the method is called asynchronously, 6126 returns the request thread. 6127 """ 6128 kwargs['_return_http_data_only'] = True 6129 if kwargs.get('callback'): 6130 return self.list_unsupported_file_types_with_http_info(account_id, **kwargs) 6131 else: 6132 (data) = self.list_unsupported_file_types_with_http_info(account_id, **kwargs) 6133 return data 6134 6135 def list_unsupported_file_types_with_http_info(self, account_id, **kwargs): 6136 """ 6137 Gets a list of unsupported file types. 6138 Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system. 6139 This method makes a synchronous HTTP request by default. To make an 6140 asynchronous HTTP request, please define a `callback` function 6141 to be invoked when receiving the response. 6142 >>> def callback_function(response): 6143 >>> pprint(response) 6144 >>> 6145 >>> thread = api.list_unsupported_file_types_with_http_info(account_id, callback=callback_function) 6146 6147 :param callback function: The callback function 6148 for asynchronous request. (optional) 6149 :param str account_id: The external account number (int) or account ID Guid. (required) 6150 :return: FileTypeList 6151 If the method is called asynchronously, 6152 returns the request thread. 6153 """ 6154 6155 all_params = ['account_id'] 6156 all_params.append('callback') 6157 all_params.append('_return_http_data_only') 6158 all_params.append('_preload_content') 6159 all_params.append('_request_timeout') 6160 6161 params = locals() 6162 for key, val in iteritems(params['kwargs']): 6163 if key not in all_params: 6164 raise TypeError( 6165 "Got an unexpected keyword argument '%s'" 6166 " to method list_unsupported_file_types" % key 6167 ) 6168 params[key] = val 6169 del params['kwargs'] 6170 # verify the required parameter 'account_id' is set 6171 if ('account_id' not in params) or (params['account_id'] is None): 6172 raise ValueError("Missing the required parameter `account_id` when calling `list_unsupported_file_types`") 6173 6174 6175 collection_formats = {} 6176 6177 resource_path = '/v2.1/accounts/{accountId}/unsupported_file_types'.replace('{format}', 'json') 6178 path_params = {} 6179 if 'account_id' in params: 6180 path_params['accountId'] = params['account_id'] 6181 6182 query_params = {} 6183 6184 header_params = {} 6185 6186 form_params = [] 6187 local_var_files = {} 6188 6189 body_params = None 6190 # HTTP header `Accept` 6191 header_params['Accept'] = self.api_client.\ 6192 select_header_accept(['application/json']) 6193 6194 # Authentication setting 6195 auth_settings = [] 6196 6197 return self.api_client.call_api(resource_path, 'GET', 6198 path_params, 6199 query_params, 6200 header_params, 6201 body=body_params, 6202 post_params=form_params, 6203 files=local_var_files, 6204 response_type='FileTypeList', 6205 auth_settings=auth_settings, 6206 callback=params.get('callback'), 6207 _return_http_data_only=params.get('_return_http_data_only'), 6208 _preload_content=params.get('_preload_content', True), 6209 _request_timeout=params.get('_request_timeout'), 6210 collection_formats=collection_formats) 6211 6212 def un_favorite_template(self, account_id, **kwargs): 6213 """ 6214 Unfavorite a template 6215 6216 This method makes a synchronous HTTP request by default. To make an 6217 asynchronous HTTP request, please define a `callback` function 6218 to be invoked when receiving the response. 6219 >>> def callback_function(response): 6220 >>> pprint(response) 6221 >>> 6222 >>> thread = api.un_favorite_template(account_id, callback=callback_function) 6223 6224 :param callback function: The callback function 6225 for asynchronous request. (optional) 6226 :param str account_id: The external account number (int) or account ID Guid. (required) 6227 :param FavoriteTemplatesInfo favorite_templates_info: 6228 :return: FavoriteTemplatesInfo 6229 If the method is called asynchronously, 6230 returns the request thread. 6231 """ 6232 kwargs['_return_http_data_only'] = True 6233 if kwargs.get('callback'): 6234 return self.un_favorite_template_with_http_info(account_id, **kwargs) 6235 else: 6236 (data) = self.un_favorite_template_with_http_info(account_id, **kwargs) 6237 return data 6238 6239 def un_favorite_template_with_http_info(self, account_id, **kwargs): 6240 """ 6241 Unfavorite a template 6242 6243 This method makes a synchronous HTTP request by default. To make an 6244 asynchronous HTTP request, please define a `callback` function 6245 to be invoked when receiving the response. 6246 >>> def callback_function(response): 6247 >>> pprint(response) 6248 >>> 6249 >>> thread = api.un_favorite_template_with_http_info(account_id, callback=callback_function) 6250 6251 :param callback function: The callback function 6252 for asynchronous request. (optional) 6253 :param str account_id: The external account number (int) or account ID Guid. (required) 6254 :param FavoriteTemplatesInfo favorite_templates_info: 6255 :return: FavoriteTemplatesInfo 6256 If the method is called asynchronously, 6257 returns the request thread. 6258 """ 6259 6260 all_params = ['account_id', 'favorite_templates_info'] 6261 all_params.append('callback') 6262 all_params.append('_return_http_data_only') 6263 all_params.append('_preload_content') 6264 all_params.append('_request_timeout') 6265 6266 params = locals() 6267 for key, val in iteritems(params['kwargs']): 6268 if key not in all_params: 6269 raise TypeError( 6270 "Got an unexpected keyword argument '%s'" 6271 " to method un_favorite_template" % key 6272 ) 6273 params[key] = val 6274 del params['kwargs'] 6275 # verify the required parameter 'account_id' is set 6276 if ('account_id' not in params) or (params['account_id'] is None): 6277 raise ValueError("Missing the required parameter `account_id` when calling `un_favorite_template`") 6278 6279 6280 collection_formats = {} 6281 6282 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 6283 path_params = {} 6284 if 'account_id' in params: 6285 path_params['accountId'] = params['account_id'] 6286 6287 query_params = {} 6288 6289 header_params = {} 6290 6291 form_params = [] 6292 local_var_files = {} 6293 6294 body_params = None 6295 if 'favorite_templates_info' in params: 6296 body_params = params['favorite_templates_info'] 6297 # HTTP header `Accept` 6298 header_params['Accept'] = self.api_client.\ 6299 select_header_accept(['application/json']) 6300 6301 # Authentication setting 6302 auth_settings = [] 6303 6304 return self.api_client.call_api(resource_path, 'DELETE', 6305 path_params, 6306 query_params, 6307 header_params, 6308 body=body_params, 6309 post_params=form_params, 6310 files=local_var_files, 6311 response_type='FavoriteTemplatesInfo', 6312 auth_settings=auth_settings, 6313 callback=params.get('callback'), 6314 _return_http_data_only=params.get('_return_http_data_only'), 6315 _preload_content=params.get('_preload_content', True), 6316 _request_timeout=params.get('_request_timeout'), 6317 collection_formats=collection_formats) 6318 6319 def update_account_signature(self, account_id, **kwargs): 6320 """ 6321 Updates a account signature. 6322 6323 This method makes a synchronous HTTP request by default. To make an 6324 asynchronous HTTP request, please define a `callback` function 6325 to be invoked when receiving the response. 6326 >>> def callback_function(response): 6327 >>> pprint(response) 6328 >>> 6329 >>> thread = api.update_account_signature(account_id, callback=callback_function) 6330 6331 :param callback function: The callback function 6332 for asynchronous request. (optional) 6333 :param str account_id: The external account number (int) or account ID Guid. (required) 6334 :param AccountSignaturesInformation account_signatures_information: 6335 :return: AccountSignaturesInformation 6336 If the method is called asynchronously, 6337 returns the request thread. 6338 """ 6339 kwargs['_return_http_data_only'] = True 6340 if kwargs.get('callback'): 6341 return self.update_account_signature_with_http_info(account_id, **kwargs) 6342 else: 6343 (data) = self.update_account_signature_with_http_info(account_id, **kwargs) 6344 return data 6345 6346 def update_account_signature_with_http_info(self, account_id, **kwargs): 6347 """ 6348 Updates a account signature. 6349 6350 This method makes a synchronous HTTP request by default. To make an 6351 asynchronous HTTP request, please define a `callback` function 6352 to be invoked when receiving the response. 6353 >>> def callback_function(response): 6354 >>> pprint(response) 6355 >>> 6356 >>> thread = api.update_account_signature_with_http_info(account_id, callback=callback_function) 6357 6358 :param callback function: The callback function 6359 for asynchronous request. (optional) 6360 :param str account_id: The external account number (int) or account ID Guid. (required) 6361 :param AccountSignaturesInformation account_signatures_information: 6362 :return: AccountSignaturesInformation 6363 If the method is called asynchronously, 6364 returns the request thread. 6365 """ 6366 6367 all_params = ['account_id', 'account_signatures_information'] 6368 all_params.append('callback') 6369 all_params.append('_return_http_data_only') 6370 all_params.append('_preload_content') 6371 all_params.append('_request_timeout') 6372 6373 params = locals() 6374 for key, val in iteritems(params['kwargs']): 6375 if key not in all_params: 6376 raise TypeError( 6377 "Got an unexpected keyword argument '%s'" 6378 " to method update_account_signature" % key 6379 ) 6380 params[key] = val 6381 del params['kwargs'] 6382 # verify the required parameter 'account_id' is set 6383 if ('account_id' not in params) or (params['account_id'] is None): 6384 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature`") 6385 6386 6387 collection_formats = {} 6388 6389 resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json') 6390 path_params = {} 6391 if 'account_id' in params: 6392 path_params['accountId'] = params['account_id'] 6393 6394 query_params = {} 6395 6396 header_params = {} 6397 6398 form_params = [] 6399 local_var_files = {} 6400 6401 body_params = None 6402 if 'account_signatures_information' in params: 6403 body_params = params['account_signatures_information'] 6404 # HTTP header `Accept` 6405 header_params['Accept'] = self.api_client.\ 6406 select_header_accept(['application/json']) 6407 6408 # Authentication setting 6409 auth_settings = [] 6410 6411 return self.api_client.call_api(resource_path, 'PUT', 6412 path_params, 6413 query_params, 6414 header_params, 6415 body=body_params, 6416 post_params=form_params, 6417 files=local_var_files, 6418 response_type='AccountSignaturesInformation', 6419 auth_settings=auth_settings, 6420 callback=params.get('callback'), 6421 _return_http_data_only=params.get('_return_http_data_only'), 6422 _preload_content=params.get('_preload_content', True), 6423 _request_timeout=params.get('_request_timeout'), 6424 collection_formats=collection_formats) 6425 6426 def update_account_signature_by_id(self, account_id, signature_id, **kwargs): 6427 """ 6428 Updates a account signature. 6429 6430 This method makes a synchronous HTTP request by default. To make an 6431 asynchronous HTTP request, please define a `callback` function 6432 to be invoked when receiving the response. 6433 >>> def callback_function(response): 6434 >>> pprint(response) 6435 >>> 6436 >>> thread = api.update_account_signature_by_id(account_id, signature_id, callback=callback_function) 6437 6438 :param callback function: The callback function 6439 for asynchronous request. (optional) 6440 :param str account_id: The external account number (int) or account ID Guid. (required) 6441 :param str signature_id: The ID of the signature being accessed. (required) 6442 :param str close_existing_signature: 6443 :param AccountSignatureDefinition account_signature_definition: 6444 :return: AccountSignature 6445 If the method is called asynchronously, 6446 returns the request thread. 6447 """ 6448 kwargs['_return_http_data_only'] = True 6449 if kwargs.get('callback'): 6450 return self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs) 6451 else: 6452 (data) = self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs) 6453 return data 6454 6455 def update_account_signature_by_id_with_http_info(self, account_id, signature_id, **kwargs): 6456 """ 6457 Updates a account signature. 6458 6459 This method makes a synchronous HTTP request by default. To make an 6460 asynchronous HTTP request, please define a `callback` function 6461 to be invoked when receiving the response. 6462 >>> def callback_function(response): 6463 >>> pprint(response) 6464 >>> 6465 >>> thread = api.update_account_signature_by_id_with_http_info(account_id, signature_id, callback=callback_function) 6466 6467 :param callback function: The callback function 6468 for asynchronous request. (optional) 6469 :param str account_id: The external account number (int) or account ID Guid. (required) 6470 :param str signature_id: The ID of the signature being accessed. (required) 6471 :param str close_existing_signature: 6472 :param AccountSignatureDefinition account_signature_definition: 6473 :return: AccountSignature 6474 If the method is called asynchronously, 6475 returns the request thread. 6476 """ 6477 6478 all_params = ['account_id', 'signature_id', 'close_existing_signature', 'account_signature_definition'] 6479 all_params.append('callback') 6480 all_params.append('_return_http_data_only') 6481 all_params.append('_preload_content') 6482 all_params.append('_request_timeout') 6483 6484 params = locals() 6485 for key, val in iteritems(params['kwargs']): 6486 if key not in all_params: 6487 raise TypeError( 6488 "Got an unexpected keyword argument '%s'" 6489 " to method update_account_signature_by_id" % key 6490 ) 6491 params[key] = val 6492 del params['kwargs'] 6493 # verify the required parameter 'account_id' is set 6494 if ('account_id' not in params) or (params['account_id'] is None): 6495 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_by_id`") 6496 # verify the required parameter 'signature_id' is set 6497 if ('signature_id' not in params) or (params['signature_id'] is None): 6498 raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_by_id`") 6499 6500 6501 collection_formats = {} 6502 6503 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 6504 path_params = {} 6505 if 'account_id' in params: 6506 path_params['accountId'] = params['account_id'] 6507 if 'signature_id' in params: 6508 path_params['signatureId'] = params['signature_id'] 6509 6510 query_params = {} 6511 if 'close_existing_signature' in params: 6512 query_params['close_existing_signature'] = params['close_existing_signature'] 6513 6514 header_params = {} 6515 6516 form_params = [] 6517 local_var_files = {} 6518 6519 body_params = None 6520 if 'account_signature_definition' in params: 6521 body_params = params['account_signature_definition'] 6522 # HTTP header `Accept` 6523 header_params['Accept'] = self.api_client.\ 6524 select_header_accept(['application/json']) 6525 6526 # Authentication setting 6527 auth_settings = [] 6528 6529 return self.api_client.call_api(resource_path, 'PUT', 6530 path_params, 6531 query_params, 6532 header_params, 6533 body=body_params, 6534 post_params=form_params, 6535 files=local_var_files, 6536 response_type='AccountSignature', 6537 auth_settings=auth_settings, 6538 callback=params.get('callback'), 6539 _return_http_data_only=params.get('_return_http_data_only'), 6540 _preload_content=params.get('_preload_content', True), 6541 _request_timeout=params.get('_request_timeout'), 6542 collection_formats=collection_formats) 6543 6544 def update_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 6545 """ 6546 Sets a signature, initials, or stamps image. 6547 6548 This method makes a synchronous HTTP request by default. To make an 6549 asynchronous HTTP request, please define a `callback` function 6550 to be invoked when receiving the response. 6551 >>> def callback_function(response): 6552 >>> pprint(response) 6553 >>> 6554 >>> thread = api.update_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 6555 6556 :param callback function: The callback function 6557 for asynchronous request. (optional) 6558 :param str account_id: The external account number (int) or account ID Guid. (required) 6559 :param str image_type: One of **signature_image** or **initials_image**. (required) 6560 :param str signature_id: The ID of the signature being accessed. (required) 6561 :param str transparent_png: 6562 :return: AccountSignature 6563 If the method is called asynchronously, 6564 returns the request thread. 6565 """ 6566 kwargs['_return_http_data_only'] = True 6567 if kwargs.get('callback'): 6568 return self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 6569 else: 6570 (data) = self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 6571 return data 6572 6573 def update_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 6574 """ 6575 Sets a signature, initials, or stamps image. 6576 6577 This method makes a synchronous HTTP request by default. To make an 6578 asynchronous HTTP request, please define a `callback` function 6579 to be invoked when receiving the response. 6580 >>> def callback_function(response): 6581 >>> pprint(response) 6582 >>> 6583 >>> thread = api.update_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 6584 6585 :param callback function: The callback function 6586 for asynchronous request. (optional) 6587 :param str account_id: The external account number (int) or account ID Guid. (required) 6588 :param str image_type: One of **signature_image** or **initials_image**. (required) 6589 :param str signature_id: The ID of the signature being accessed. (required) 6590 :param str transparent_png: 6591 :return: AccountSignature 6592 If the method is called asynchronously, 6593 returns the request thread. 6594 """ 6595 6596 all_params = ['account_id', 'image_type', 'signature_id', 'transparent_png'] 6597 all_params.append('callback') 6598 all_params.append('_return_http_data_only') 6599 all_params.append('_preload_content') 6600 all_params.append('_request_timeout') 6601 6602 params = locals() 6603 for key, val in iteritems(params['kwargs']): 6604 if key not in all_params: 6605 raise TypeError( 6606 "Got an unexpected keyword argument '%s'" 6607 " to method update_account_signature_image" % key 6608 ) 6609 params[key] = val 6610 del params['kwargs'] 6611 # verify the required parameter 'account_id' is set 6612 if ('account_id' not in params) or (params['account_id'] is None): 6613 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_image`") 6614 # verify the required parameter 'image_type' is set 6615 if ('image_type' not in params) or (params['image_type'] is None): 6616 raise ValueError("Missing the required parameter `image_type` when calling `update_account_signature_image`") 6617 # verify the required parameter 'signature_id' is set 6618 if ('signature_id' not in params) or (params['signature_id'] is None): 6619 raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_image`") 6620 6621 6622 collection_formats = {} 6623 6624 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 6625 path_params = {} 6626 if 'account_id' in params: 6627 path_params['accountId'] = params['account_id'] 6628 if 'image_type' in params: 6629 path_params['imageType'] = params['image_type'] 6630 if 'signature_id' in params: 6631 path_params['signatureId'] = params['signature_id'] 6632 6633 query_params = {} 6634 if 'transparent_png' in params: 6635 query_params['transparent_png'] = params['transparent_png'] 6636 6637 header_params = {} 6638 6639 form_params = [] 6640 local_var_files = {} 6641 6642 body_params = None 6643 # HTTP header `Accept` 6644 header_params['Accept'] = self.api_client.\ 6645 select_header_accept(['application/json']) 6646 6647 # HTTP header `Content-Type` 6648 header_params['Content-Type'] = self.api_client.\ 6649 select_header_content_type(['image/gif']) 6650 6651 # Authentication setting 6652 auth_settings = [] 6653 6654 return self.api_client.call_api(resource_path, 'PUT', 6655 path_params, 6656 query_params, 6657 header_params, 6658 body=body_params, 6659 post_params=form_params, 6660 files=local_var_files, 6661 response_type='AccountSignature', 6662 auth_settings=auth_settings, 6663 callback=params.get('callback'), 6664 _return_http_data_only=params.get('_return_http_data_only'), 6665 _preload_content=params.get('_preload_content', True), 6666 _request_timeout=params.get('_request_timeout'), 6667 collection_formats=collection_formats) 6668 6669 def update_account_tab_settings(self, account_id, **kwargs): 6670 """ 6671 Modifies tab settings for specified account 6672 This method modifies the tab types and tab functionality that is enabled for an account. 6673 This method makes a synchronous HTTP request by default. To make an 6674 asynchronous HTTP request, please define a `callback` function 6675 to be invoked when receiving the response. 6676 >>> def callback_function(response): 6677 >>> pprint(response) 6678 >>> 6679 >>> thread = api.update_account_tab_settings(account_id, callback=callback_function) 6680 6681 :param callback function: The callback function 6682 for asynchronous request. (optional) 6683 :param str account_id: The external account number (int) or account ID Guid. (required) 6684 :param TabAccountSettings tab_account_settings: 6685 :return: TabAccountSettings 6686 If the method is called asynchronously, 6687 returns the request thread. 6688 """ 6689 kwargs['_return_http_data_only'] = True 6690 if kwargs.get('callback'): 6691 return self.update_account_tab_settings_with_http_info(account_id, **kwargs) 6692 else: 6693 (data) = self.update_account_tab_settings_with_http_info(account_id, **kwargs) 6694 return data 6695 6696 def update_account_tab_settings_with_http_info(self, account_id, **kwargs): 6697 """ 6698 Modifies tab settings for specified account 6699 This method modifies the tab types and tab functionality that is enabled for an account. 6700 This method makes a synchronous HTTP request by default. To make an 6701 asynchronous HTTP request, please define a `callback` function 6702 to be invoked when receiving the response. 6703 >>> def callback_function(response): 6704 >>> pprint(response) 6705 >>> 6706 >>> thread = api.update_account_tab_settings_with_http_info(account_id, callback=callback_function) 6707 6708 :param callback function: The callback function 6709 for asynchronous request. (optional) 6710 :param str account_id: The external account number (int) or account ID Guid. (required) 6711 :param TabAccountSettings tab_account_settings: 6712 :return: TabAccountSettings 6713 If the method is called asynchronously, 6714 returns the request thread. 6715 """ 6716 6717 all_params = ['account_id', 'tab_account_settings'] 6718 all_params.append('callback') 6719 all_params.append('_return_http_data_only') 6720 all_params.append('_preload_content') 6721 all_params.append('_request_timeout') 6722 6723 params = locals() 6724 for key, val in iteritems(params['kwargs']): 6725 if key not in all_params: 6726 raise TypeError( 6727 "Got an unexpected keyword argument '%s'" 6728 " to method update_account_tab_settings" % key 6729 ) 6730 params[key] = val 6731 del params['kwargs'] 6732 # verify the required parameter 'account_id' is set 6733 if ('account_id' not in params) or (params['account_id'] is None): 6734 raise ValueError("Missing the required parameter `account_id` when calling `update_account_tab_settings`") 6735 6736 6737 collection_formats = {} 6738 6739 resource_path = '/v2.1/accounts/{accountId}/settings/tabs'.replace('{format}', 'json') 6740 path_params = {} 6741 if 'account_id' in params: 6742 path_params['accountId'] = params['account_id'] 6743 6744 query_params = {} 6745 6746 header_params = {} 6747 6748 form_params = [] 6749 local_var_files = {} 6750 6751 body_params = None 6752 if 'tab_account_settings' in params: 6753 body_params = params['tab_account_settings'] 6754 # HTTP header `Accept` 6755 header_params['Accept'] = self.api_client.\ 6756 select_header_accept(['application/json']) 6757 6758 # Authentication setting 6759 auth_settings = [] 6760 6761 return self.api_client.call_api(resource_path, 'PUT', 6762 path_params, 6763 query_params, 6764 header_params, 6765 body=body_params, 6766 post_params=form_params, 6767 files=local_var_files, 6768 response_type='TabAccountSettings', 6769 auth_settings=auth_settings, 6770 callback=params.get('callback'), 6771 _return_http_data_only=params.get('_return_http_data_only'), 6772 _preload_content=params.get('_preload_content', True), 6773 _request_timeout=params.get('_request_timeout'), 6774 collection_formats=collection_formats) 6775 6776 def update_brand(self, account_id, brand_id, **kwargs): 6777 """ 6778 Updates an existing brand. 6779 This method updates an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 6780 This method makes a synchronous HTTP request by default. To make an 6781 asynchronous HTTP request, please define a `callback` function 6782 to be invoked when receiving the response. 6783 >>> def callback_function(response): 6784 >>> pprint(response) 6785 >>> 6786 >>> thread = api.update_brand(account_id, brand_id, callback=callback_function) 6787 6788 :param callback function: The callback function 6789 for asynchronous request. (optional) 6790 :param str account_id: The external account number (int) or account ID Guid. (required) 6791 :param str brand_id: The unique identifier of a brand. (required) 6792 :param str replace_brand: 6793 :param Brand brand: 6794 :return: Brand 6795 If the method is called asynchronously, 6796 returns the request thread. 6797 """ 6798 kwargs['_return_http_data_only'] = True 6799 if kwargs.get('callback'): 6800 return self.update_brand_with_http_info(account_id, brand_id, **kwargs) 6801 else: 6802 (data) = self.update_brand_with_http_info(account_id, brand_id, **kwargs) 6803 return data 6804 6805 def update_brand_with_http_info(self, account_id, brand_id, **kwargs): 6806 """ 6807 Updates an existing brand. 6808 This method updates an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 6809 This method makes a synchronous HTTP request by default. To make an 6810 asynchronous HTTP request, please define a `callback` function 6811 to be invoked when receiving the response. 6812 >>> def callback_function(response): 6813 >>> pprint(response) 6814 >>> 6815 >>> thread = api.update_brand_with_http_info(account_id, brand_id, callback=callback_function) 6816 6817 :param callback function: The callback function 6818 for asynchronous request. (optional) 6819 :param str account_id: The external account number (int) or account ID Guid. (required) 6820 :param str brand_id: The unique identifier of a brand. (required) 6821 :param str replace_brand: 6822 :param Brand brand: 6823 :return: Brand 6824 If the method is called asynchronously, 6825 returns the request thread. 6826 """ 6827 6828 all_params = ['account_id', 'brand_id', 'replace_brand', 'brand'] 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 update_brand" % 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 `update_brand`") 6846 # verify the required parameter 'brand_id' is set 6847 if ('brand_id' not in params) or (params['brand_id'] is None): 6848 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand`") 6849 6850 6851 collection_formats = {} 6852 6853 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 6854 path_params = {} 6855 if 'account_id' in params: 6856 path_params['accountId'] = params['account_id'] 6857 if 'brand_id' in params: 6858 path_params['brandId'] = params['brand_id'] 6859 6860 query_params = {} 6861 if 'replace_brand' in params: 6862 query_params['replace_brand'] = params['replace_brand'] 6863 6864 header_params = {} 6865 6866 form_params = [] 6867 local_var_files = {} 6868 6869 body_params = None 6870 if 'brand' in params: 6871 body_params = params['brand'] 6872 # HTTP header `Accept` 6873 header_params['Accept'] = self.api_client.\ 6874 select_header_accept(['application/json']) 6875 6876 # Authentication setting 6877 auth_settings = [] 6878 6879 return self.api_client.call_api(resource_path, 'PUT', 6880 path_params, 6881 query_params, 6882 header_params, 6883 body=body_params, 6884 post_params=form_params, 6885 files=local_var_files, 6886 response_type='Brand', 6887 auth_settings=auth_settings, 6888 callback=params.get('callback'), 6889 _return_http_data_only=params.get('_return_http_data_only'), 6890 _preload_content=params.get('_preload_content', True), 6891 _request_timeout=params.get('_request_timeout'), 6892 collection_formats=collection_formats) 6893 6894 def update_brand_logo_by_type(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs): 6895 """ 6896 Put one branding logo. 6897 This method updates a single brand logo. You pass in the new version of the resource in the `Content-Disposition` header. Example: `Content-Disposition: form-data; name=\"file\"; filename=\"logo.jpg\"` **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 6898 This method makes a synchronous HTTP request by default. To make an 6899 asynchronous HTTP request, please define a `callback` function 6900 to be invoked when receiving the response. 6901 >>> def callback_function(response): 6902 >>> pprint(response) 6903 >>> 6904 >>> thread = api.update_brand_logo_by_type(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function) 6905 6906 :param callback function: The callback function 6907 for asynchronous request. (optional) 6908 :param str account_id: The external account number (int) or account ID GUID. (required) 6909 :param str brand_id: The ID of the brand. (required) 6910 :param str logo_type: The type of logo. Valid values are: - `primary` - `secondary` - `email` (required) 6911 :param str logo_file_bytes: Brand logo binary Stream. Supported formats: JPG, GIF, PNG. Maximum file size: 300 KB. Recommended dimensions: 296 x 76 pixels (larger images will be resized). Changes may take up to one hour to display in all places (required) 6912 :return: None 6913 If the method is called asynchronously, 6914 returns the request thread. 6915 """ 6916 kwargs['_return_http_data_only'] = True 6917 if kwargs.get('callback'): 6918 return self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs) 6919 else: 6920 (data) = self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs) 6921 return data 6922 6923 def update_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs): 6924 """ 6925 Put one branding logo. 6926 This method updates a single brand logo. You pass in the new version of the resource in the `Content-Disposition` header. Example: `Content-Disposition: form-data; name=\"file\"; filename=\"logo.jpg\"` **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 6927 This method makes a synchronous HTTP request by default. To make an 6928 asynchronous HTTP request, please define a `callback` function 6929 to be invoked when receiving the response. 6930 >>> def callback_function(response): 6931 >>> pprint(response) 6932 >>> 6933 >>> thread = api.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function) 6934 6935 :param callback function: The callback function 6936 for asynchronous request. (optional) 6937 :param str account_id: The external account number (int) or account ID GUID. (required) 6938 :param str brand_id: The ID of the brand. (required) 6939 :param str logo_type: The type of logo. Valid values are: - `primary` - `secondary` - `email` (required) 6940 :param str logo_file_bytes: Brand logo binary Stream. Supported formats: JPG, GIF, PNG. Maximum file size: 300 KB. Recommended dimensions: 296 x 76 pixels (larger images will be resized). Changes may take up to one hour to display in all places (required) 6941 :return: None 6942 If the method is called asynchronously, 6943 returns the request thread. 6944 """ 6945 6946 all_params = ['account_id', 'brand_id', 'logo_type', 'logo_file_bytes'] 6947 all_params.append('callback') 6948 all_params.append('_return_http_data_only') 6949 all_params.append('_preload_content') 6950 all_params.append('_request_timeout') 6951 6952 params = locals() 6953 for key, val in iteritems(params['kwargs']): 6954 if key not in all_params: 6955 raise TypeError( 6956 "Got an unexpected keyword argument '%s'" 6957 " to method update_brand_logo_by_type" % key 6958 ) 6959 params[key] = val 6960 del params['kwargs'] 6961 # verify the required parameter 'account_id' is set 6962 if ('account_id' not in params) or (params['account_id'] is None): 6963 raise ValueError("Missing the required parameter `account_id` when calling `update_brand_logo_by_type`") 6964 # verify the required parameter 'brand_id' is set 6965 if ('brand_id' not in params) or (params['brand_id'] is None): 6966 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_logo_by_type`") 6967 # verify the required parameter 'logo_type' is set 6968 if ('logo_type' not in params) or (params['logo_type'] is None): 6969 raise ValueError("Missing the required parameter `logo_type` when calling `update_brand_logo_by_type`") 6970 # verify the required parameter 'logo_file_bytes' is set 6971 if ('logo_file_bytes' not in params) or (params['logo_file_bytes'] is None): 6972 raise ValueError("Missing the required parameter `logo_file_bytes` when calling `update_brand_logo_by_type`") 6973 6974 6975 collection_formats = {} 6976 6977 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 6978 path_params = {} 6979 if 'account_id' in params: 6980 path_params['accountId'] = params['account_id'] 6981 if 'brand_id' in params: 6982 path_params['brandId'] = params['brand_id'] 6983 if 'logo_type' in params: 6984 path_params['logoType'] = params['logo_type'] 6985 6986 query_params = {} 6987 6988 header_params = {} 6989 6990 form_params = [] 6991 local_var_files = {} 6992 6993 body_params = None 6994 if 'logo_file_bytes' in params: 6995 body_params = params['logo_file_bytes'] 6996 # HTTP header `Accept` 6997 header_params['Accept'] = self.api_client.\ 6998 select_header_accept(['application/json']) 6999 7000 # HTTP header `Content-Type` 7001 header_params['Content-Type'] = self.api_client.\ 7002 select_header_content_type(['image/png']) 7003 7004 # Authentication setting 7005 auth_settings = [] 7006 7007 return self.api_client.call_api(resource_path, 'PUT', 7008 path_params, 7009 query_params, 7010 header_params, 7011 body=body_params, 7012 post_params=form_params, 7013 files=local_var_files, 7014 response_type=None, 7015 auth_settings=auth_settings, 7016 callback=params.get('callback'), 7017 _return_http_data_only=params.get('_return_http_data_only'), 7018 _preload_content=params.get('_preload_content', True), 7019 _request_timeout=params.get('_request_timeout'), 7020 collection_formats=collection_formats) 7021 7022 def update_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, file_xml, **kwargs): 7023 """ 7024 Uploads a branding resource file. 7025 This method updates a branding resource file. You pass in the new version of the resource file in the `Content-Disposition` header. Example: `Content-Disposition: form-data; name=\"file\"; filename=\"DocuSign_SigningResource_4328673.xml\"` **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). **Important:** Customizing resource files is an advanced branding configuration option which can significantly impact your account, and should be done only by someone with expertise in XML and HTML. The master resource files are subject to change without notice. If you customize your resource files, after each release, DocuSign recommends you review any changes and update your custom files as needed. When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file. 7026 This method makes a synchronous HTTP request by default. To make an 7027 asynchronous HTTP request, please define a `callback` function 7028 to be invoked when receiving the response. 7029 >>> def callback_function(response): 7030 >>> pprint(response) 7031 >>> 7032 >>> thread = api.update_brand_resources_by_content_type(account_id, brand_id, resource_content_type, file_xml, callback=callback_function) 7033 7034 :param callback function: The callback function 7035 for asynchronous request. (optional) 7036 :param str account_id: The external account number (int) or account ID GUID. (required) 7037 :param str brand_id: The ID of the brand. (required) 7038 :param str resource_content_type: The type of brand resource file that you are updating. Valid values are: - `sending` - `signing` - `email` - `signing_captive` (required) 7039 :param file file_xml: Brand resource XML file. (required) 7040 :return: BrandResources 7041 If the method is called asynchronously, 7042 returns the request thread. 7043 """ 7044 kwargs['_return_http_data_only'] = True 7045 if kwargs.get('callback'): 7046 return self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs) 7047 else: 7048 (data) = self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs) 7049 return data 7050 7051 def update_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, file_xml, **kwargs): 7052 """ 7053 Uploads a branding resource file. 7054 This method updates a branding resource file. You pass in the new version of the resource file in the `Content-Disposition` header. Example: `Content-Disposition: form-data; name=\"file\"; filename=\"DocuSign_SigningResource_4328673.xml\"` **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). **Important:** Customizing resource files is an advanced branding configuration option which can significantly impact your account, and should be done only by someone with expertise in XML and HTML. The master resource files are subject to change without notice. If you customize your resource files, after each release, DocuSign recommends you review any changes and update your custom files as needed. When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file. 7055 This method makes a synchronous HTTP request by default. To make an 7056 asynchronous HTTP request, please define a `callback` function 7057 to be invoked when receiving the response. 7058 >>> def callback_function(response): 7059 >>> pprint(response) 7060 >>> 7061 >>> thread = api.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, callback=callback_function) 7062 7063 :param callback function: The callback function 7064 for asynchronous request. (optional) 7065 :param str account_id: The external account number (int) or account ID GUID. (required) 7066 :param str brand_id: The ID of the brand. (required) 7067 :param str resource_content_type: The type of brand resource file that you are updating. Valid values are: - `sending` - `signing` - `email` - `signing_captive` (required) 7068 :param file file_xml: Brand resource XML file. (required) 7069 :return: BrandResources 7070 If the method is called asynchronously, 7071 returns the request thread. 7072 """ 7073 7074 all_params = ['account_id', 'brand_id', 'resource_content_type', 'file_xml'] 7075 all_params.append('callback') 7076 all_params.append('_return_http_data_only') 7077 all_params.append('_preload_content') 7078 all_params.append('_request_timeout') 7079 7080 params = locals() 7081 for key, val in iteritems(params['kwargs']): 7082 if key not in all_params: 7083 raise TypeError( 7084 "Got an unexpected keyword argument '%s'" 7085 " to method update_brand_resources_by_content_type" % key 7086 ) 7087 params[key] = val 7088 del params['kwargs'] 7089 # verify the required parameter 'account_id' is set 7090 if ('account_id' not in params) or (params['account_id'] is None): 7091 raise ValueError("Missing the required parameter `account_id` when calling `update_brand_resources_by_content_type`") 7092 # verify the required parameter 'brand_id' is set 7093 if ('brand_id' not in params) or (params['brand_id'] is None): 7094 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_resources_by_content_type`") 7095 # verify the required parameter 'resource_content_type' is set 7096 if ('resource_content_type' not in params) or (params['resource_content_type'] is None): 7097 raise ValueError("Missing the required parameter `resource_content_type` when calling `update_brand_resources_by_content_type`") 7098 # verify the required parameter 'file_xml' is set 7099 if ('file_xml' not in params) or (params['file_xml'] is None): 7100 raise ValueError("Missing the required parameter `file_xml` when calling `update_brand_resources_by_content_type`") 7101 7102 7103 collection_formats = {} 7104 7105 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources/{resourceContentType}'.replace('{format}', 'json') 7106 path_params = {} 7107 if 'account_id' in params: 7108 path_params['accountId'] = params['account_id'] 7109 if 'brand_id' in params: 7110 path_params['brandId'] = params['brand_id'] 7111 if 'resource_content_type' in params: 7112 path_params['resourceContentType'] = params['resource_content_type'] 7113 7114 query_params = {} 7115 7116 header_params = {} 7117 7118 form_params = [] 7119 local_var_files = {} 7120 if 'file_xml' in params: 7121 local_var_files['file.xml'] = params['file_xml'] 7122 7123 body_params = None 7124 # HTTP header `Accept` 7125 header_params['Accept'] = self.api_client.\ 7126 select_header_accept(['application/json']) 7127 7128 # HTTP header `Content-Type` 7129 header_params['Content-Type'] = self.api_client.\ 7130 select_header_content_type(['multipart/form-data']) 7131 7132 # Authentication setting 7133 auth_settings = [] 7134 7135 return self.api_client.call_api(resource_path, 'PUT', 7136 path_params, 7137 query_params, 7138 header_params, 7139 body=body_params, 7140 post_params=form_params, 7141 files=local_var_files, 7142 response_type='BrandResources', 7143 auth_settings=auth_settings, 7144 callback=params.get('callback'), 7145 _return_http_data_only=params.get('_return_http_data_only'), 7146 _preload_content=params.get('_preload_content', True), 7147 _request_timeout=params.get('_request_timeout'), 7148 collection_formats=collection_formats) 7149 7150 def update_consumer_disclosure(self, account_id, lang_code, **kwargs): 7151 """ 7152 Update Consumer Disclosure. 7153 Account administrators can use this method to perform the following tasks: - Customize values in the default disclosure. - Switch to a custom disclosure that uses your own text and HTML formatting. - Change values in your existing consumer disclosure. To specify the signer language version of the disclosure that you are updating, use the optional `langCode` query parameter. **Note:** Only account administrators can use this method. Each time you change the disclosure content, all unsigned recipients of outstanding documents will be required to accept a new version. ## Updating the default disclosure When you update the default disclosure, you can edit all properties except for the following ones: - `accountEsignId`: This property is read-only. - `custom`: The default value is **false.** Editing this property causes the default disclosure to switch to a custom disclosure. - `esignAgreement`: This property is read-only. - `esignText`: You cannot edit this property when `custom` is set to **false.** The API returns a 200 OK HTTP response, but does not update the `esignText`. - Metadata properties: These properties are read-only. **Note:** The text of the default disclosure is always in English. ## Switching to a custom disclosure To switch to a custom disclosure, set the `custom` property to **true** and customize the value for the `eSignText` property. You can also edit all of the other properties except for the following ones: - `accountEsignId`: This property is read-only. - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only. **Note:** When you use a custom disclosure, you can create versions of it in different signer languages and se the `langCode` parameter to specify the signer language version that you are updating. **Important:** When you switch from a default to a custom disclosure, note the following information: - You will not be able to return to using the default disclosure. - Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use. ## Updating a custom disclosure When you update a custom disclosure, you can update all of the properties except for the following ones: - `accountEsignId`: This property is read-only. - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only. **Important:** Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use. 7154 This method makes a synchronous HTTP request by default. To make an 7155 asynchronous HTTP request, please define a `callback` function 7156 to be invoked when receiving the response. 7157 >>> def callback_function(response): 7158 >>> pprint(response) 7159 >>> 7160 >>> thread = api.update_consumer_disclosure(account_id, lang_code, callback=callback_function) 7161 7162 :param callback function: The callback function 7163 for asynchronous request. (optional) 7164 :param str account_id: The external account number (int) or account ID Guid. (required) 7165 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 7166 :param str include_metadata: 7167 :param ConsumerDisclosure consumer_disclosure: 7168 :return: ConsumerDisclosure 7169 If the method is called asynchronously, 7170 returns the request thread. 7171 """ 7172 kwargs['_return_http_data_only'] = True 7173 if kwargs.get('callback'): 7174 return self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 7175 else: 7176 (data) = self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 7177 return data 7178 7179 def update_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs): 7180 """ 7181 Update Consumer Disclosure. 7182 Account administrators can use this method to perform the following tasks: - Customize values in the default disclosure. - Switch to a custom disclosure that uses your own text and HTML formatting. - Change values in your existing consumer disclosure. To specify the signer language version of the disclosure that you are updating, use the optional `langCode` query parameter. **Note:** Only account administrators can use this method. Each time you change the disclosure content, all unsigned recipients of outstanding documents will be required to accept a new version. ## Updating the default disclosure When you update the default disclosure, you can edit all properties except for the following ones: - `accountEsignId`: This property is read-only. - `custom`: The default value is **false.** Editing this property causes the default disclosure to switch to a custom disclosure. - `esignAgreement`: This property is read-only. - `esignText`: You cannot edit this property when `custom` is set to **false.** The API returns a 200 OK HTTP response, but does not update the `esignText`. - Metadata properties: These properties are read-only. **Note:** The text of the default disclosure is always in English. ## Switching to a custom disclosure To switch to a custom disclosure, set the `custom` property to **true** and customize the value for the `eSignText` property. You can also edit all of the other properties except for the following ones: - `accountEsignId`: This property is read-only. - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only. **Note:** When you use a custom disclosure, you can create versions of it in different signer languages and se the `langCode` parameter to specify the signer language version that you are updating. **Important:** When you switch from a default to a custom disclosure, note the following information: - You will not be able to return to using the default disclosure. - Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use. ## Updating a custom disclosure When you update a custom disclosure, you can update all of the properties except for the following ones: - `accountEsignId`: This property is read-only. - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only. **Important:** Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use. 7183 This method makes a synchronous HTTP request by default. To make an 7184 asynchronous HTTP request, please define a `callback` function 7185 to be invoked when receiving the response. 7186 >>> def callback_function(response): 7187 >>> pprint(response) 7188 >>> 7189 >>> thread = api.update_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function) 7190 7191 :param callback function: The callback function 7192 for asynchronous request. (optional) 7193 :param str account_id: The external account number (int) or account ID Guid. (required) 7194 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 7195 :param str include_metadata: 7196 :param ConsumerDisclosure consumer_disclosure: 7197 :return: ConsumerDisclosure 7198 If the method is called asynchronously, 7199 returns the request thread. 7200 """ 7201 7202 all_params = ['account_id', 'lang_code', 'include_metadata', 'consumer_disclosure'] 7203 all_params.append('callback') 7204 all_params.append('_return_http_data_only') 7205 all_params.append('_preload_content') 7206 all_params.append('_request_timeout') 7207 7208 params = locals() 7209 for key, val in iteritems(params['kwargs']): 7210 if key not in all_params: 7211 raise TypeError( 7212 "Got an unexpected keyword argument '%s'" 7213 " to method update_consumer_disclosure" % key 7214 ) 7215 params[key] = val 7216 del params['kwargs'] 7217 # verify the required parameter 'account_id' is set 7218 if ('account_id' not in params) or (params['account_id'] is None): 7219 raise ValueError("Missing the required parameter `account_id` when calling `update_consumer_disclosure`") 7220 # verify the required parameter 'lang_code' is set 7221 if ('lang_code' not in params) or (params['lang_code'] is None): 7222 raise ValueError("Missing the required parameter `lang_code` when calling `update_consumer_disclosure`") 7223 7224 7225 collection_formats = {} 7226 7227 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 7228 path_params = {} 7229 if 'account_id' in params: 7230 path_params['accountId'] = params['account_id'] 7231 if 'lang_code' in params: 7232 path_params['langCode'] = params['lang_code'] 7233 7234 query_params = {} 7235 if 'include_metadata' in params: 7236 query_params['include_metadata'] = params['include_metadata'] 7237 7238 header_params = {} 7239 7240 form_params = [] 7241 local_var_files = {} 7242 7243 body_params = None 7244 if 'consumer_disclosure' in params: 7245 body_params = params['consumer_disclosure'] 7246 # HTTP header `Accept` 7247 header_params['Accept'] = self.api_client.\ 7248 select_header_accept(['application/json']) 7249 7250 # Authentication setting 7251 auth_settings = [] 7252 7253 return self.api_client.call_api(resource_path, 'PUT', 7254 path_params, 7255 query_params, 7256 header_params, 7257 body=body_params, 7258 post_params=form_params, 7259 files=local_var_files, 7260 response_type='ConsumerDisclosure', 7261 auth_settings=auth_settings, 7262 callback=params.get('callback'), 7263 _return_http_data_only=params.get('_return_http_data_only'), 7264 _preload_content=params.get('_preload_content', True), 7265 _request_timeout=params.get('_request_timeout'), 7266 collection_formats=collection_formats) 7267 7268 def update_custom_field(self, account_id, custom_field_id, **kwargs): 7269 """ 7270 Updates an existing account custom field. 7271 This method updates an existing account custom field. 7272 This method makes a synchronous HTTP request by default. To make an 7273 asynchronous HTTP request, please define a `callback` function 7274 to be invoked when receiving the response. 7275 >>> def callback_function(response): 7276 >>> pprint(response) 7277 >>> 7278 >>> thread = api.update_custom_field(account_id, custom_field_id, callback=callback_function) 7279 7280 :param callback function: The callback function 7281 for asynchronous request. (optional) 7282 :param str account_id: The external account number (int) or account ID Guid. (required) 7283 :param str custom_field_id: (required) 7284 :param str apply_to_templates: 7285 :param CustomField custom_field: 7286 :return: CustomFields 7287 If the method is called asynchronously, 7288 returns the request thread. 7289 """ 7290 kwargs['_return_http_data_only'] = True 7291 if kwargs.get('callback'): 7292 return self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 7293 else: 7294 (data) = self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 7295 return data 7296 7297 def update_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs): 7298 """ 7299 Updates an existing account custom field. 7300 This method updates an existing account custom field. 7301 This method makes a synchronous HTTP request by default. To make an 7302 asynchronous HTTP request, please define a `callback` function 7303 to be invoked when receiving the response. 7304 >>> def callback_function(response): 7305 >>> pprint(response) 7306 >>> 7307 >>> thread = api.update_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function) 7308 7309 :param callback function: The callback function 7310 for asynchronous request. (optional) 7311 :param str account_id: The external account number (int) or account ID Guid. (required) 7312 :param str custom_field_id: (required) 7313 :param str apply_to_templates: 7314 :param CustomField custom_field: 7315 :return: CustomFields 7316 If the method is called asynchronously, 7317 returns the request thread. 7318 """ 7319 7320 all_params = ['account_id', 'custom_field_id', 'apply_to_templates', 'custom_field'] 7321 all_params.append('callback') 7322 all_params.append('_return_http_data_only') 7323 all_params.append('_preload_content') 7324 all_params.append('_request_timeout') 7325 7326 params = locals() 7327 for key, val in iteritems(params['kwargs']): 7328 if key not in all_params: 7329 raise TypeError( 7330 "Got an unexpected keyword argument '%s'" 7331 " to method update_custom_field" % key 7332 ) 7333 params[key] = val 7334 del params['kwargs'] 7335 # verify the required parameter 'account_id' is set 7336 if ('account_id' not in params) or (params['account_id'] is None): 7337 raise ValueError("Missing the required parameter `account_id` when calling `update_custom_field`") 7338 # verify the required parameter 'custom_field_id' is set 7339 if ('custom_field_id' not in params) or (params['custom_field_id'] is None): 7340 raise ValueError("Missing the required parameter `custom_field_id` when calling `update_custom_field`") 7341 7342 7343 collection_formats = {} 7344 7345 resource_path = '/v2.1/accounts/{accountId}/custom_fields/{customFieldId}'.replace('{format}', 'json') 7346 path_params = {} 7347 if 'account_id' in params: 7348 path_params['accountId'] = params['account_id'] 7349 if 'custom_field_id' in params: 7350 path_params['customFieldId'] = params['custom_field_id'] 7351 7352 query_params = {} 7353 if 'apply_to_templates' in params: 7354 query_params['apply_to_templates'] = params['apply_to_templates'] 7355 7356 header_params = {} 7357 7358 form_params = [] 7359 local_var_files = {} 7360 7361 body_params = None 7362 if 'custom_field' in params: 7363 body_params = params['custom_field'] 7364 # HTTP header `Accept` 7365 header_params['Accept'] = self.api_client.\ 7366 select_header_accept(['application/json']) 7367 7368 # Authentication setting 7369 auth_settings = [] 7370 7371 return self.api_client.call_api(resource_path, 'PUT', 7372 path_params, 7373 query_params, 7374 header_params, 7375 body=body_params, 7376 post_params=form_params, 7377 files=local_var_files, 7378 response_type='CustomFields', 7379 auth_settings=auth_settings, 7380 callback=params.get('callback'), 7381 _return_http_data_only=params.get('_return_http_data_only'), 7382 _preload_content=params.get('_preload_content', True), 7383 _request_timeout=params.get('_request_timeout'), 7384 collection_formats=collection_formats) 7385 7386 def update_e_note_configuration(self, account_id, **kwargs): 7387 """ 7388 Updates configuration information for the eNote eOriginal integration. 7389 7390 This method makes a synchronous HTTP request by default. To make an 7391 asynchronous HTTP request, please define a `callback` function 7392 to be invoked when receiving the response. 7393 >>> def callback_function(response): 7394 >>> pprint(response) 7395 >>> 7396 >>> thread = api.update_e_note_configuration(account_id, callback=callback_function) 7397 7398 :param callback function: The callback function 7399 for asynchronous request. (optional) 7400 :param str account_id: The external account number (int) or account ID Guid. (required) 7401 :param ENoteConfiguration e_note_configuration: 7402 :return: ENoteConfiguration 7403 If the method is called asynchronously, 7404 returns the request thread. 7405 """ 7406 kwargs['_return_http_data_only'] = True 7407 if kwargs.get('callback'): 7408 return self.update_e_note_configuration_with_http_info(account_id, **kwargs) 7409 else: 7410 (data) = self.update_e_note_configuration_with_http_info(account_id, **kwargs) 7411 return data 7412 7413 def update_e_note_configuration_with_http_info(self, account_id, **kwargs): 7414 """ 7415 Updates configuration information for the eNote eOriginal integration. 7416 7417 This method makes a synchronous HTTP request by default. To make an 7418 asynchronous HTTP request, please define a `callback` function 7419 to be invoked when receiving the response. 7420 >>> def callback_function(response): 7421 >>> pprint(response) 7422 >>> 7423 >>> thread = api.update_e_note_configuration_with_http_info(account_id, callback=callback_function) 7424 7425 :param callback function: The callback function 7426 for asynchronous request. (optional) 7427 :param str account_id: The external account number (int) or account ID Guid. (required) 7428 :param ENoteConfiguration e_note_configuration: 7429 :return: ENoteConfiguration 7430 If the method is called asynchronously, 7431 returns the request thread. 7432 """ 7433 7434 all_params = ['account_id', 'e_note_configuration'] 7435 all_params.append('callback') 7436 all_params.append('_return_http_data_only') 7437 all_params.append('_preload_content') 7438 all_params.append('_request_timeout') 7439 7440 params = locals() 7441 for key, val in iteritems(params['kwargs']): 7442 if key not in all_params: 7443 raise TypeError( 7444 "Got an unexpected keyword argument '%s'" 7445 " to method update_e_note_configuration" % key 7446 ) 7447 params[key] = val 7448 del params['kwargs'] 7449 # verify the required parameter 'account_id' is set 7450 if ('account_id' not in params) or (params['account_id'] is None): 7451 raise ValueError("Missing the required parameter `account_id` when calling `update_e_note_configuration`") 7452 7453 7454 collection_formats = {} 7455 7456 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 7457 path_params = {} 7458 if 'account_id' in params: 7459 path_params['accountId'] = params['account_id'] 7460 7461 query_params = {} 7462 7463 header_params = {} 7464 7465 form_params = [] 7466 local_var_files = {} 7467 7468 body_params = None 7469 if 'e_note_configuration' in params: 7470 body_params = params['e_note_configuration'] 7471 # HTTP header `Accept` 7472 header_params['Accept'] = self.api_client.\ 7473 select_header_accept(['application/json']) 7474 7475 # Authentication setting 7476 auth_settings = [] 7477 7478 return self.api_client.call_api(resource_path, 'PUT', 7479 path_params, 7480 query_params, 7481 header_params, 7482 body=body_params, 7483 post_params=form_params, 7484 files=local_var_files, 7485 response_type='ENoteConfiguration', 7486 auth_settings=auth_settings, 7487 callback=params.get('callback'), 7488 _return_http_data_only=params.get('_return_http_data_only'), 7489 _preload_content=params.get('_preload_content', True), 7490 _request_timeout=params.get('_request_timeout'), 7491 collection_formats=collection_formats) 7492 7493 def update_envelope_purge_configuration(self, account_id, **kwargs): 7494 """ 7495 Updates envelope purge configuration. 7496 An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method sets the envelope purge configuration for your account. **Note:** To use this method, you must be an account administrator. For more information, see [Purge Envelopes](https://support.docusign.com/en/guides/ndse-user-guide-purge-envelopes). 7497 This method makes a synchronous HTTP request by default. To make an 7498 asynchronous HTTP request, please define a `callback` function 7499 to be invoked when receiving the response. 7500 >>> def callback_function(response): 7501 >>> pprint(response) 7502 >>> 7503 >>> thread = api.update_envelope_purge_configuration(account_id, callback=callback_function) 7504 7505 :param callback function: The callback function 7506 for asynchronous request. (optional) 7507 :param str account_id: The external account number (int) or account ID Guid. (required) 7508 :param EnvelopePurgeConfiguration envelope_purge_configuration: 7509 :return: EnvelopePurgeConfiguration 7510 If the method is called asynchronously, 7511 returns the request thread. 7512 """ 7513 kwargs['_return_http_data_only'] = True 7514 if kwargs.get('callback'): 7515 return self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs) 7516 else: 7517 (data) = self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs) 7518 return data 7519 7520 def update_envelope_purge_configuration_with_http_info(self, account_id, **kwargs): 7521 """ 7522 Updates envelope purge configuration. 7523 An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method sets the envelope purge configuration for your account. **Note:** To use this method, you must be an account administrator. For more information, see [Purge Envelopes](https://support.docusign.com/en/guides/ndse-user-guide-purge-envelopes). 7524 This method makes a synchronous HTTP request by default. To make an 7525 asynchronous HTTP request, please define a `callback` function 7526 to be invoked when receiving the response. 7527 >>> def callback_function(response): 7528 >>> pprint(response) 7529 >>> 7530 >>> thread = api.update_envelope_purge_configuration_with_http_info(account_id, callback=callback_function) 7531 7532 :param callback function: The callback function 7533 for asynchronous request. (optional) 7534 :param str account_id: The external account number (int) or account ID Guid. (required) 7535 :param EnvelopePurgeConfiguration envelope_purge_configuration: 7536 :return: EnvelopePurgeConfiguration 7537 If the method is called asynchronously, 7538 returns the request thread. 7539 """ 7540 7541 all_params = ['account_id', 'envelope_purge_configuration'] 7542 all_params.append('callback') 7543 all_params.append('_return_http_data_only') 7544 all_params.append('_preload_content') 7545 all_params.append('_request_timeout') 7546 7547 params = locals() 7548 for key, val in iteritems(params['kwargs']): 7549 if key not in all_params: 7550 raise TypeError( 7551 "Got an unexpected keyword argument '%s'" 7552 " to method update_envelope_purge_configuration" % key 7553 ) 7554 params[key] = val 7555 del params['kwargs'] 7556 # verify the required parameter 'account_id' is set 7557 if ('account_id' not in params) or (params['account_id'] is None): 7558 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_purge_configuration`") 7559 7560 7561 collection_formats = {} 7562 7563 resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json') 7564 path_params = {} 7565 if 'account_id' in params: 7566 path_params['accountId'] = params['account_id'] 7567 7568 query_params = {} 7569 7570 header_params = {} 7571 7572 form_params = [] 7573 local_var_files = {} 7574 7575 body_params = None 7576 if 'envelope_purge_configuration' in params: 7577 body_params = params['envelope_purge_configuration'] 7578 # HTTP header `Accept` 7579 header_params['Accept'] = self.api_client.\ 7580 select_header_accept(['application/json']) 7581 7582 # Authentication setting 7583 auth_settings = [] 7584 7585 return self.api_client.call_api(resource_path, 'PUT', 7586 path_params, 7587 query_params, 7588 header_params, 7589 body=body_params, 7590 post_params=form_params, 7591 files=local_var_files, 7592 response_type='EnvelopePurgeConfiguration', 7593 auth_settings=auth_settings, 7594 callback=params.get('callback'), 7595 _return_http_data_only=params.get('_return_http_data_only'), 7596 _preload_content=params.get('_preload_content', True), 7597 _request_timeout=params.get('_request_timeout'), 7598 collection_formats=collection_formats) 7599 7600 def update_favorite_template(self, account_id, **kwargs): 7601 """ 7602 Favorites a template 7603 7604 This method makes a synchronous HTTP request by default. To make an 7605 asynchronous HTTP request, please define a `callback` function 7606 to be invoked when receiving the response. 7607 >>> def callback_function(response): 7608 >>> pprint(response) 7609 >>> 7610 >>> thread = api.update_favorite_template(account_id, callback=callback_function) 7611 7612 :param callback function: The callback function 7613 for asynchronous request. (optional) 7614 :param str account_id: The external account number (int) or account ID Guid. (required) 7615 :param FavoriteTemplatesInfo favorite_templates_info: 7616 :return: FavoriteTemplatesInfo 7617 If the method is called asynchronously, 7618 returns the request thread. 7619 """ 7620 kwargs['_return_http_data_only'] = True 7621 if kwargs.get('callback'): 7622 return self.update_favorite_template_with_http_info(account_id, **kwargs) 7623 else: 7624 (data) = self.update_favorite_template_with_http_info(account_id, **kwargs) 7625 return data 7626 7627 def update_favorite_template_with_http_info(self, account_id, **kwargs): 7628 """ 7629 Favorites a template 7630 7631 This method makes a synchronous HTTP request by default. To make an 7632 asynchronous HTTP request, please define a `callback` function 7633 to be invoked when receiving the response. 7634 >>> def callback_function(response): 7635 >>> pprint(response) 7636 >>> 7637 >>> thread = api.update_favorite_template_with_http_info(account_id, callback=callback_function) 7638 7639 :param callback function: The callback function 7640 for asynchronous request. (optional) 7641 :param str account_id: The external account number (int) or account ID Guid. (required) 7642 :param FavoriteTemplatesInfo favorite_templates_info: 7643 :return: FavoriteTemplatesInfo 7644 If the method is called asynchronously, 7645 returns the request thread. 7646 """ 7647 7648 all_params = ['account_id', 'favorite_templates_info'] 7649 all_params.append('callback') 7650 all_params.append('_return_http_data_only') 7651 all_params.append('_preload_content') 7652 all_params.append('_request_timeout') 7653 7654 params = locals() 7655 for key, val in iteritems(params['kwargs']): 7656 if key not in all_params: 7657 raise TypeError( 7658 "Got an unexpected keyword argument '%s'" 7659 " to method update_favorite_template" % key 7660 ) 7661 params[key] = val 7662 del params['kwargs'] 7663 # verify the required parameter 'account_id' is set 7664 if ('account_id' not in params) or (params['account_id'] is None): 7665 raise ValueError("Missing the required parameter `account_id` when calling `update_favorite_template`") 7666 7667 7668 collection_formats = {} 7669 7670 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 7671 path_params = {} 7672 if 'account_id' in params: 7673 path_params['accountId'] = params['account_id'] 7674 7675 query_params = {} 7676 7677 header_params = {} 7678 7679 form_params = [] 7680 local_var_files = {} 7681 7682 body_params = None 7683 if 'favorite_templates_info' in params: 7684 body_params = params['favorite_templates_info'] 7685 # HTTP header `Accept` 7686 header_params['Accept'] = self.api_client.\ 7687 select_header_accept(['application/json']) 7688 7689 # Authentication setting 7690 auth_settings = [] 7691 7692 return self.api_client.call_api(resource_path, 'PUT', 7693 path_params, 7694 query_params, 7695 header_params, 7696 body=body_params, 7697 post_params=form_params, 7698 files=local_var_files, 7699 response_type='FavoriteTemplatesInfo', 7700 auth_settings=auth_settings, 7701 callback=params.get('callback'), 7702 _return_http_data_only=params.get('_return_http_data_only'), 7703 _preload_content=params.get('_preload_content', True), 7704 _request_timeout=params.get('_request_timeout'), 7705 collection_formats=collection_formats) 7706 7707 def update_notification_defaults(self, account_id, **kwargs): 7708 """ 7709 Updates default user level settings for a specified account 7710 This method changes the default settings for the email notifications that signers and senders receive about envelopes. 7711 This method makes a synchronous HTTP request by default. To make an 7712 asynchronous HTTP request, please define a `callback` function 7713 to be invoked when receiving the response. 7714 >>> def callback_function(response): 7715 >>> pprint(response) 7716 >>> 7717 >>> thread = api.update_notification_defaults(account_id, callback=callback_function) 7718 7719 :param callback function: The callback function 7720 for asynchronous request. (optional) 7721 :param str account_id: The external account number (int) or account ID Guid. (required) 7722 :param NotificationDefaults notification_defaults: 7723 :return: NotificationDefaults 7724 If the method is called asynchronously, 7725 returns the request thread. 7726 """ 7727 kwargs['_return_http_data_only'] = True 7728 if kwargs.get('callback'): 7729 return self.update_notification_defaults_with_http_info(account_id, **kwargs) 7730 else: 7731 (data) = self.update_notification_defaults_with_http_info(account_id, **kwargs) 7732 return data 7733 7734 def update_notification_defaults_with_http_info(self, account_id, **kwargs): 7735 """ 7736 Updates default user level settings for a specified account 7737 This method changes the default settings for the email notifications that signers and senders receive about envelopes. 7738 This method makes a synchronous HTTP request by default. To make an 7739 asynchronous HTTP request, please define a `callback` function 7740 to be invoked when receiving the response. 7741 >>> def callback_function(response): 7742 >>> pprint(response) 7743 >>> 7744 >>> thread = api.update_notification_defaults_with_http_info(account_id, callback=callback_function) 7745 7746 :param callback function: The callback function 7747 for asynchronous request. (optional) 7748 :param str account_id: The external account number (int) or account ID Guid. (required) 7749 :param NotificationDefaults notification_defaults: 7750 :return: NotificationDefaults 7751 If the method is called asynchronously, 7752 returns the request thread. 7753 """ 7754 7755 all_params = ['account_id', 'notification_defaults'] 7756 all_params.append('callback') 7757 all_params.append('_return_http_data_only') 7758 all_params.append('_preload_content') 7759 all_params.append('_request_timeout') 7760 7761 params = locals() 7762 for key, val in iteritems(params['kwargs']): 7763 if key not in all_params: 7764 raise TypeError( 7765 "Got an unexpected keyword argument '%s'" 7766 " to method update_notification_defaults" % key 7767 ) 7768 params[key] = val 7769 del params['kwargs'] 7770 # verify the required parameter 'account_id' is set 7771 if ('account_id' not in params) or (params['account_id'] is None): 7772 raise ValueError("Missing the required parameter `account_id` when calling `update_notification_defaults`") 7773 7774 7775 collection_formats = {} 7776 7777 resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json') 7778 path_params = {} 7779 if 'account_id' in params: 7780 path_params['accountId'] = params['account_id'] 7781 7782 query_params = {} 7783 7784 header_params = {} 7785 7786 form_params = [] 7787 local_var_files = {} 7788 7789 body_params = None 7790 if 'notification_defaults' in params: 7791 body_params = params['notification_defaults'] 7792 # HTTP header `Accept` 7793 header_params['Accept'] = self.api_client.\ 7794 select_header_accept(['application/json']) 7795 7796 # Authentication setting 7797 auth_settings = [] 7798 7799 return self.api_client.call_api(resource_path, 'PUT', 7800 path_params, 7801 query_params, 7802 header_params, 7803 body=body_params, 7804 post_params=form_params, 7805 files=local_var_files, 7806 response_type='NotificationDefaults', 7807 auth_settings=auth_settings, 7808 callback=params.get('callback'), 7809 _return_http_data_only=params.get('_return_http_data_only'), 7810 _preload_content=params.get('_preload_content', True), 7811 _request_timeout=params.get('_request_timeout'), 7812 collection_formats=collection_formats) 7813 7814 def update_password_rules(self, account_id, **kwargs): 7815 """ 7816 Update the password rules 7817 This method updates the password rules for an account. **Note:** To update the password rules for an account, you must be an account administrator. 7818 This method makes a synchronous HTTP request by default. To make an 7819 asynchronous HTTP request, please define a `callback` function 7820 to be invoked when receiving the response. 7821 >>> def callback_function(response): 7822 >>> pprint(response) 7823 >>> 7824 >>> thread = api.update_password_rules(account_id, callback=callback_function) 7825 7826 :param callback function: The callback function 7827 for asynchronous request. (optional) 7828 :param str account_id: The external account number (int) or account ID Guid. (required) 7829 :param AccountPasswordRules account_password_rules: 7830 :return: AccountPasswordRules 7831 If the method is called asynchronously, 7832 returns the request thread. 7833 """ 7834 kwargs['_return_http_data_only'] = True 7835 if kwargs.get('callback'): 7836 return self.update_password_rules_with_http_info(account_id, **kwargs) 7837 else: 7838 (data) = self.update_password_rules_with_http_info(account_id, **kwargs) 7839 return data 7840 7841 def update_password_rules_with_http_info(self, account_id, **kwargs): 7842 """ 7843 Update the password rules 7844 This method updates the password rules for an account. **Note:** To update the password rules for an account, you must be an account administrator. 7845 This method makes a synchronous HTTP request by default. To make an 7846 asynchronous HTTP request, please define a `callback` function 7847 to be invoked when receiving the response. 7848 >>> def callback_function(response): 7849 >>> pprint(response) 7850 >>> 7851 >>> thread = api.update_password_rules_with_http_info(account_id, callback=callback_function) 7852 7853 :param callback function: The callback function 7854 for asynchronous request. (optional) 7855 :param str account_id: The external account number (int) or account ID Guid. (required) 7856 :param AccountPasswordRules account_password_rules: 7857 :return: AccountPasswordRules 7858 If the method is called asynchronously, 7859 returns the request thread. 7860 """ 7861 7862 all_params = ['account_id', 'account_password_rules'] 7863 all_params.append('callback') 7864 all_params.append('_return_http_data_only') 7865 all_params.append('_preload_content') 7866 all_params.append('_request_timeout') 7867 7868 params = locals() 7869 for key, val in iteritems(params['kwargs']): 7870 if key not in all_params: 7871 raise TypeError( 7872 "Got an unexpected keyword argument '%s'" 7873 " to method update_password_rules" % key 7874 ) 7875 params[key] = val 7876 del params['kwargs'] 7877 # verify the required parameter 'account_id' is set 7878 if ('account_id' not in params) or (params['account_id'] is None): 7879 raise ValueError("Missing the required parameter `account_id` when calling `update_password_rules`") 7880 7881 7882 collection_formats = {} 7883 7884 resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json') 7885 path_params = {} 7886 if 'account_id' in params: 7887 path_params['accountId'] = params['account_id'] 7888 7889 query_params = {} 7890 7891 header_params = {} 7892 7893 form_params = [] 7894 local_var_files = {} 7895 7896 body_params = None 7897 if 'account_password_rules' in params: 7898 body_params = params['account_password_rules'] 7899 # HTTP header `Accept` 7900 header_params['Accept'] = self.api_client.\ 7901 select_header_accept(['application/json']) 7902 7903 # Authentication setting 7904 auth_settings = [] 7905 7906 return self.api_client.call_api(resource_path, 'PUT', 7907 path_params, 7908 query_params, 7909 header_params, 7910 body=body_params, 7911 post_params=form_params, 7912 files=local_var_files, 7913 response_type='AccountPasswordRules', 7914 auth_settings=auth_settings, 7915 callback=params.get('callback'), 7916 _return_http_data_only=params.get('_return_http_data_only'), 7917 _preload_content=params.get('_preload_content', True), 7918 _request_timeout=params.get('_request_timeout'), 7919 collection_formats=collection_formats) 7920 7921 def update_permission_profile(self, account_id, permission_profile_id, **kwargs): 7922 """ 7923 Updates a permission profile within the specified account. 7924 This method updates an account permission profile. ### Related topics - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 7925 This method makes a synchronous HTTP request by default. To make an 7926 asynchronous HTTP request, please define a `callback` function 7927 to be invoked when receiving the response. 7928 >>> def callback_function(response): 7929 >>> pprint(response) 7930 >>> 7931 >>> thread = api.update_permission_profile(account_id, permission_profile_id, callback=callback_function) 7932 7933 :param callback function: The callback function 7934 for asynchronous request. (optional) 7935 :param str account_id: The external account number (int) or account ID Guid. (required) 7936 :param str permission_profile_id: (required) 7937 :param str include: 7938 :param PermissionProfile permission_profile: 7939 :return: PermissionProfile 7940 If the method is called asynchronously, 7941 returns the request thread. 7942 """ 7943 kwargs['_return_http_data_only'] = True 7944 if kwargs.get('callback'): 7945 return self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 7946 else: 7947 (data) = self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 7948 return data 7949 7950 def update_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 7951 """ 7952 Updates a permission profile within the specified account. 7953 This method updates an account permission profile. ### Related topics - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 7954 This method makes a synchronous HTTP request by default. To make an 7955 asynchronous HTTP request, please define a `callback` function 7956 to be invoked when receiving the response. 7957 >>> def callback_function(response): 7958 >>> pprint(response) 7959 >>> 7960 >>> thread = api.update_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 7961 7962 :param callback function: The callback function 7963 for asynchronous request. (optional) 7964 :param str account_id: The external account number (int) or account ID Guid. (required) 7965 :param str permission_profile_id: (required) 7966 :param str include: 7967 :param PermissionProfile permission_profile: 7968 :return: PermissionProfile 7969 If the method is called asynchronously, 7970 returns the request thread. 7971 """ 7972 7973 all_params = ['account_id', 'permission_profile_id', 'include', 'permission_profile'] 7974 all_params.append('callback') 7975 all_params.append('_return_http_data_only') 7976 all_params.append('_preload_content') 7977 all_params.append('_request_timeout') 7978 7979 params = locals() 7980 for key, val in iteritems(params['kwargs']): 7981 if key not in all_params: 7982 raise TypeError( 7983 "Got an unexpected keyword argument '%s'" 7984 " to method update_permission_profile" % key 7985 ) 7986 params[key] = val 7987 del params['kwargs'] 7988 # verify the required parameter 'account_id' is set 7989 if ('account_id' not in params) or (params['account_id'] is None): 7990 raise ValueError("Missing the required parameter `account_id` when calling `update_permission_profile`") 7991 # verify the required parameter 'permission_profile_id' is set 7992 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 7993 raise ValueError("Missing the required parameter `permission_profile_id` when calling `update_permission_profile`") 7994 7995 7996 collection_formats = {} 7997 7998 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 7999 path_params = {} 8000 if 'account_id' in params: 8001 path_params['accountId'] = params['account_id'] 8002 if 'permission_profile_id' in params: 8003 path_params['permissionProfileId'] = params['permission_profile_id'] 8004 8005 query_params = {} 8006 if 'include' in params: 8007 query_params['include'] = params['include'] 8008 8009 header_params = {} 8010 8011 form_params = [] 8012 local_var_files = {} 8013 8014 body_params = None 8015 if 'permission_profile' in params: 8016 body_params = params['permission_profile'] 8017 # HTTP header `Accept` 8018 header_params['Accept'] = self.api_client.\ 8019 select_header_accept(['application/json']) 8020 8021 # Authentication setting 8022 auth_settings = [] 8023 8024 return self.api_client.call_api(resource_path, 'PUT', 8025 path_params, 8026 query_params, 8027 header_params, 8028 body=body_params, 8029 post_params=form_params, 8030 files=local_var_files, 8031 response_type='PermissionProfile', 8032 auth_settings=auth_settings, 8033 callback=params.get('callback'), 8034 _return_http_data_only=params.get('_return_http_data_only'), 8035 _preload_content=params.get('_preload_content', True), 8036 _request_timeout=params.get('_request_timeout'), 8037 collection_formats=collection_formats) 8038 8039 def update_settings(self, account_id, **kwargs): 8040 """ 8041 Updates the account settings for an account. 8042 Updates the account settings for the specified account. 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.update_settings(account_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 AccountSettingsInformation account_settings_information: 8055 :return: None 8056 If the method is called asynchronously, 8057 returns the request thread. 8058 """ 8059 kwargs['_return_http_data_only'] = True 8060 if kwargs.get('callback'): 8061 return self.update_settings_with_http_info(account_id, **kwargs) 8062 else: 8063 (data) = self.update_settings_with_http_info(account_id, **kwargs) 8064 return data 8065 8066 def update_settings_with_http_info(self, account_id, **kwargs): 8067 """ 8068 Updates the account settings for an account. 8069 Updates the account settings for the specified account. 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.update_settings_with_http_info(account_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 AccountSettingsInformation account_settings_information: 8082 :return: None 8083 If the method is called asynchronously, 8084 returns the request thread. 8085 """ 8086 8087 all_params = ['account_id', 'account_settings_information'] 8088 all_params.append('callback') 8089 all_params.append('_return_http_data_only') 8090 all_params.append('_preload_content') 8091 all_params.append('_request_timeout') 8092 8093 params = locals() 8094 for key, val in iteritems(params['kwargs']): 8095 if key not in all_params: 8096 raise TypeError( 8097 "Got an unexpected keyword argument '%s'" 8098 " to method update_settings" % key 8099 ) 8100 params[key] = val 8101 del params['kwargs'] 8102 # verify the required parameter 'account_id' is set 8103 if ('account_id' not in params) or (params['account_id'] is None): 8104 raise ValueError("Missing the required parameter `account_id` when calling `update_settings`") 8105 8106 8107 collection_formats = {} 8108 8109 resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json') 8110 path_params = {} 8111 if 'account_id' in params: 8112 path_params['accountId'] = params['account_id'] 8113 8114 query_params = {} 8115 8116 header_params = {} 8117 8118 form_params = [] 8119 local_var_files = {} 8120 8121 body_params = None 8122 if 'account_settings_information' in params: 8123 body_params = params['account_settings_information'] 8124 # HTTP header `Accept` 8125 header_params['Accept'] = self.api_client.\ 8126 select_header_accept(['application/json']) 8127 8128 # Authentication setting 8129 auth_settings = [] 8130 8131 return self.api_client.call_api(resource_path, 'PUT', 8132 path_params, 8133 query_params, 8134 header_params, 8135 body=body_params, 8136 post_params=form_params, 8137 files=local_var_files, 8138 response_type=None, 8139 auth_settings=auth_settings, 8140 callback=params.get('callback'), 8141 _return_http_data_only=params.get('_return_http_data_only'), 8142 _preload_content=params.get('_preload_content', True), 8143 _request_timeout=params.get('_request_timeout'), 8144 collection_formats=collection_formats) 8145 8146 def update_shared_access(self, account_id, **kwargs): 8147 """ 8148 Reserved: Sets the shared access information for users. 8149 Reserved: Sets the shared access information for one or more users. 8150 This method makes a synchronous HTTP request by default. To make an 8151 asynchronous HTTP request, please define a `callback` function 8152 to be invoked when receiving the response. 8153 >>> def callback_function(response): 8154 >>> pprint(response) 8155 >>> 8156 >>> thread = api.update_shared_access(account_id, callback=callback_function) 8157 8158 :param callback function: The callback function 8159 for asynchronous request. (optional) 8160 :param str account_id: The external account number (int) or account ID Guid. (required) 8161 :param str item_type: 8162 :param str preserve_existing_shared_access: 8163 :param str user_ids: 8164 :param AccountSharedAccess account_shared_access: 8165 :return: AccountSharedAccess 8166 If the method is called asynchronously, 8167 returns the request thread. 8168 """ 8169 kwargs['_return_http_data_only'] = True 8170 if kwargs.get('callback'): 8171 return self.update_shared_access_with_http_info(account_id, **kwargs) 8172 else: 8173 (data) = self.update_shared_access_with_http_info(account_id, **kwargs) 8174 return data 8175 8176 def update_shared_access_with_http_info(self, account_id, **kwargs): 8177 """ 8178 Reserved: Sets the shared access information for users. 8179 Reserved: Sets the shared access information for one or more users. 8180 This method makes a synchronous HTTP request by default. To make an 8181 asynchronous HTTP request, please define a `callback` function 8182 to be invoked when receiving the response. 8183 >>> def callback_function(response): 8184 >>> pprint(response) 8185 >>> 8186 >>> thread = api.update_shared_access_with_http_info(account_id, callback=callback_function) 8187 8188 :param callback function: The callback function 8189 for asynchronous request. (optional) 8190 :param str account_id: The external account number (int) or account ID Guid. (required) 8191 :param str item_type: 8192 :param str preserve_existing_shared_access: 8193 :param str user_ids: 8194 :param AccountSharedAccess account_shared_access: 8195 :return: AccountSharedAccess 8196 If the method is called asynchronously, 8197 returns the request thread. 8198 """ 8199 8200 all_params = ['account_id', 'item_type', 'preserve_existing_shared_access', 'user_ids', 'account_shared_access'] 8201 all_params.append('callback') 8202 all_params.append('_return_http_data_only') 8203 all_params.append('_preload_content') 8204 all_params.append('_request_timeout') 8205 8206 params = locals() 8207 for key, val in iteritems(params['kwargs']): 8208 if key not in all_params: 8209 raise TypeError( 8210 "Got an unexpected keyword argument '%s'" 8211 " to method update_shared_access" % key 8212 ) 8213 params[key] = val 8214 del params['kwargs'] 8215 # verify the required parameter 'account_id' is set 8216 if ('account_id' not in params) or (params['account_id'] is None): 8217 raise ValueError("Missing the required parameter `account_id` when calling `update_shared_access`") 8218 8219 8220 collection_formats = {} 8221 8222 resource_path = '/v2.1/accounts/{accountId}/shared_access'.replace('{format}', 'json') 8223 path_params = {} 8224 if 'account_id' in params: 8225 path_params['accountId'] = params['account_id'] 8226 8227 query_params = {} 8228 if 'item_type' in params: 8229 query_params['item_type'] = params['item_type'] 8230 if 'preserve_existing_shared_access' in params: 8231 query_params['preserve_existing_shared_access'] = params['preserve_existing_shared_access'] 8232 if 'user_ids' in params: 8233 query_params['user_ids'] = params['user_ids'] 8234 8235 header_params = {} 8236 8237 form_params = [] 8238 local_var_files = {} 8239 8240 body_params = None 8241 if 'account_shared_access' in params: 8242 body_params = params['account_shared_access'] 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, 'PUT', 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='AccountSharedAccess', 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 update_user_authorization(self, account_id, authorization_id, user_id, **kwargs): 8266 """ 8267 Updates the user authorization 8268 This method makes a synchronous HTTP request by default. To make an 8269 asynchronous HTTP request, please define a `callback` function 8270 to be invoked when receiving the response. 8271 >>> def callback_function(response): 8272 >>> pprint(response) 8273 >>> 8274 >>> thread = api.update_user_authorization(account_id, authorization_id, user_id, callback=callback_function) 8275 8276 :param callback function: The callback function 8277 for asynchronous request. (optional) 8278 :param str account_id: The external account number (int) or account ID Guid. (required) 8279 :param str authorization_id: (required) 8280 :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required) 8281 :param UserAuthorizationUpdateRequest user_authorization_update_request: 8282 :return: UserAuthorization 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.update_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 8289 else: 8290 (data) = self.update_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 8291 return data 8292 8293 def update_user_authorization_with_http_info(self, account_id, authorization_id, user_id, **kwargs): 8294 """ 8295 Updates the user authorization 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.update_user_authorization_with_http_info(account_id, authorization_id, user_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 authorization_id: (required) 8308 :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required) 8309 :param UserAuthorizationUpdateRequest user_authorization_update_request: 8310 :return: UserAuthorization 8311 If the method is called asynchronously, 8312 returns the request thread. 8313 """ 8314 8315 all_params = ['account_id', 'authorization_id', 'user_id', 'user_authorization_update_request'] 8316 all_params.append('callback') 8317 all_params.append('_return_http_data_only') 8318 all_params.append('_preload_content') 8319 all_params.append('_request_timeout') 8320 8321 params = locals() 8322 for key, val in iteritems(params['kwargs']): 8323 if key not in all_params: 8324 raise TypeError( 8325 "Got an unexpected keyword argument '%s'" 8326 " to method update_user_authorization" % key 8327 ) 8328 params[key] = val 8329 del params['kwargs'] 8330 # verify the required parameter 'account_id' is set 8331 if ('account_id' not in params) or (params['account_id'] is None): 8332 raise ValueError("Missing the required parameter `account_id` when calling `update_user_authorization`") 8333 # verify the required parameter 'authorization_id' is set 8334 if ('authorization_id' not in params) or (params['authorization_id'] is None): 8335 raise ValueError("Missing the required parameter `authorization_id` when calling `update_user_authorization`") 8336 # verify the required parameter 'user_id' is set 8337 if ('user_id' not in params) or (params['user_id'] is None): 8338 raise ValueError("Missing the required parameter `user_id` when calling `update_user_authorization`") 8339 8340 8341 collection_formats = {} 8342 8343 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorization/{authorizationId}'.replace('{format}', 'json') 8344 path_params = {} 8345 if 'account_id' in params: 8346 path_params['accountId'] = params['account_id'] 8347 if 'authorization_id' in params: 8348 path_params['authorizationId'] = params['authorization_id'] 8349 if 'user_id' in params: 8350 path_params['userId'] = params['user_id'] 8351 8352 query_params = {} 8353 8354 header_params = {} 8355 8356 form_params = [] 8357 local_var_files = {} 8358 8359 body_params = None 8360 if 'user_authorization_update_request' in params: 8361 body_params = params['user_authorization_update_request'] 8362 # HTTP header `Accept` 8363 header_params['Accept'] = self.api_client.\ 8364 select_header_accept(['application/json']) 8365 8366 # Authentication setting 8367 auth_settings = [] 8368 8369 return self.api_client.call_api(resource_path, 'PUT', 8370 path_params, 8371 query_params, 8372 header_params, 8373 body=body_params, 8374 post_params=form_params, 8375 files=local_var_files, 8376 response_type='UserAuthorization', 8377 auth_settings=auth_settings, 8378 callback=params.get('callback'), 8379 _return_http_data_only=params.get('_return_http_data_only'), 8380 _preload_content=params.get('_preload_content', True), 8381 _request_timeout=params.get('_request_timeout'), 8382 collection_formats=collection_formats) 8383 8384 def update_watermark(self, account_id, **kwargs): 8385 """ 8386 Update watermark information. 8387 8388 This method makes a synchronous HTTP request by default. To make an 8389 asynchronous HTTP request, please define a `callback` function 8390 to be invoked when receiving the response. 8391 >>> def callback_function(response): 8392 >>> pprint(response) 8393 >>> 8394 >>> thread = api.update_watermark(account_id, callback=callback_function) 8395 8396 :param callback function: The callback function 8397 for asynchronous request. (optional) 8398 :param str account_id: The external account number (int) or account ID Guid. (required) 8399 :param Watermark watermark: 8400 :return: Watermark 8401 If the method is called asynchronously, 8402 returns the request thread. 8403 """ 8404 kwargs['_return_http_data_only'] = True 8405 if kwargs.get('callback'): 8406 return self.update_watermark_with_http_info(account_id, **kwargs) 8407 else: 8408 (data) = self.update_watermark_with_http_info(account_id, **kwargs) 8409 return data 8410 8411 def update_watermark_with_http_info(self, account_id, **kwargs): 8412 """ 8413 Update watermark information. 8414 8415 This method makes a synchronous HTTP request by default. To make an 8416 asynchronous HTTP request, please define a `callback` function 8417 to be invoked when receiving the response. 8418 >>> def callback_function(response): 8419 >>> pprint(response) 8420 >>> 8421 >>> thread = api.update_watermark_with_http_info(account_id, callback=callback_function) 8422 8423 :param callback function: The callback function 8424 for asynchronous request. (optional) 8425 :param str account_id: The external account number (int) or account ID Guid. (required) 8426 :param Watermark watermark: 8427 :return: Watermark 8428 If the method is called asynchronously, 8429 returns the request thread. 8430 """ 8431 8432 all_params = ['account_id', 'watermark'] 8433 all_params.append('callback') 8434 all_params.append('_return_http_data_only') 8435 all_params.append('_preload_content') 8436 all_params.append('_request_timeout') 8437 8438 params = locals() 8439 for key, val in iteritems(params['kwargs']): 8440 if key not in all_params: 8441 raise TypeError( 8442 "Got an unexpected keyword argument '%s'" 8443 " to method update_watermark" % key 8444 ) 8445 params[key] = val 8446 del params['kwargs'] 8447 # verify the required parameter 'account_id' is set 8448 if ('account_id' not in params) or (params['account_id'] is None): 8449 raise ValueError("Missing the required parameter `account_id` when calling `update_watermark`") 8450 8451 8452 collection_formats = {} 8453 8454 resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json') 8455 path_params = {} 8456 if 'account_id' in params: 8457 path_params['accountId'] = params['account_id'] 8458 8459 query_params = {} 8460 8461 header_params = {} 8462 8463 form_params = [] 8464 local_var_files = {} 8465 8466 body_params = None 8467 if 'watermark' in params: 8468 body_params = params['watermark'] 8469 # HTTP header `Accept` 8470 header_params['Accept'] = self.api_client.\ 8471 select_header_accept(['application/json']) 8472 8473 # Authentication setting 8474 auth_settings = [] 8475 8476 return self.api_client.call_api(resource_path, 'PUT', 8477 path_params, 8478 query_params, 8479 header_params, 8480 body=body_params, 8481 post_params=form_params, 8482 files=local_var_files, 8483 response_type='Watermark', 8484 auth_settings=auth_settings, 8485 callback=params.get('callback'), 8486 _return_http_data_only=params.get('_return_http_data_only'), 8487 _preload_content=params.get('_preload_content', True), 8488 _request_timeout=params.get('_request_timeout'), 8489 collection_formats=collection_formats)
class
AccountsApi:
28class AccountsApi(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 create(self, **kwargs): 45 """ 46 Creates new accounts. 47 Creates new DocuSign service accounts. This is used to create multiple DocuSign accounts with one call. It uses the same information and formats as the normal a [Accounts:create](accounts_create) call with the information included within a `newAccountRequests` element. A maximum of 100 new accounts can be created at one time. Note that the structure of the XML request is slightly different than the JSON request, in that the new account information is included in a `newAccountDefinition` property inside the `newAccountRequests` element. Response The response returns the new account ID, password and the default user information for each newly created account. A 201 code is returned if the call succeeded. While the call may have succeed, some of the individual account requests may have failed. In the case of failures to create the account, an `errorDetails` node is added in the response to each specific request that failed. 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.create(callback=callback_function) 55 56 :param callback function: The callback function 57 for asynchronous request. (optional) 58 :param str preview_billing_plan: When set to **true**, creates the account using a preview billing plan. 59 :param NewAccountDefinition new_account_definition: 60 :return: NewAccountSummary 61 If the method is called asynchronously, 62 returns the request thread. 63 """ 64 kwargs['_return_http_data_only'] = True 65 if kwargs.get('callback'): 66 return self.create_with_http_info(**kwargs) 67 else: 68 (data) = self.create_with_http_info(**kwargs) 69 return data 70 71 def create_with_http_info(self, **kwargs): 72 """ 73 Creates new accounts. 74 Creates new DocuSign service accounts. This is used to create multiple DocuSign accounts with one call. It uses the same information and formats as the normal a [Accounts:create](accounts_create) call with the information included within a `newAccountRequests` element. A maximum of 100 new accounts can be created at one time. Note that the structure of the XML request is slightly different than the JSON request, in that the new account information is included in a `newAccountDefinition` property inside the `newAccountRequests` element. Response The response returns the new account ID, password and the default user information for each newly created account. A 201 code is returned if the call succeeded. While the call may have succeed, some of the individual account requests may have failed. In the case of failures to create the account, an `errorDetails` node is added in the response to each specific request that failed. 75 This method makes a synchronous HTTP request by default. To make an 76 asynchronous HTTP request, please define a `callback` function 77 to be invoked when receiving the response. 78 >>> def callback_function(response): 79 >>> pprint(response) 80 >>> 81 >>> thread = api.create_with_http_info(callback=callback_function) 82 83 :param callback function: The callback function 84 for asynchronous request. (optional) 85 :param str preview_billing_plan: When set to **true**, creates the account using a preview billing plan. 86 :param NewAccountDefinition new_account_definition: 87 :return: NewAccountSummary 88 If the method is called asynchronously, 89 returns the request thread. 90 """ 91 92 all_params = ['preview_billing_plan', 'new_account_definition'] 93 all_params.append('callback') 94 all_params.append('_return_http_data_only') 95 all_params.append('_preload_content') 96 all_params.append('_request_timeout') 97 98 params = locals() 99 for key, val in iteritems(params['kwargs']): 100 if key not in all_params: 101 raise TypeError( 102 "Got an unexpected keyword argument '%s'" 103 " to method create" % key 104 ) 105 params[key] = val 106 del params['kwargs'] 107 108 109 collection_formats = {} 110 111 resource_path = '/v2.1/accounts'.replace('{format}', 'json') 112 path_params = {} 113 114 query_params = {} 115 if 'preview_billing_plan' in params: 116 query_params['preview_billing_plan'] = params['preview_billing_plan'] 117 118 header_params = {} 119 120 form_params = [] 121 local_var_files = {} 122 123 body_params = None 124 if 'new_account_definition' in params: 125 body_params = params['new_account_definition'] 126 # HTTP header `Accept` 127 header_params['Accept'] = self.api_client.\ 128 select_header_accept(['application/json']) 129 130 # Authentication setting 131 auth_settings = [] 132 133 return self.api_client.call_api(resource_path, 'POST', 134 path_params, 135 query_params, 136 header_params, 137 body=body_params, 138 post_params=form_params, 139 files=local_var_files, 140 response_type='NewAccountSummary', 141 auth_settings=auth_settings, 142 callback=params.get('callback'), 143 _return_http_data_only=params.get('_return_http_data_only'), 144 _preload_content=params.get('_preload_content', True), 145 _request_timeout=params.get('_request_timeout'), 146 collection_formats=collection_formats) 147 148 def create_account_signatures(self, account_id, **kwargs): 149 """ 150 Adds/updates one or more account signatures. This request may include images in multi-part format. 151 152 This method makes a synchronous HTTP request by default. To make an 153 asynchronous HTTP request, please define a `callback` function 154 to be invoked when receiving the response. 155 >>> def callback_function(response): 156 >>> pprint(response) 157 >>> 158 >>> thread = api.create_account_signatures(account_id, callback=callback_function) 159 160 :param callback function: The callback function 161 for asynchronous request. (optional) 162 :param str account_id: The external account number (int) or account ID Guid. (required) 163 :param str decode_only: 164 :param AccountSignaturesInformation account_signatures_information: 165 :return: AccountSignaturesInformation 166 If the method is called asynchronously, 167 returns the request thread. 168 """ 169 kwargs['_return_http_data_only'] = True 170 if kwargs.get('callback'): 171 return self.create_account_signatures_with_http_info(account_id, **kwargs) 172 else: 173 (data) = self.create_account_signatures_with_http_info(account_id, **kwargs) 174 return data 175 176 def create_account_signatures_with_http_info(self, account_id, **kwargs): 177 """ 178 Adds/updates one or more account signatures. This request may include images in multi-part format. 179 180 This method makes a synchronous HTTP request by default. To make an 181 asynchronous HTTP request, please define a `callback` function 182 to be invoked when receiving the response. 183 >>> def callback_function(response): 184 >>> pprint(response) 185 >>> 186 >>> thread = api.create_account_signatures_with_http_info(account_id, callback=callback_function) 187 188 :param callback function: The callback function 189 for asynchronous request. (optional) 190 :param str account_id: The external account number (int) or account ID Guid. (required) 191 :param str decode_only: 192 :param AccountSignaturesInformation account_signatures_information: 193 :return: AccountSignaturesInformation 194 If the method is called asynchronously, 195 returns the request thread. 196 """ 197 198 all_params = ['account_id', 'decode_only', 'account_signatures_information'] 199 all_params.append('callback') 200 all_params.append('_return_http_data_only') 201 all_params.append('_preload_content') 202 all_params.append('_request_timeout') 203 204 params = locals() 205 for key, val in iteritems(params['kwargs']): 206 if key not in all_params: 207 raise TypeError( 208 "Got an unexpected keyword argument '%s'" 209 " to method create_account_signatures" % key 210 ) 211 params[key] = val 212 del params['kwargs'] 213 # verify the required parameter 'account_id' is set 214 if ('account_id' not in params) or (params['account_id'] is None): 215 raise ValueError("Missing the required parameter `account_id` when calling `create_account_signatures`") 216 217 218 collection_formats = {} 219 220 resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json') 221 path_params = {} 222 if 'account_id' in params: 223 path_params['accountId'] = params['account_id'] 224 225 query_params = {} 226 if 'decode_only' in params: 227 query_params['decode_only'] = params['decode_only'] 228 229 header_params = {} 230 231 form_params = [] 232 local_var_files = {} 233 234 body_params = None 235 if 'account_signatures_information' in params: 236 body_params = params['account_signatures_information'] 237 # HTTP header `Accept` 238 header_params['Accept'] = self.api_client.\ 239 select_header_accept(['application/json']) 240 241 # Authentication setting 242 auth_settings = [] 243 244 return self.api_client.call_api(resource_path, 'POST', 245 path_params, 246 query_params, 247 header_params, 248 body=body_params, 249 post_params=form_params, 250 files=local_var_files, 251 response_type='AccountSignaturesInformation', 252 auth_settings=auth_settings, 253 callback=params.get('callback'), 254 _return_http_data_only=params.get('_return_http_data_only'), 255 _preload_content=params.get('_preload_content', True), 256 _request_timeout=params.get('_request_timeout'), 257 collection_formats=collection_formats) 258 259 def create_brand(self, account_id, **kwargs): 260 """ 261 Creates one or more brand profile files for the account. 262 Creates one or more brand profile files for the account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSig`) must be set to **true** for the account to use this call. An error is returned if `brandId` property for a brand profile is already set for the account. To upload a new version of an existing brand profile, you must delete the profile and then upload the newer version. When brand profile files are being uploaded, they must be combined into one zip file and the `Content-Type` must be `application/zip`. 263 This method makes a synchronous HTTP request by default. To make an 264 asynchronous HTTP request, please define a `callback` function 265 to be invoked when receiving the response. 266 >>> def callback_function(response): 267 >>> pprint(response) 268 >>> 269 >>> thread = api.create_brand(account_id, callback=callback_function) 270 271 :param callback function: The callback function 272 for asynchronous request. (optional) 273 :param str account_id: The external account number (int) or account ID GUID. (required) 274 :param Brand brand: 275 :return: BrandsResponse 276 If the method is called asynchronously, 277 returns the request thread. 278 """ 279 kwargs['_return_http_data_only'] = True 280 if kwargs.get('callback'): 281 return self.create_brand_with_http_info(account_id, **kwargs) 282 else: 283 (data) = self.create_brand_with_http_info(account_id, **kwargs) 284 return data 285 286 def create_brand_with_http_info(self, account_id, **kwargs): 287 """ 288 Creates one or more brand profile files for the account. 289 Creates one or more brand profile files for the account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSig`) must be set to **true** for the account to use this call. An error is returned if `brandId` property for a brand profile is already set for the account. To upload a new version of an existing brand profile, you must delete the profile and then upload the newer version. When brand profile files are being uploaded, they must be combined into one zip file and the `Content-Type` must be `application/zip`. 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_brand_with_http_info(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 Brand brand: 302 :return: BrandsResponse 303 If the method is called asynchronously, 304 returns the request thread. 305 """ 306 307 all_params = ['account_id', 'brand'] 308 all_params.append('callback') 309 all_params.append('_return_http_data_only') 310 all_params.append('_preload_content') 311 all_params.append('_request_timeout') 312 313 params = locals() 314 for key, val in iteritems(params['kwargs']): 315 if key not in all_params: 316 raise TypeError( 317 "Got an unexpected keyword argument '%s'" 318 " to method create_brand" % key 319 ) 320 params[key] = val 321 del params['kwargs'] 322 # verify the required parameter 'account_id' is set 323 if ('account_id' not in params) or (params['account_id'] is None): 324 raise ValueError("Missing the required parameter `account_id` when calling `create_brand`") 325 326 327 collection_formats = {} 328 329 resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json') 330 path_params = {} 331 if 'account_id' in params: 332 path_params['accountId'] = params['account_id'] 333 334 query_params = {} 335 336 header_params = {} 337 338 form_params = [] 339 local_var_files = {} 340 341 body_params = None 342 if 'brand' in params: 343 body_params = params['brand'] 344 # HTTP header `Accept` 345 header_params['Accept'] = self.api_client.\ 346 select_header_accept(['application/json']) 347 348 # Authentication setting 349 auth_settings = [] 350 351 return self.api_client.call_api(resource_path, 'POST', 352 path_params, 353 query_params, 354 header_params, 355 body=body_params, 356 post_params=form_params, 357 files=local_var_files, 358 response_type='BrandsResponse', 359 auth_settings=auth_settings, 360 callback=params.get('callback'), 361 _return_http_data_only=params.get('_return_http_data_only'), 362 _preload_content=params.get('_preload_content', True), 363 _request_timeout=params.get('_request_timeout'), 364 collection_formats=collection_formats) 365 366 def create_custom_field(self, account_id, **kwargs): 367 """ 368 Creates an acount custom field. 369 This method creates a custom field and makes it available for all new envelopes associated with an account. 370 This method makes a synchronous HTTP request by default. To make an 371 asynchronous HTTP request, please define a `callback` function 372 to be invoked when receiving the response. 373 >>> def callback_function(response): 374 >>> pprint(response) 375 >>> 376 >>> thread = api.create_custom_field(account_id, callback=callback_function) 377 378 :param callback function: The callback function 379 for asynchronous request. (optional) 380 :param str account_id: The external account number (int) or account ID Guid. (required) 381 :param str apply_to_templates: 382 :param CustomField custom_field: 383 :return: CustomFields 384 If the method is called asynchronously, 385 returns the request thread. 386 """ 387 kwargs['_return_http_data_only'] = True 388 if kwargs.get('callback'): 389 return self.create_custom_field_with_http_info(account_id, **kwargs) 390 else: 391 (data) = self.create_custom_field_with_http_info(account_id, **kwargs) 392 return data 393 394 def create_custom_field_with_http_info(self, account_id, **kwargs): 395 """ 396 Creates an acount custom field. 397 This method creates a custom field and makes it available for all new envelopes associated with an account. 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_custom_field_with_http_info(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 str apply_to_templates: 410 :param CustomField custom_field: 411 :return: CustomFields 412 If the method is called asynchronously, 413 returns the request thread. 414 """ 415 416 all_params = ['account_id', 'apply_to_templates', 'custom_field'] 417 all_params.append('callback') 418 all_params.append('_return_http_data_only') 419 all_params.append('_preload_content') 420 all_params.append('_request_timeout') 421 422 params = locals() 423 for key, val in iteritems(params['kwargs']): 424 if key not in all_params: 425 raise TypeError( 426 "Got an unexpected keyword argument '%s'" 427 " to method create_custom_field" % key 428 ) 429 params[key] = val 430 del params['kwargs'] 431 # verify the required parameter 'account_id' is set 432 if ('account_id' not in params) or (params['account_id'] is None): 433 raise ValueError("Missing the required parameter `account_id` when calling `create_custom_field`") 434 435 436 collection_formats = {} 437 438 resource_path = '/v2.1/accounts/{accountId}/custom_fields'.replace('{format}', 'json') 439 path_params = {} 440 if 'account_id' in params: 441 path_params['accountId'] = params['account_id'] 442 443 query_params = {} 444 if 'apply_to_templates' in params: 445 query_params['apply_to_templates'] = params['apply_to_templates'] 446 447 header_params = {} 448 449 form_params = [] 450 local_var_files = {} 451 452 body_params = None 453 if 'custom_field' in params: 454 body_params = params['custom_field'] 455 # HTTP header `Accept` 456 header_params['Accept'] = self.api_client.\ 457 select_header_accept(['application/json']) 458 459 # Authentication setting 460 auth_settings = [] 461 462 return self.api_client.call_api(resource_path, 'POST', 463 path_params, 464 query_params, 465 header_params, 466 body=body_params, 467 post_params=form_params, 468 files=local_var_files, 469 response_type='CustomFields', 470 auth_settings=auth_settings, 471 callback=params.get('callback'), 472 _return_http_data_only=params.get('_return_http_data_only'), 473 _preload_content=params.get('_preload_content', True), 474 _request_timeout=params.get('_request_timeout'), 475 collection_formats=collection_formats) 476 477 def create_permission_profile(self, account_id, **kwargs): 478 """ 479 Creates a new permission profile in the specified account. 480 This method creates a new permission profile for an account. ### Related topics - [How to create a permission profile](/docs/esign-rest-api/how-to/permission-profile-creating/) 481 This method makes a synchronous HTTP request by default. To make an 482 asynchronous HTTP request, please define a `callback` function 483 to be invoked when receiving the response. 484 >>> def callback_function(response): 485 >>> pprint(response) 486 >>> 487 >>> thread = api.create_permission_profile(account_id, callback=callback_function) 488 489 :param callback function: The callback function 490 for asynchronous request. (optional) 491 :param str account_id: The external account number (int) or account ID Guid. (required) 492 :param str include: 493 :param PermissionProfile permission_profile: 494 :return: PermissionProfile 495 If the method is called asynchronously, 496 returns the request thread. 497 """ 498 kwargs['_return_http_data_only'] = True 499 if kwargs.get('callback'): 500 return self.create_permission_profile_with_http_info(account_id, **kwargs) 501 else: 502 (data) = self.create_permission_profile_with_http_info(account_id, **kwargs) 503 return data 504 505 def create_permission_profile_with_http_info(self, account_id, **kwargs): 506 """ 507 Creates a new permission profile in the specified account. 508 This method creates a new permission profile for an account. ### Related topics - [How to create a permission profile](/docs/esign-rest-api/how-to/permission-profile-creating/) 509 This method makes a synchronous HTTP request by default. To make an 510 asynchronous HTTP request, please define a `callback` function 511 to be invoked when receiving the response. 512 >>> def callback_function(response): 513 >>> pprint(response) 514 >>> 515 >>> thread = api.create_permission_profile_with_http_info(account_id, callback=callback_function) 516 517 :param callback function: The callback function 518 for asynchronous request. (optional) 519 :param str account_id: The external account number (int) or account ID Guid. (required) 520 :param str include: 521 :param PermissionProfile permission_profile: 522 :return: PermissionProfile 523 If the method is called asynchronously, 524 returns the request thread. 525 """ 526 527 all_params = ['account_id', 'include', 'permission_profile'] 528 all_params.append('callback') 529 all_params.append('_return_http_data_only') 530 all_params.append('_preload_content') 531 all_params.append('_request_timeout') 532 533 params = locals() 534 for key, val in iteritems(params['kwargs']): 535 if key not in all_params: 536 raise TypeError( 537 "Got an unexpected keyword argument '%s'" 538 " to method create_permission_profile" % key 539 ) 540 params[key] = val 541 del params['kwargs'] 542 # verify the required parameter 'account_id' is set 543 if ('account_id' not in params) or (params['account_id'] is None): 544 raise ValueError("Missing the required parameter `account_id` when calling `create_permission_profile`") 545 546 547 collection_formats = {} 548 549 resource_path = '/v2.1/accounts/{accountId}/permission_profiles'.replace('{format}', 'json') 550 path_params = {} 551 if 'account_id' in params: 552 path_params['accountId'] = params['account_id'] 553 554 query_params = {} 555 if 'include' in params: 556 query_params['include'] = params['include'] 557 558 header_params = {} 559 560 form_params = [] 561 local_var_files = {} 562 563 body_params = None 564 if 'permission_profile' in params: 565 body_params = params['permission_profile'] 566 # HTTP header `Accept` 567 header_params['Accept'] = self.api_client.\ 568 select_header_accept(['application/json']) 569 570 # Authentication setting 571 auth_settings = [] 572 573 return self.api_client.call_api(resource_path, 'POST', 574 path_params, 575 query_params, 576 header_params, 577 body=body_params, 578 post_params=form_params, 579 files=local_var_files, 580 response_type='PermissionProfile', 581 auth_settings=auth_settings, 582 callback=params.get('callback'), 583 _return_http_data_only=params.get('_return_http_data_only'), 584 _preload_content=params.get('_preload_content', True), 585 _request_timeout=params.get('_request_timeout'), 586 collection_formats=collection_formats) 587 588 def create_user_authorization(self, account_id, user_id, **kwargs): 589 """ 590 Creates the user authorization 591 This method makes a synchronous HTTP request by default. To make an 592 asynchronous HTTP request, please define a `callback` function 593 to be invoked when receiving the response. 594 >>> def callback_function(response): 595 >>> pprint(response) 596 >>> 597 >>> thread = api.create_user_authorization(account_id, user_id, callback=callback_function) 598 599 :param callback function: The callback function 600 for asynchronous request. (optional) 601 :param str account_id: The external account number (int) or account ID Guid. (required) 602 :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required) 603 :param UserAuthorizationCreateRequest user_authorization_create_request: 604 :return: UserAuthorization 605 If the method is called asynchronously, 606 returns the request thread. 607 """ 608 kwargs['_return_http_data_only'] = True 609 if kwargs.get('callback'): 610 return self.create_user_authorization_with_http_info(account_id, user_id, **kwargs) 611 else: 612 (data) = self.create_user_authorization_with_http_info(account_id, user_id, **kwargs) 613 return data 614 615 def create_user_authorization_with_http_info(self, account_id, user_id, **kwargs): 616 """ 617 Creates the user authorization 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_user_authorization_with_http_info(account_id, user_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 user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required) 630 :param UserAuthorizationCreateRequest user_authorization_create_request: 631 :return: UserAuthorization 632 If the method is called asynchronously, 633 returns the request thread. 634 """ 635 636 all_params = ['account_id', 'user_id', 'user_authorization_create_request'] 637 all_params.append('callback') 638 all_params.append('_return_http_data_only') 639 all_params.append('_preload_content') 640 all_params.append('_request_timeout') 641 642 params = locals() 643 for key, val in iteritems(params['kwargs']): 644 if key not in all_params: 645 raise TypeError( 646 "Got an unexpected keyword argument '%s'" 647 " to method create_user_authorization" % key 648 ) 649 params[key] = val 650 del params['kwargs'] 651 # verify the required parameter 'account_id' is set 652 if ('account_id' not in params) or (params['account_id'] is None): 653 raise ValueError("Missing the required parameter `account_id` when calling `create_user_authorization`") 654 # verify the required parameter 'user_id' is set 655 if ('user_id' not in params) or (params['user_id'] is None): 656 raise ValueError("Missing the required parameter `user_id` when calling `create_user_authorization`") 657 658 659 collection_formats = {} 660 661 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorization'.replace('{format}', 'json') 662 path_params = {} 663 if 'account_id' in params: 664 path_params['accountId'] = params['account_id'] 665 if 'user_id' in params: 666 path_params['userId'] = params['user_id'] 667 668 query_params = {} 669 670 header_params = {} 671 672 form_params = [] 673 local_var_files = {} 674 675 body_params = None 676 if 'user_authorization_create_request' in params: 677 body_params = params['user_authorization_create_request'] 678 # HTTP header `Accept` 679 header_params['Accept'] = self.api_client.\ 680 select_header_accept(['application/json']) 681 682 # Authentication setting 683 auth_settings = [] 684 685 return self.api_client.call_api(resource_path, 'POST', 686 path_params, 687 query_params, 688 header_params, 689 body=body_params, 690 post_params=form_params, 691 files=local_var_files, 692 response_type='UserAuthorization', 693 auth_settings=auth_settings, 694 callback=params.get('callback'), 695 _return_http_data_only=params.get('_return_http_data_only'), 696 _preload_content=params.get('_preload_content', True), 697 _request_timeout=params.get('_request_timeout'), 698 collection_formats=collection_formats) 699 700 def create_user_authorizations(self, account_id, user_id, **kwargs): 701 """ 702 Creates ot updates user authorizations 703 This method makes a synchronous HTTP request by default. To make an 704 asynchronous HTTP request, please define a `callback` function 705 to be invoked when receiving the response. 706 >>> def callback_function(response): 707 >>> pprint(response) 708 >>> 709 >>> thread = api.create_user_authorizations(account_id, user_id, callback=callback_function) 710 711 :param callback function: The callback function 712 for asynchronous request. (optional) 713 :param str account_id: The external account number (int) or account ID Guid. (required) 714 :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required) 715 :param UserAuthorizationsRequest user_authorizations_request: 716 :return: UserAuthorizationsResponse 717 If the method is called asynchronously, 718 returns the request thread. 719 """ 720 kwargs['_return_http_data_only'] = True 721 if kwargs.get('callback'): 722 return self.create_user_authorizations_with_http_info(account_id, user_id, **kwargs) 723 else: 724 (data) = self.create_user_authorizations_with_http_info(account_id, user_id, **kwargs) 725 return data 726 727 def create_user_authorizations_with_http_info(self, account_id, user_id, **kwargs): 728 """ 729 Creates ot updates user authorizations 730 This method makes a synchronous HTTP request by default. To make an 731 asynchronous HTTP request, please define a `callback` function 732 to be invoked when receiving the response. 733 >>> def callback_function(response): 734 >>> pprint(response) 735 >>> 736 >>> thread = api.create_user_authorizations_with_http_info(account_id, user_id, callback=callback_function) 737 738 :param callback function: The callback function 739 for asynchronous request. (optional) 740 :param str account_id: The external account number (int) or account ID Guid. (required) 741 :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required) 742 :param UserAuthorizationsRequest user_authorizations_request: 743 :return: UserAuthorizationsResponse 744 If the method is called asynchronously, 745 returns the request thread. 746 """ 747 748 all_params = ['account_id', 'user_id', 'user_authorizations_request'] 749 all_params.append('callback') 750 all_params.append('_return_http_data_only') 751 all_params.append('_preload_content') 752 all_params.append('_request_timeout') 753 754 params = locals() 755 for key, val in iteritems(params['kwargs']): 756 if key not in all_params: 757 raise TypeError( 758 "Got an unexpected keyword argument '%s'" 759 " to method create_user_authorizations" % key 760 ) 761 params[key] = val 762 del params['kwargs'] 763 # verify the required parameter 'account_id' is set 764 if ('account_id' not in params) or (params['account_id'] is None): 765 raise ValueError("Missing the required parameter `account_id` when calling `create_user_authorizations`") 766 # verify the required parameter 'user_id' is set 767 if ('user_id' not in params) or (params['user_id'] is None): 768 raise ValueError("Missing the required parameter `user_id` when calling `create_user_authorizations`") 769 770 771 collection_formats = {} 772 773 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorizations'.replace('{format}', 'json') 774 path_params = {} 775 if 'account_id' in params: 776 path_params['accountId'] = params['account_id'] 777 if 'user_id' in params: 778 path_params['userId'] = params['user_id'] 779 780 query_params = {} 781 782 header_params = {} 783 784 form_params = [] 785 local_var_files = {} 786 787 body_params = None 788 if 'user_authorizations_request' in params: 789 body_params = params['user_authorizations_request'] 790 # HTTP header `Accept` 791 header_params['Accept'] = self.api_client.\ 792 select_header_accept(['application/json']) 793 794 # Authentication setting 795 auth_settings = [] 796 797 return self.api_client.call_api(resource_path, 'POST', 798 path_params, 799 query_params, 800 header_params, 801 body=body_params, 802 post_params=form_params, 803 files=local_var_files, 804 response_type='UserAuthorizationsResponse', 805 auth_settings=auth_settings, 806 callback=params.get('callback'), 807 _return_http_data_only=params.get('_return_http_data_only'), 808 _preload_content=params.get('_preload_content', True), 809 _request_timeout=params.get('_request_timeout'), 810 collection_formats=collection_formats) 811 812 def delete(self, account_id, **kwargs): 813 """ 814 Deletes the specified account. 815 This closes the specified account. You must be an account admin to close your account. Once closed, an account must be reopened by DocuSign. 816 This method makes a synchronous HTTP request by default. To make an 817 asynchronous HTTP request, please define a `callback` function 818 to be invoked when receiving the response. 819 >>> def callback_function(response): 820 >>> pprint(response) 821 >>> 822 >>> thread = api.delete(account_id, callback=callback_function) 823 824 :param callback function: The callback function 825 for asynchronous request. (optional) 826 :param str account_id: The external account number (int) or account ID Guid. (required) 827 :param str redact_user_data: 828 :return: None 829 If the method is called asynchronously, 830 returns the request thread. 831 """ 832 kwargs['_return_http_data_only'] = True 833 if kwargs.get('callback'): 834 return self.delete_with_http_info(account_id, **kwargs) 835 else: 836 (data) = self.delete_with_http_info(account_id, **kwargs) 837 return data 838 839 def delete_with_http_info(self, account_id, **kwargs): 840 """ 841 Deletes the specified account. 842 This closes the specified account. You must be an account admin to close your account. Once closed, an account must be reopened by DocuSign. 843 This method makes a synchronous HTTP request by default. To make an 844 asynchronous HTTP request, please define a `callback` function 845 to be invoked when receiving the response. 846 >>> def callback_function(response): 847 >>> pprint(response) 848 >>> 849 >>> thread = api.delete_with_http_info(account_id, callback=callback_function) 850 851 :param callback function: The callback function 852 for asynchronous request. (optional) 853 :param str account_id: The external account number (int) or account ID Guid. (required) 854 :param str redact_user_data: 855 :return: None 856 If the method is called asynchronously, 857 returns the request thread. 858 """ 859 860 all_params = ['account_id', 'redact_user_data'] 861 all_params.append('callback') 862 all_params.append('_return_http_data_only') 863 all_params.append('_preload_content') 864 all_params.append('_request_timeout') 865 866 params = locals() 867 for key, val in iteritems(params['kwargs']): 868 if key not in all_params: 869 raise TypeError( 870 "Got an unexpected keyword argument '%s'" 871 " to method delete" % key 872 ) 873 params[key] = val 874 del params['kwargs'] 875 # verify the required parameter 'account_id' is set 876 if ('account_id' not in params) or (params['account_id'] is None): 877 raise ValueError("Missing the required parameter `account_id` when calling `delete`") 878 879 880 collection_formats = {} 881 882 resource_path = '/v2.1/accounts/{accountId}'.replace('{format}', 'json') 883 path_params = {} 884 if 'account_id' in params: 885 path_params['accountId'] = params['account_id'] 886 887 query_params = {} 888 if 'redact_user_data' in params: 889 query_params['redact_user_data'] = params['redact_user_data'] 890 891 header_params = {} 892 893 form_params = [] 894 local_var_files = {} 895 896 body_params = None 897 # HTTP header `Accept` 898 header_params['Accept'] = self.api_client.\ 899 select_header_accept(['application/json']) 900 901 # Authentication setting 902 auth_settings = [] 903 904 return self.api_client.call_api(resource_path, 'DELETE', 905 path_params, 906 query_params, 907 header_params, 908 body=body_params, 909 post_params=form_params, 910 files=local_var_files, 911 response_type=None, 912 auth_settings=auth_settings, 913 callback=params.get('callback'), 914 _return_http_data_only=params.get('_return_http_data_only'), 915 _preload_content=params.get('_preload_content', True), 916 _request_timeout=params.get('_request_timeout'), 917 collection_formats=collection_formats) 918 919 def delete_account_signature(self, account_id, signature_id, **kwargs): 920 """ 921 Close the specified signature by Id. 922 923 This method makes a synchronous HTTP request by default. To make an 924 asynchronous HTTP request, please define a `callback` function 925 to be invoked when receiving the response. 926 >>> def callback_function(response): 927 >>> pprint(response) 928 >>> 929 >>> thread = api.delete_account_signature(account_id, signature_id, callback=callback_function) 930 931 :param callback function: The callback function 932 for asynchronous request. (optional) 933 :param str account_id: The external account number (int) or account ID Guid. (required) 934 :param str signature_id: The ID of the signature being accessed. (required) 935 :return: None 936 If the method is called asynchronously, 937 returns the request thread. 938 """ 939 kwargs['_return_http_data_only'] = True 940 if kwargs.get('callback'): 941 return self.delete_account_signature_with_http_info(account_id, signature_id, **kwargs) 942 else: 943 (data) = self.delete_account_signature_with_http_info(account_id, signature_id, **kwargs) 944 return data 945 946 def delete_account_signature_with_http_info(self, account_id, signature_id, **kwargs): 947 """ 948 Close the specified signature by Id. 949 950 This method makes a synchronous HTTP request by default. To make an 951 asynchronous HTTP request, please define a `callback` function 952 to be invoked when receiving the response. 953 >>> def callback_function(response): 954 >>> pprint(response) 955 >>> 956 >>> thread = api.delete_account_signature_with_http_info(account_id, signature_id, callback=callback_function) 957 958 :param callback function: The callback function 959 for asynchronous request. (optional) 960 :param str account_id: The external account number (int) or account ID Guid. (required) 961 :param str signature_id: The ID of the signature being accessed. (required) 962 :return: None 963 If the method is called asynchronously, 964 returns the request thread. 965 """ 966 967 all_params = ['account_id', 'signature_id'] 968 all_params.append('callback') 969 all_params.append('_return_http_data_only') 970 all_params.append('_preload_content') 971 all_params.append('_request_timeout') 972 973 params = locals() 974 for key, val in iteritems(params['kwargs']): 975 if key not in all_params: 976 raise TypeError( 977 "Got an unexpected keyword argument '%s'" 978 " to method delete_account_signature" % key 979 ) 980 params[key] = val 981 del params['kwargs'] 982 # verify the required parameter 'account_id' is set 983 if ('account_id' not in params) or (params['account_id'] is None): 984 raise ValueError("Missing the required parameter `account_id` when calling `delete_account_signature`") 985 # verify the required parameter 'signature_id' is set 986 if ('signature_id' not in params) or (params['signature_id'] is None): 987 raise ValueError("Missing the required parameter `signature_id` when calling `delete_account_signature`") 988 989 990 collection_formats = {} 991 992 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 993 path_params = {} 994 if 'account_id' in params: 995 path_params['accountId'] = params['account_id'] 996 if 'signature_id' in params: 997 path_params['signatureId'] = params['signature_id'] 998 999 query_params = {} 1000 1001 header_params = {} 1002 1003 form_params = [] 1004 local_var_files = {} 1005 1006 body_params = None 1007 # HTTP header `Accept` 1008 header_params['Accept'] = self.api_client.\ 1009 select_header_accept(['application/json']) 1010 1011 # Authentication setting 1012 auth_settings = [] 1013 1014 return self.api_client.call_api(resource_path, 'DELETE', 1015 path_params, 1016 query_params, 1017 header_params, 1018 body=body_params, 1019 post_params=form_params, 1020 files=local_var_files, 1021 response_type=None, 1022 auth_settings=auth_settings, 1023 callback=params.get('callback'), 1024 _return_http_data_only=params.get('_return_http_data_only'), 1025 _preload_content=params.get('_preload_content', True), 1026 _request_timeout=params.get('_request_timeout'), 1027 collection_formats=collection_formats) 1028 1029 def delete_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 1030 """ 1031 Deletes a signature, initials, or stamps image. 1032 1033 This method makes a synchronous HTTP request by default. To make an 1034 asynchronous HTTP request, please define a `callback` function 1035 to be invoked when receiving the response. 1036 >>> def callback_function(response): 1037 >>> pprint(response) 1038 >>> 1039 >>> thread = api.delete_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 1040 1041 :param callback function: The callback function 1042 for asynchronous request. (optional) 1043 :param str account_id: The external account number (int) or account ID Guid. (required) 1044 :param str image_type: One of **signature_image** or **initials_image**. (required) 1045 :param str signature_id: The ID of the signature being accessed. (required) 1046 :return: AccountSignature 1047 If the method is called asynchronously, 1048 returns the request thread. 1049 """ 1050 kwargs['_return_http_data_only'] = True 1051 if kwargs.get('callback'): 1052 return self.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 1053 else: 1054 (data) = self.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 1055 return data 1056 1057 def delete_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 1058 """ 1059 Deletes a signature, initials, or stamps image. 1060 1061 This method makes a synchronous HTTP request by default. To make an 1062 asynchronous HTTP request, please define a `callback` function 1063 to be invoked when receiving the response. 1064 >>> def callback_function(response): 1065 >>> pprint(response) 1066 >>> 1067 >>> thread = api.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 1068 1069 :param callback function: The callback function 1070 for asynchronous request. (optional) 1071 :param str account_id: The external account number (int) or account ID Guid. (required) 1072 :param str image_type: One of **signature_image** or **initials_image**. (required) 1073 :param str signature_id: The ID of the signature being accessed. (required) 1074 :return: AccountSignature 1075 If the method is called asynchronously, 1076 returns the request thread. 1077 """ 1078 1079 all_params = ['account_id', 'image_type', 'signature_id'] 1080 all_params.append('callback') 1081 all_params.append('_return_http_data_only') 1082 all_params.append('_preload_content') 1083 all_params.append('_request_timeout') 1084 1085 params = locals() 1086 for key, val in iteritems(params['kwargs']): 1087 if key not in all_params: 1088 raise TypeError( 1089 "Got an unexpected keyword argument '%s'" 1090 " to method delete_account_signature_image" % key 1091 ) 1092 params[key] = val 1093 del params['kwargs'] 1094 # verify the required parameter 'account_id' is set 1095 if ('account_id' not in params) or (params['account_id'] is None): 1096 raise ValueError("Missing the required parameter `account_id` when calling `delete_account_signature_image`") 1097 # verify the required parameter 'image_type' is set 1098 if ('image_type' not in params) or (params['image_type'] is None): 1099 raise ValueError("Missing the required parameter `image_type` when calling `delete_account_signature_image`") 1100 # verify the required parameter 'signature_id' is set 1101 if ('signature_id' not in params) or (params['signature_id'] is None): 1102 raise ValueError("Missing the required parameter `signature_id` when calling `delete_account_signature_image`") 1103 1104 1105 collection_formats = {} 1106 1107 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 1108 path_params = {} 1109 if 'account_id' in params: 1110 path_params['accountId'] = params['account_id'] 1111 if 'image_type' in params: 1112 path_params['imageType'] = params['image_type'] 1113 if 'signature_id' in params: 1114 path_params['signatureId'] = params['signature_id'] 1115 1116 query_params = {} 1117 1118 header_params = {} 1119 1120 form_params = [] 1121 local_var_files = {} 1122 1123 body_params = None 1124 # HTTP header `Accept` 1125 header_params['Accept'] = self.api_client.\ 1126 select_header_accept(['application/json']) 1127 1128 # Authentication setting 1129 auth_settings = [] 1130 1131 return self.api_client.call_api(resource_path, 'DELETE', 1132 path_params, 1133 query_params, 1134 header_params, 1135 body=body_params, 1136 post_params=form_params, 1137 files=local_var_files, 1138 response_type='AccountSignature', 1139 auth_settings=auth_settings, 1140 callback=params.get('callback'), 1141 _return_http_data_only=params.get('_return_http_data_only'), 1142 _preload_content=params.get('_preload_content', True), 1143 _request_timeout=params.get('_request_timeout'), 1144 collection_formats=collection_formats) 1145 1146 def delete_brand(self, account_id, brand_id, **kwargs): 1147 """ 1148 Removes a brand. 1149 This method deletes a brand from an account. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 1150 This method makes a synchronous HTTP request by default. To make an 1151 asynchronous HTTP request, please define a `callback` function 1152 to be invoked when receiving the response. 1153 >>> def callback_function(response): 1154 >>> pprint(response) 1155 >>> 1156 >>> thread = api.delete_brand(account_id, brand_id, callback=callback_function) 1157 1158 :param callback function: The callback function 1159 for asynchronous request. (optional) 1160 :param str account_id: The external account number (int) or account ID Guid. (required) 1161 :param str brand_id: The unique identifier of a brand. (required) 1162 :return: None 1163 If the method is called asynchronously, 1164 returns the request thread. 1165 """ 1166 kwargs['_return_http_data_only'] = True 1167 if kwargs.get('callback'): 1168 return self.delete_brand_with_http_info(account_id, brand_id, **kwargs) 1169 else: 1170 (data) = self.delete_brand_with_http_info(account_id, brand_id, **kwargs) 1171 return data 1172 1173 def delete_brand_with_http_info(self, account_id, brand_id, **kwargs): 1174 """ 1175 Removes a brand. 1176 This method deletes a brand from an account. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 1177 This method makes a synchronous HTTP request by default. To make an 1178 asynchronous HTTP request, please define a `callback` function 1179 to be invoked when receiving the response. 1180 >>> def callback_function(response): 1181 >>> pprint(response) 1182 >>> 1183 >>> thread = api.delete_brand_with_http_info(account_id, brand_id, callback=callback_function) 1184 1185 :param callback function: The callback function 1186 for asynchronous request. (optional) 1187 :param str account_id: The external account number (int) or account ID Guid. (required) 1188 :param str brand_id: The unique identifier of a brand. (required) 1189 :return: None 1190 If the method is called asynchronously, 1191 returns the request thread. 1192 """ 1193 1194 all_params = ['account_id', 'brand_id'] 1195 all_params.append('callback') 1196 all_params.append('_return_http_data_only') 1197 all_params.append('_preload_content') 1198 all_params.append('_request_timeout') 1199 1200 params = locals() 1201 for key, val in iteritems(params['kwargs']): 1202 if key not in all_params: 1203 raise TypeError( 1204 "Got an unexpected keyword argument '%s'" 1205 " to method delete_brand" % key 1206 ) 1207 params[key] = val 1208 del params['kwargs'] 1209 # verify the required parameter 'account_id' is set 1210 if ('account_id' not in params) or (params['account_id'] is None): 1211 raise ValueError("Missing the required parameter `account_id` when calling `delete_brand`") 1212 # verify the required parameter 'brand_id' is set 1213 if ('brand_id' not in params) or (params['brand_id'] is None): 1214 raise ValueError("Missing the required parameter `brand_id` when calling `delete_brand`") 1215 1216 1217 collection_formats = {} 1218 1219 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 1220 path_params = {} 1221 if 'account_id' in params: 1222 path_params['accountId'] = params['account_id'] 1223 if 'brand_id' in params: 1224 path_params['brandId'] = params['brand_id'] 1225 1226 query_params = {} 1227 1228 header_params = {} 1229 1230 form_params = [] 1231 local_var_files = {} 1232 1233 body_params = None 1234 # HTTP header `Accept` 1235 header_params['Accept'] = self.api_client.\ 1236 select_header_accept(['application/json']) 1237 1238 # Authentication setting 1239 auth_settings = [] 1240 1241 return self.api_client.call_api(resource_path, 'DELETE', 1242 path_params, 1243 query_params, 1244 header_params, 1245 body=body_params, 1246 post_params=form_params, 1247 files=local_var_files, 1248 response_type=None, 1249 auth_settings=auth_settings, 1250 callback=params.get('callback'), 1251 _return_http_data_only=params.get('_return_http_data_only'), 1252 _preload_content=params.get('_preload_content', True), 1253 _request_timeout=params.get('_request_timeout'), 1254 collection_formats=collection_formats) 1255 1256 def delete_brand_logo_by_type(self, account_id, brand_id, logo_type, **kwargs): 1257 """ 1258 Delete one branding logo. 1259 This method deletes a single logo from an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 1260 This method makes a synchronous HTTP request by default. To make an 1261 asynchronous HTTP request, please define a `callback` function 1262 to be invoked when receiving the response. 1263 >>> def callback_function(response): 1264 >>> pprint(response) 1265 >>> 1266 >>> thread = api.delete_brand_logo_by_type(account_id, brand_id, logo_type, callback=callback_function) 1267 1268 :param callback function: The callback function 1269 for asynchronous request. (optional) 1270 :param str account_id: The external account number (int) or account ID Guid. (required) 1271 :param str brand_id: The unique identifier of a brand. (required) 1272 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 1273 :return: None 1274 If the method is called asynchronously, 1275 returns the request thread. 1276 """ 1277 kwargs['_return_http_data_only'] = True 1278 if kwargs.get('callback'): 1279 return self.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 1280 else: 1281 (data) = self.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 1282 return data 1283 1284 def delete_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, **kwargs): 1285 """ 1286 Delete one branding logo. 1287 This method deletes a single logo from an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 1288 This method makes a synchronous HTTP request by default. To make an 1289 asynchronous HTTP request, please define a `callback` function 1290 to be invoked when receiving the response. 1291 >>> def callback_function(response): 1292 >>> pprint(response) 1293 >>> 1294 >>> thread = api.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, callback=callback_function) 1295 1296 :param callback function: The callback function 1297 for asynchronous request. (optional) 1298 :param str account_id: The external account number (int) or account ID Guid. (required) 1299 :param str brand_id: The unique identifier of a brand. (required) 1300 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 1301 :return: None 1302 If the method is called asynchronously, 1303 returns the request thread. 1304 """ 1305 1306 all_params = ['account_id', 'brand_id', 'logo_type'] 1307 all_params.append('callback') 1308 all_params.append('_return_http_data_only') 1309 all_params.append('_preload_content') 1310 all_params.append('_request_timeout') 1311 1312 params = locals() 1313 for key, val in iteritems(params['kwargs']): 1314 if key not in all_params: 1315 raise TypeError( 1316 "Got an unexpected keyword argument '%s'" 1317 " to method delete_brand_logo_by_type" % key 1318 ) 1319 params[key] = val 1320 del params['kwargs'] 1321 # verify the required parameter 'account_id' is set 1322 if ('account_id' not in params) or (params['account_id'] is None): 1323 raise ValueError("Missing the required parameter `account_id` when calling `delete_brand_logo_by_type`") 1324 # verify the required parameter 'brand_id' is set 1325 if ('brand_id' not in params) or (params['brand_id'] is None): 1326 raise ValueError("Missing the required parameter `brand_id` when calling `delete_brand_logo_by_type`") 1327 # verify the required parameter 'logo_type' is set 1328 if ('logo_type' not in params) or (params['logo_type'] is None): 1329 raise ValueError("Missing the required parameter `logo_type` when calling `delete_brand_logo_by_type`") 1330 1331 1332 collection_formats = {} 1333 1334 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 1335 path_params = {} 1336 if 'account_id' in params: 1337 path_params['accountId'] = params['account_id'] 1338 if 'brand_id' in params: 1339 path_params['brandId'] = params['brand_id'] 1340 if 'logo_type' in params: 1341 path_params['logoType'] = params['logo_type'] 1342 1343 query_params = {} 1344 1345 header_params = {} 1346 1347 form_params = [] 1348 local_var_files = {} 1349 1350 body_params = None 1351 # HTTP header `Accept` 1352 header_params['Accept'] = self.api_client.\ 1353 select_header_accept(['application/json']) 1354 1355 # Authentication setting 1356 auth_settings = [] 1357 1358 return self.api_client.call_api(resource_path, 'DELETE', 1359 path_params, 1360 query_params, 1361 header_params, 1362 body=body_params, 1363 post_params=form_params, 1364 files=local_var_files, 1365 response_type=None, 1366 auth_settings=auth_settings, 1367 callback=params.get('callback'), 1368 _return_http_data_only=params.get('_return_http_data_only'), 1369 _preload_content=params.get('_preload_content', True), 1370 _request_timeout=params.get('_request_timeout'), 1371 collection_formats=collection_formats) 1372 1373 def delete_brands(self, account_id, **kwargs): 1374 """ 1375 Deletes one or more brand profiles. 1376 Deletes one or more brand profiles from an account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`) must be set to **true** to use this call. 1377 This method makes a synchronous HTTP request by default. To make an 1378 asynchronous HTTP request, please define a `callback` function 1379 to be invoked when receiving the response. 1380 >>> def callback_function(response): 1381 >>> pprint(response) 1382 >>> 1383 >>> thread = api.delete_brands(account_id, callback=callback_function) 1384 1385 :param callback function: The callback function 1386 for asynchronous request. (optional) 1387 :param str account_id: The external account number (int) or account ID Guid. (required) 1388 :param BrandsRequest brands_request: 1389 :return: BrandsResponse 1390 If the method is called asynchronously, 1391 returns the request thread. 1392 """ 1393 kwargs['_return_http_data_only'] = True 1394 if kwargs.get('callback'): 1395 return self.delete_brands_with_http_info(account_id, **kwargs) 1396 else: 1397 (data) = self.delete_brands_with_http_info(account_id, **kwargs) 1398 return data 1399 1400 def delete_brands_with_http_info(self, account_id, **kwargs): 1401 """ 1402 Deletes one or more brand profiles. 1403 Deletes one or more brand profiles from an account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`) must be set to **true** to use this call. 1404 This method makes a synchronous HTTP request by default. To make an 1405 asynchronous HTTP request, please define a `callback` function 1406 to be invoked when receiving the response. 1407 >>> def callback_function(response): 1408 >>> pprint(response) 1409 >>> 1410 >>> thread = api.delete_brands_with_http_info(account_id, callback=callback_function) 1411 1412 :param callback function: The callback function 1413 for asynchronous request. (optional) 1414 :param str account_id: The external account number (int) or account ID Guid. (required) 1415 :param BrandsRequest brands_request: 1416 :return: BrandsResponse 1417 If the method is called asynchronously, 1418 returns the request thread. 1419 """ 1420 1421 all_params = ['account_id', 'brands_request'] 1422 all_params.append('callback') 1423 all_params.append('_return_http_data_only') 1424 all_params.append('_preload_content') 1425 all_params.append('_request_timeout') 1426 1427 params = locals() 1428 for key, val in iteritems(params['kwargs']): 1429 if key not in all_params: 1430 raise TypeError( 1431 "Got an unexpected keyword argument '%s'" 1432 " to method delete_brands" % key 1433 ) 1434 params[key] = val 1435 del params['kwargs'] 1436 # verify the required parameter 'account_id' is set 1437 if ('account_id' not in params) or (params['account_id'] is None): 1438 raise ValueError("Missing the required parameter `account_id` when calling `delete_brands`") 1439 1440 1441 collection_formats = {} 1442 1443 resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json') 1444 path_params = {} 1445 if 'account_id' in params: 1446 path_params['accountId'] = params['account_id'] 1447 1448 query_params = {} 1449 1450 header_params = {} 1451 1452 form_params = [] 1453 local_var_files = {} 1454 1455 body_params = None 1456 if 'brands_request' in params: 1457 body_params = params['brands_request'] 1458 # HTTP header `Accept` 1459 header_params['Accept'] = self.api_client.\ 1460 select_header_accept(['application/json']) 1461 1462 # Authentication setting 1463 auth_settings = [] 1464 1465 return self.api_client.call_api(resource_path, 'DELETE', 1466 path_params, 1467 query_params, 1468 header_params, 1469 body=body_params, 1470 post_params=form_params, 1471 files=local_var_files, 1472 response_type='BrandsResponse', 1473 auth_settings=auth_settings, 1474 callback=params.get('callback'), 1475 _return_http_data_only=params.get('_return_http_data_only'), 1476 _preload_content=params.get('_preload_content', True), 1477 _request_timeout=params.get('_request_timeout'), 1478 collection_formats=collection_formats) 1479 1480 def delete_captive_recipient(self, account_id, recipient_part, **kwargs): 1481 """ 1482 Deletes the signature for one or more captive recipient records. 1483 Deletes the signature for one or more captive recipient records; it is primarily used for testing. This provides a way to reset the signature associated with a client user ID so that a new signature can be created the next time the client user ID is used. 1484 This method makes a synchronous HTTP request by default. To make an 1485 asynchronous HTTP request, please define a `callback` function 1486 to be invoked when receiving the response. 1487 >>> def callback_function(response): 1488 >>> pprint(response) 1489 >>> 1490 >>> thread = api.delete_captive_recipient(account_id, recipient_part, callback=callback_function) 1491 1492 :param callback function: The callback function 1493 for asynchronous request. (optional) 1494 :param str account_id: The external account number (int) or account ID Guid. (required) 1495 :param str recipient_part: (required) 1496 :param CaptiveRecipientInformation captive_recipient_information: 1497 :return: CaptiveRecipientInformation 1498 If the method is called asynchronously, 1499 returns the request thread. 1500 """ 1501 kwargs['_return_http_data_only'] = True 1502 if kwargs.get('callback'): 1503 return self.delete_captive_recipient_with_http_info(account_id, recipient_part, **kwargs) 1504 else: 1505 (data) = self.delete_captive_recipient_with_http_info(account_id, recipient_part, **kwargs) 1506 return data 1507 1508 def delete_captive_recipient_with_http_info(self, account_id, recipient_part, **kwargs): 1509 """ 1510 Deletes the signature for one or more captive recipient records. 1511 Deletes the signature for one or more captive recipient records; it is primarily used for testing. This provides a way to reset the signature associated with a client user ID so that a new signature can be created the next time the client user ID is used. 1512 This method makes a synchronous HTTP request by default. To make an 1513 asynchronous HTTP request, please define a `callback` function 1514 to be invoked when receiving the response. 1515 >>> def callback_function(response): 1516 >>> pprint(response) 1517 >>> 1518 >>> thread = api.delete_captive_recipient_with_http_info(account_id, recipient_part, callback=callback_function) 1519 1520 :param callback function: The callback function 1521 for asynchronous request. (optional) 1522 :param str account_id: The external account number (int) or account ID Guid. (required) 1523 :param str recipient_part: (required) 1524 :param CaptiveRecipientInformation captive_recipient_information: 1525 :return: CaptiveRecipientInformation 1526 If the method is called asynchronously, 1527 returns the request thread. 1528 """ 1529 1530 all_params = ['account_id', 'recipient_part', 'captive_recipient_information'] 1531 all_params.append('callback') 1532 all_params.append('_return_http_data_only') 1533 all_params.append('_preload_content') 1534 all_params.append('_request_timeout') 1535 1536 params = locals() 1537 for key, val in iteritems(params['kwargs']): 1538 if key not in all_params: 1539 raise TypeError( 1540 "Got an unexpected keyword argument '%s'" 1541 " to method delete_captive_recipient" % key 1542 ) 1543 params[key] = val 1544 del params['kwargs'] 1545 # verify the required parameter 'account_id' is set 1546 if ('account_id' not in params) or (params['account_id'] is None): 1547 raise ValueError("Missing the required parameter `account_id` when calling `delete_captive_recipient`") 1548 # verify the required parameter 'recipient_part' is set 1549 if ('recipient_part' not in params) or (params['recipient_part'] is None): 1550 raise ValueError("Missing the required parameter `recipient_part` when calling `delete_captive_recipient`") 1551 1552 1553 collection_formats = {} 1554 1555 resource_path = '/v2.1/accounts/{accountId}/captive_recipients/{recipientPart}'.replace('{format}', 'json') 1556 path_params = {} 1557 if 'account_id' in params: 1558 path_params['accountId'] = params['account_id'] 1559 if 'recipient_part' in params: 1560 path_params['recipientPart'] = params['recipient_part'] 1561 1562 query_params = {} 1563 1564 header_params = {} 1565 1566 form_params = [] 1567 local_var_files = {} 1568 1569 body_params = None 1570 if 'captive_recipient_information' in params: 1571 body_params = params['captive_recipient_information'] 1572 # HTTP header `Accept` 1573 header_params['Accept'] = self.api_client.\ 1574 select_header_accept(['application/json']) 1575 1576 # Authentication setting 1577 auth_settings = [] 1578 1579 return self.api_client.call_api(resource_path, 'DELETE', 1580 path_params, 1581 query_params, 1582 header_params, 1583 body=body_params, 1584 post_params=form_params, 1585 files=local_var_files, 1586 response_type='CaptiveRecipientInformation', 1587 auth_settings=auth_settings, 1588 callback=params.get('callback'), 1589 _return_http_data_only=params.get('_return_http_data_only'), 1590 _preload_content=params.get('_preload_content', True), 1591 _request_timeout=params.get('_request_timeout'), 1592 collection_formats=collection_formats) 1593 1594 def delete_custom_field(self, account_id, custom_field_id, **kwargs): 1595 """ 1596 Delete an existing account custom field. 1597 This method deletes an existing account custom field. 1598 This method makes a synchronous HTTP request by default. To make an 1599 asynchronous HTTP request, please define a `callback` function 1600 to be invoked when receiving the response. 1601 >>> def callback_function(response): 1602 >>> pprint(response) 1603 >>> 1604 >>> thread = api.delete_custom_field(account_id, custom_field_id, callback=callback_function) 1605 1606 :param callback function: The callback function 1607 for asynchronous request. (optional) 1608 :param str account_id: The external account number (int) or account ID Guid. (required) 1609 :param str custom_field_id: (required) 1610 :param str apply_to_templates: 1611 :return: None 1612 If the method is called asynchronously, 1613 returns the request thread. 1614 """ 1615 kwargs['_return_http_data_only'] = True 1616 if kwargs.get('callback'): 1617 return self.delete_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 1618 else: 1619 (data) = self.delete_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 1620 return data 1621 1622 def delete_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs): 1623 """ 1624 Delete an existing account custom field. 1625 This method deletes an existing account custom field. 1626 This method makes a synchronous HTTP request by default. To make an 1627 asynchronous HTTP request, please define a `callback` function 1628 to be invoked when receiving the response. 1629 >>> def callback_function(response): 1630 >>> pprint(response) 1631 >>> 1632 >>> thread = api.delete_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function) 1633 1634 :param callback function: The callback function 1635 for asynchronous request. (optional) 1636 :param str account_id: The external account number (int) or account ID Guid. (required) 1637 :param str custom_field_id: (required) 1638 :param str apply_to_templates: 1639 :return: None 1640 If the method is called asynchronously, 1641 returns the request thread. 1642 """ 1643 1644 all_params = ['account_id', 'custom_field_id', 'apply_to_templates'] 1645 all_params.append('callback') 1646 all_params.append('_return_http_data_only') 1647 all_params.append('_preload_content') 1648 all_params.append('_request_timeout') 1649 1650 params = locals() 1651 for key, val in iteritems(params['kwargs']): 1652 if key not in all_params: 1653 raise TypeError( 1654 "Got an unexpected keyword argument '%s'" 1655 " to method delete_custom_field" % key 1656 ) 1657 params[key] = val 1658 del params['kwargs'] 1659 # verify the required parameter 'account_id' is set 1660 if ('account_id' not in params) or (params['account_id'] is None): 1661 raise ValueError("Missing the required parameter `account_id` when calling `delete_custom_field`") 1662 # verify the required parameter 'custom_field_id' is set 1663 if ('custom_field_id' not in params) or (params['custom_field_id'] is None): 1664 raise ValueError("Missing the required parameter `custom_field_id` when calling `delete_custom_field`") 1665 1666 1667 collection_formats = {} 1668 1669 resource_path = '/v2.1/accounts/{accountId}/custom_fields/{customFieldId}'.replace('{format}', 'json') 1670 path_params = {} 1671 if 'account_id' in params: 1672 path_params['accountId'] = params['account_id'] 1673 if 'custom_field_id' in params: 1674 path_params['customFieldId'] = params['custom_field_id'] 1675 1676 query_params = {} 1677 if 'apply_to_templates' in params: 1678 query_params['apply_to_templates'] = params['apply_to_templates'] 1679 1680 header_params = {} 1681 1682 form_params = [] 1683 local_var_files = {} 1684 1685 body_params = None 1686 # HTTP header `Accept` 1687 header_params['Accept'] = self.api_client.\ 1688 select_header_accept(['application/json']) 1689 1690 # Authentication setting 1691 auth_settings = [] 1692 1693 return self.api_client.call_api(resource_path, 'DELETE', 1694 path_params, 1695 query_params, 1696 header_params, 1697 body=body_params, 1698 post_params=form_params, 1699 files=local_var_files, 1700 response_type=None, 1701 auth_settings=auth_settings, 1702 callback=params.get('callback'), 1703 _return_http_data_only=params.get('_return_http_data_only'), 1704 _preload_content=params.get('_preload_content', True), 1705 _request_timeout=params.get('_request_timeout'), 1706 collection_formats=collection_formats) 1707 1708 def delete_e_note_configuration(self, account_id, **kwargs): 1709 """ 1710 Deletes configuration information for the eNote eOriginal integration. 1711 1712 This method makes a synchronous HTTP request by default. To make an 1713 asynchronous HTTP request, please define a `callback` function 1714 to be invoked when receiving the response. 1715 >>> def callback_function(response): 1716 >>> pprint(response) 1717 >>> 1718 >>> thread = api.delete_e_note_configuration(account_id, callback=callback_function) 1719 1720 :param callback function: The callback function 1721 for asynchronous request. (optional) 1722 :param str account_id: The external account number (int) or account ID Guid. (required) 1723 :return: None 1724 If the method is called asynchronously, 1725 returns the request thread. 1726 """ 1727 kwargs['_return_http_data_only'] = True 1728 if kwargs.get('callback'): 1729 return self.delete_e_note_configuration_with_http_info(account_id, **kwargs) 1730 else: 1731 (data) = self.delete_e_note_configuration_with_http_info(account_id, **kwargs) 1732 return data 1733 1734 def delete_e_note_configuration_with_http_info(self, account_id, **kwargs): 1735 """ 1736 Deletes configuration information for the eNote eOriginal integration. 1737 1738 This method makes a synchronous HTTP request by default. To make an 1739 asynchronous HTTP request, please define a `callback` function 1740 to be invoked when receiving the response. 1741 >>> def callback_function(response): 1742 >>> pprint(response) 1743 >>> 1744 >>> thread = api.delete_e_note_configuration_with_http_info(account_id, callback=callback_function) 1745 1746 :param callback function: The callback function 1747 for asynchronous request. (optional) 1748 :param str account_id: The external account number (int) or account ID Guid. (required) 1749 :return: None 1750 If the method is called asynchronously, 1751 returns the request thread. 1752 """ 1753 1754 all_params = ['account_id'] 1755 all_params.append('callback') 1756 all_params.append('_return_http_data_only') 1757 all_params.append('_preload_content') 1758 all_params.append('_request_timeout') 1759 1760 params = locals() 1761 for key, val in iteritems(params['kwargs']): 1762 if key not in all_params: 1763 raise TypeError( 1764 "Got an unexpected keyword argument '%s'" 1765 " to method delete_e_note_configuration" % key 1766 ) 1767 params[key] = val 1768 del params['kwargs'] 1769 # verify the required parameter 'account_id' is set 1770 if ('account_id' not in params) or (params['account_id'] is None): 1771 raise ValueError("Missing the required parameter `account_id` when calling `delete_e_note_configuration`") 1772 1773 1774 collection_formats = {} 1775 1776 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 1777 path_params = {} 1778 if 'account_id' in params: 1779 path_params['accountId'] = params['account_id'] 1780 1781 query_params = {} 1782 1783 header_params = {} 1784 1785 form_params = [] 1786 local_var_files = {} 1787 1788 body_params = None 1789 # HTTP header `Accept` 1790 header_params['Accept'] = self.api_client.\ 1791 select_header_accept(['application/json']) 1792 1793 # Authentication setting 1794 auth_settings = [] 1795 1796 return self.api_client.call_api(resource_path, 'DELETE', 1797 path_params, 1798 query_params, 1799 header_params, 1800 body=body_params, 1801 post_params=form_params, 1802 files=local_var_files, 1803 response_type=None, 1804 auth_settings=auth_settings, 1805 callback=params.get('callback'), 1806 _return_http_data_only=params.get('_return_http_data_only'), 1807 _preload_content=params.get('_preload_content', True), 1808 _request_timeout=params.get('_request_timeout'), 1809 collection_formats=collection_formats) 1810 1811 def delete_permission_profile(self, account_id, permission_profile_id, **kwargs): 1812 """ 1813 Deletes a permissions profile within the specified account. 1814 This method deletes a permission profile from an account. To delete a permission profile, it must not have any users associated with it. When you use this method to delete a permission profile, you can reassign the users associated with it to a new permission profile at the same time by using the `move_users_to` query parameter. ### Related topics - [How to delete a permission profile](/docs/esign-rest-api/how-to/permission-profile-deleting/) 1815 This method makes a synchronous HTTP request by default. To make an 1816 asynchronous HTTP request, please define a `callback` function 1817 to be invoked when receiving the response. 1818 >>> def callback_function(response): 1819 >>> pprint(response) 1820 >>> 1821 >>> thread = api.delete_permission_profile(account_id, permission_profile_id, callback=callback_function) 1822 1823 :param callback function: The callback function 1824 for asynchronous request. (optional) 1825 :param str account_id: The external account number (int) or account ID Guid. (required) 1826 :param str permission_profile_id: (required) 1827 :param str move_users_to: 1828 :return: None 1829 If the method is called asynchronously, 1830 returns the request thread. 1831 """ 1832 kwargs['_return_http_data_only'] = True 1833 if kwargs.get('callback'): 1834 return self.delete_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 1835 else: 1836 (data) = self.delete_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 1837 return data 1838 1839 def delete_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 1840 """ 1841 Deletes a permissions profile within the specified account. 1842 This method deletes a permission profile from an account. To delete a permission profile, it must not have any users associated with it. When you use this method to delete a permission profile, you can reassign the users associated with it to a new permission profile at the same time by using the `move_users_to` query parameter. ### Related topics - [How to delete a permission profile](/docs/esign-rest-api/how-to/permission-profile-deleting/) 1843 This method makes a synchronous HTTP request by default. To make an 1844 asynchronous HTTP request, please define a `callback` function 1845 to be invoked when receiving the response. 1846 >>> def callback_function(response): 1847 >>> pprint(response) 1848 >>> 1849 >>> thread = api.delete_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 1850 1851 :param callback function: The callback function 1852 for asynchronous request. (optional) 1853 :param str account_id: The external account number (int) or account ID Guid. (required) 1854 :param str permission_profile_id: (required) 1855 :param str move_users_to: 1856 :return: None 1857 If the method is called asynchronously, 1858 returns the request thread. 1859 """ 1860 1861 all_params = ['account_id', 'permission_profile_id', 'move_users_to'] 1862 all_params.append('callback') 1863 all_params.append('_return_http_data_only') 1864 all_params.append('_preload_content') 1865 all_params.append('_request_timeout') 1866 1867 params = locals() 1868 for key, val in iteritems(params['kwargs']): 1869 if key not in all_params: 1870 raise TypeError( 1871 "Got an unexpected keyword argument '%s'" 1872 " to method delete_permission_profile" % key 1873 ) 1874 params[key] = val 1875 del params['kwargs'] 1876 # verify the required parameter 'account_id' is set 1877 if ('account_id' not in params) or (params['account_id'] is None): 1878 raise ValueError("Missing the required parameter `account_id` when calling `delete_permission_profile`") 1879 # verify the required parameter 'permission_profile_id' is set 1880 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 1881 raise ValueError("Missing the required parameter `permission_profile_id` when calling `delete_permission_profile`") 1882 1883 1884 collection_formats = {} 1885 1886 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 1887 path_params = {} 1888 if 'account_id' in params: 1889 path_params['accountId'] = params['account_id'] 1890 if 'permission_profile_id' in params: 1891 path_params['permissionProfileId'] = params['permission_profile_id'] 1892 1893 query_params = {} 1894 if 'move_users_to' in params: 1895 query_params['move_users_to'] = params['move_users_to'] 1896 1897 header_params = {} 1898 1899 form_params = [] 1900 local_var_files = {} 1901 1902 body_params = None 1903 # HTTP header `Accept` 1904 header_params['Accept'] = self.api_client.\ 1905 select_header_accept(['application/json']) 1906 1907 # Authentication setting 1908 auth_settings = [] 1909 1910 return self.api_client.call_api(resource_path, 'DELETE', 1911 path_params, 1912 query_params, 1913 header_params, 1914 body=body_params, 1915 post_params=form_params, 1916 files=local_var_files, 1917 response_type=None, 1918 auth_settings=auth_settings, 1919 callback=params.get('callback'), 1920 _return_http_data_only=params.get('_return_http_data_only'), 1921 _preload_content=params.get('_preload_content', True), 1922 _request_timeout=params.get('_request_timeout'), 1923 collection_formats=collection_formats) 1924 1925 def delete_user_authorization(self, account_id, authorization_id, user_id, **kwargs): 1926 """ 1927 Deletes the user authorization 1928 This method makes a synchronous HTTP request by default. To make an 1929 asynchronous HTTP request, please define a `callback` function 1930 to be invoked when receiving the response. 1931 >>> def callback_function(response): 1932 >>> pprint(response) 1933 >>> 1934 >>> thread = api.delete_user_authorization(account_id, authorization_id, user_id, callback=callback_function) 1935 1936 :param callback function: The callback function 1937 for asynchronous request. (optional) 1938 :param str account_id: The external account number (int) or account ID Guid. (required) 1939 :param str authorization_id: (required) 1940 :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required) 1941 :return: None 1942 If the method is called asynchronously, 1943 returns the request thread. 1944 """ 1945 kwargs['_return_http_data_only'] = True 1946 if kwargs.get('callback'): 1947 return self.delete_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 1948 else: 1949 (data) = self.delete_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 1950 return data 1951 1952 def delete_user_authorization_with_http_info(self, account_id, authorization_id, user_id, **kwargs): 1953 """ 1954 Deletes the user authorization 1955 This method makes a synchronous HTTP request by default. To make an 1956 asynchronous HTTP request, please define a `callback` function 1957 to be invoked when receiving the response. 1958 >>> def callback_function(response): 1959 >>> pprint(response) 1960 >>> 1961 >>> thread = api.delete_user_authorization_with_http_info(account_id, authorization_id, user_id, callback=callback_function) 1962 1963 :param callback function: The callback function 1964 for asynchronous request. (optional) 1965 :param str account_id: The external account number (int) or account ID Guid. (required) 1966 :param str authorization_id: (required) 1967 :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required) 1968 :return: None 1969 If the method is called asynchronously, 1970 returns the request thread. 1971 """ 1972 1973 all_params = ['account_id', 'authorization_id', 'user_id'] 1974 all_params.append('callback') 1975 all_params.append('_return_http_data_only') 1976 all_params.append('_preload_content') 1977 all_params.append('_request_timeout') 1978 1979 params = locals() 1980 for key, val in iteritems(params['kwargs']): 1981 if key not in all_params: 1982 raise TypeError( 1983 "Got an unexpected keyword argument '%s'" 1984 " to method delete_user_authorization" % key 1985 ) 1986 params[key] = val 1987 del params['kwargs'] 1988 # verify the required parameter 'account_id' is set 1989 if ('account_id' not in params) or (params['account_id'] is None): 1990 raise ValueError("Missing the required parameter `account_id` when calling `delete_user_authorization`") 1991 # verify the required parameter 'authorization_id' is set 1992 if ('authorization_id' not in params) or (params['authorization_id'] is None): 1993 raise ValueError("Missing the required parameter `authorization_id` when calling `delete_user_authorization`") 1994 # verify the required parameter 'user_id' is set 1995 if ('user_id' not in params) or (params['user_id'] is None): 1996 raise ValueError("Missing the required parameter `user_id` when calling `delete_user_authorization`") 1997 1998 1999 collection_formats = {} 2000 2001 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorization/{authorizationId}'.replace('{format}', 'json') 2002 path_params = {} 2003 if 'account_id' in params: 2004 path_params['accountId'] = params['account_id'] 2005 if 'authorization_id' in params: 2006 path_params['authorizationId'] = params['authorization_id'] 2007 if 'user_id' in params: 2008 path_params['userId'] = params['user_id'] 2009 2010 query_params = {} 2011 2012 header_params = {} 2013 2014 form_params = [] 2015 local_var_files = {} 2016 2017 body_params = None 2018 # HTTP header `Accept` 2019 header_params['Accept'] = self.api_client.\ 2020 select_header_accept(['application/json']) 2021 2022 # Authentication setting 2023 auth_settings = [] 2024 2025 return self.api_client.call_api(resource_path, 'DELETE', 2026 path_params, 2027 query_params, 2028 header_params, 2029 body=body_params, 2030 post_params=form_params, 2031 files=local_var_files, 2032 response_type=None, 2033 auth_settings=auth_settings, 2034 callback=params.get('callback'), 2035 _return_http_data_only=params.get('_return_http_data_only'), 2036 _preload_content=params.get('_preload_content', True), 2037 _request_timeout=params.get('_request_timeout'), 2038 collection_formats=collection_formats) 2039 2040 def delete_user_authorizations(self, account_id, user_id, **kwargs): 2041 """ 2042 Creates ot updates user authorizations 2043 This method makes a synchronous HTTP request by default. To make an 2044 asynchronous HTTP request, please define a `callback` function 2045 to be invoked when receiving the response. 2046 >>> def callback_function(response): 2047 >>> pprint(response) 2048 >>> 2049 >>> thread = api.delete_user_authorizations(account_id, user_id, callback=callback_function) 2050 2051 :param callback function: The callback function 2052 for asynchronous request. (optional) 2053 :param str account_id: The external account number (int) or account ID Guid. (required) 2054 :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required) 2055 :param UserAuthorizationsDeleteRequest user_authorizations_delete_request: 2056 :return: UserAuthorizationsDeleteResponse 2057 If the method is called asynchronously, 2058 returns the request thread. 2059 """ 2060 kwargs['_return_http_data_only'] = True 2061 if kwargs.get('callback'): 2062 return self.delete_user_authorizations_with_http_info(account_id, user_id, **kwargs) 2063 else: 2064 (data) = self.delete_user_authorizations_with_http_info(account_id, user_id, **kwargs) 2065 return data 2066 2067 def delete_user_authorizations_with_http_info(self, account_id, user_id, **kwargs): 2068 """ 2069 Creates ot updates user authorizations 2070 This method makes a synchronous HTTP request by default. To make an 2071 asynchronous HTTP request, please define a `callback` function 2072 to be invoked when receiving the response. 2073 >>> def callback_function(response): 2074 >>> pprint(response) 2075 >>> 2076 >>> thread = api.delete_user_authorizations_with_http_info(account_id, user_id, callback=callback_function) 2077 2078 :param callback function: The callback function 2079 for asynchronous request. (optional) 2080 :param str account_id: The external account number (int) or account ID Guid. (required) 2081 :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required) 2082 :param UserAuthorizationsDeleteRequest user_authorizations_delete_request: 2083 :return: UserAuthorizationsDeleteResponse 2084 If the method is called asynchronously, 2085 returns the request thread. 2086 """ 2087 2088 all_params = ['account_id', 'user_id', 'user_authorizations_delete_request'] 2089 all_params.append('callback') 2090 all_params.append('_return_http_data_only') 2091 all_params.append('_preload_content') 2092 all_params.append('_request_timeout') 2093 2094 params = locals() 2095 for key, val in iteritems(params['kwargs']): 2096 if key not in all_params: 2097 raise TypeError( 2098 "Got an unexpected keyword argument '%s'" 2099 " to method delete_user_authorizations" % key 2100 ) 2101 params[key] = val 2102 del params['kwargs'] 2103 # verify the required parameter 'account_id' is set 2104 if ('account_id' not in params) or (params['account_id'] is None): 2105 raise ValueError("Missing the required parameter `account_id` when calling `delete_user_authorizations`") 2106 # verify the required parameter 'user_id' is set 2107 if ('user_id' not in params) or (params['user_id'] is None): 2108 raise ValueError("Missing the required parameter `user_id` when calling `delete_user_authorizations`") 2109 2110 2111 collection_formats = {} 2112 2113 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorizations'.replace('{format}', 'json') 2114 path_params = {} 2115 if 'account_id' in params: 2116 path_params['accountId'] = params['account_id'] 2117 if 'user_id' in params: 2118 path_params['userId'] = params['user_id'] 2119 2120 query_params = {} 2121 2122 header_params = {} 2123 2124 form_params = [] 2125 local_var_files = {} 2126 2127 body_params = None 2128 if 'user_authorizations_delete_request' in params: 2129 body_params = params['user_authorizations_delete_request'] 2130 # HTTP header `Accept` 2131 header_params['Accept'] = self.api_client.\ 2132 select_header_accept(['application/json']) 2133 2134 # Authentication setting 2135 auth_settings = [] 2136 2137 return self.api_client.call_api(resource_path, 'DELETE', 2138 path_params, 2139 query_params, 2140 header_params, 2141 body=body_params, 2142 post_params=form_params, 2143 files=local_var_files, 2144 response_type='UserAuthorizationsDeleteResponse', 2145 auth_settings=auth_settings, 2146 callback=params.get('callback'), 2147 _return_http_data_only=params.get('_return_http_data_only'), 2148 _preload_content=params.get('_preload_content', True), 2149 _request_timeout=params.get('_request_timeout'), 2150 collection_formats=collection_formats) 2151 2152 def get_account_identity_verification(self, account_id, **kwargs): 2153 """ 2154 Get the list of identity verification options for an account 2155 This method returns a list of Identity Verification workflows that are available to an account. **Note:** To use this method, you must either be an account administrator or a sender. ### Related topics - [How to require ID Verification (IDV) for a recipient](/docs/esign-rest-api/how-to/id-verification/) 2156 This method makes a synchronous HTTP request by default. To make an 2157 asynchronous HTTP request, please define a `callback` function 2158 to be invoked when receiving the response. 2159 >>> def callback_function(response): 2160 >>> pprint(response) 2161 >>> 2162 >>> thread = api.get_account_identity_verification(account_id, callback=callback_function) 2163 2164 :param callback function: The callback function 2165 for asynchronous request. (optional) 2166 :param str account_id: The external account number (int) or account ID Guid. (required) 2167 :param str identity_verification_workflow_status: 2168 :return: AccountIdentityVerificationResponse 2169 If the method is called asynchronously, 2170 returns the request thread. 2171 """ 2172 kwargs['_return_http_data_only'] = True 2173 if kwargs.get('callback'): 2174 return self.get_account_identity_verification_with_http_info(account_id, **kwargs) 2175 else: 2176 (data) = self.get_account_identity_verification_with_http_info(account_id, **kwargs) 2177 return data 2178 2179 def get_account_identity_verification_with_http_info(self, account_id, **kwargs): 2180 """ 2181 Get the list of identity verification options for an account 2182 This method returns a list of Identity Verification workflows that are available to an account. **Note:** To use this method, you must either be an account administrator or a sender. ### Related topics - [How to require ID Verification (IDV) for a recipient](/docs/esign-rest-api/how-to/id-verification/) 2183 This method makes a synchronous HTTP request by default. To make an 2184 asynchronous HTTP request, please define a `callback` function 2185 to be invoked when receiving the response. 2186 >>> def callback_function(response): 2187 >>> pprint(response) 2188 >>> 2189 >>> thread = api.get_account_identity_verification_with_http_info(account_id, callback=callback_function) 2190 2191 :param callback function: The callback function 2192 for asynchronous request. (optional) 2193 :param str account_id: The external account number (int) or account ID Guid. (required) 2194 :param str identity_verification_workflow_status: 2195 :return: AccountIdentityVerificationResponse 2196 If the method is called asynchronously, 2197 returns the request thread. 2198 """ 2199 2200 all_params = ['account_id', 'identity_verification_workflow_status'] 2201 all_params.append('callback') 2202 all_params.append('_return_http_data_only') 2203 all_params.append('_preload_content') 2204 all_params.append('_request_timeout') 2205 2206 params = locals() 2207 for key, val in iteritems(params['kwargs']): 2208 if key not in all_params: 2209 raise TypeError( 2210 "Got an unexpected keyword argument '%s'" 2211 " to method get_account_identity_verification" % key 2212 ) 2213 params[key] = val 2214 del params['kwargs'] 2215 # verify the required parameter 'account_id' is set 2216 if ('account_id' not in params) or (params['account_id'] is None): 2217 raise ValueError("Missing the required parameter `account_id` when calling `get_account_identity_verification`") 2218 2219 2220 collection_formats = {} 2221 2222 resource_path = '/v2.1/accounts/{accountId}/identity_verification'.replace('{format}', 'json') 2223 path_params = {} 2224 if 'account_id' in params: 2225 path_params['accountId'] = params['account_id'] 2226 2227 query_params = {} 2228 if 'identity_verification_workflow_status' in params: 2229 query_params['identity_verification_workflow_status'] = params['identity_verification_workflow_status'] 2230 2231 header_params = {} 2232 2233 form_params = [] 2234 local_var_files = {} 2235 2236 body_params = None 2237 # HTTP header `Accept` 2238 header_params['Accept'] = self.api_client.\ 2239 select_header_accept(['application/json']) 2240 2241 # Authentication setting 2242 auth_settings = [] 2243 2244 return self.api_client.call_api(resource_path, 'GET', 2245 path_params, 2246 query_params, 2247 header_params, 2248 body=body_params, 2249 post_params=form_params, 2250 files=local_var_files, 2251 response_type='AccountIdentityVerificationResponse', 2252 auth_settings=auth_settings, 2253 callback=params.get('callback'), 2254 _return_http_data_only=params.get('_return_http_data_only'), 2255 _preload_content=params.get('_preload_content', True), 2256 _request_timeout=params.get('_request_timeout'), 2257 collection_formats=collection_formats) 2258 2259 def get_account_information(self, account_id, **kwargs): 2260 """ 2261 Retrieves the account information for the specified account. 2262 Retrieves the account information for the specified account. **Response** The `canUpgrade` property contains is a Boolean that indicates whether the account can be upgraded through the API. 2263 This method makes a synchronous HTTP request by default. To make an 2264 asynchronous HTTP request, please define a `callback` function 2265 to be invoked when receiving the response. 2266 >>> def callback_function(response): 2267 >>> pprint(response) 2268 >>> 2269 >>> thread = api.get_account_information(account_id, callback=callback_function) 2270 2271 :param callback function: The callback function 2272 for asynchronous request. (optional) 2273 :param str account_id: The external account number (int) or account ID Guid. (required) 2274 :param str include_account_settings: When set to **true**, includes the account settings for the account in the response. 2275 :return: AccountInformation 2276 If the method is called asynchronously, 2277 returns the request thread. 2278 """ 2279 kwargs['_return_http_data_only'] = True 2280 if kwargs.get('callback'): 2281 return self.get_account_information_with_http_info(account_id, **kwargs) 2282 else: 2283 (data) = self.get_account_information_with_http_info(account_id, **kwargs) 2284 return data 2285 2286 def get_account_information_with_http_info(self, account_id, **kwargs): 2287 """ 2288 Retrieves the account information for the specified account. 2289 Retrieves the account information for the specified account. **Response** The `canUpgrade` property contains is a Boolean that indicates whether the account can be upgraded through the API. 2290 This method makes a synchronous HTTP request by default. To make an 2291 asynchronous HTTP request, please define a `callback` function 2292 to be invoked when receiving the response. 2293 >>> def callback_function(response): 2294 >>> pprint(response) 2295 >>> 2296 >>> thread = api.get_account_information_with_http_info(account_id, callback=callback_function) 2297 2298 :param callback function: The callback function 2299 for asynchronous request. (optional) 2300 :param str account_id: The external account number (int) or account ID Guid. (required) 2301 :param str include_account_settings: When set to **true**, includes the account settings for the account in the response. 2302 :return: AccountInformation 2303 If the method is called asynchronously, 2304 returns the request thread. 2305 """ 2306 2307 all_params = ['account_id', 'include_account_settings'] 2308 all_params.append('callback') 2309 all_params.append('_return_http_data_only') 2310 all_params.append('_preload_content') 2311 all_params.append('_request_timeout') 2312 2313 params = locals() 2314 for key, val in iteritems(params['kwargs']): 2315 if key not in all_params: 2316 raise TypeError( 2317 "Got an unexpected keyword argument '%s'" 2318 " to method get_account_information" % key 2319 ) 2320 params[key] = val 2321 del params['kwargs'] 2322 # verify the required parameter 'account_id' is set 2323 if ('account_id' not in params) or (params['account_id'] is None): 2324 raise ValueError("Missing the required parameter `account_id` when calling `get_account_information`") 2325 2326 2327 collection_formats = {} 2328 2329 resource_path = '/v2.1/accounts/{accountId}'.replace('{format}', 'json') 2330 path_params = {} 2331 if 'account_id' in params: 2332 path_params['accountId'] = params['account_id'] 2333 2334 query_params = {} 2335 if 'include_account_settings' in params: 2336 query_params['include_account_settings'] = params['include_account_settings'] 2337 2338 header_params = {} 2339 2340 form_params = [] 2341 local_var_files = {} 2342 2343 body_params = None 2344 # HTTP header `Accept` 2345 header_params['Accept'] = self.api_client.\ 2346 select_header_accept(['application/json']) 2347 2348 # Authentication setting 2349 auth_settings = [] 2350 2351 return self.api_client.call_api(resource_path, 'GET', 2352 path_params, 2353 query_params, 2354 header_params, 2355 body=body_params, 2356 post_params=form_params, 2357 files=local_var_files, 2358 response_type='AccountInformation', 2359 auth_settings=auth_settings, 2360 callback=params.get('callback'), 2361 _return_http_data_only=params.get('_return_http_data_only'), 2362 _preload_content=params.get('_preload_content', True), 2363 _request_timeout=params.get('_request_timeout'), 2364 collection_formats=collection_formats) 2365 2366 def get_account_signature(self, account_id, signature_id, **kwargs): 2367 """ 2368 Returns information about a single signature by specifed signatureId. 2369 2370 This method makes a synchronous HTTP request by default. To make an 2371 asynchronous HTTP request, please define a `callback` function 2372 to be invoked when receiving the response. 2373 >>> def callback_function(response): 2374 >>> pprint(response) 2375 >>> 2376 >>> thread = api.get_account_signature(account_id, signature_id, callback=callback_function) 2377 2378 :param callback function: The callback function 2379 for asynchronous request. (optional) 2380 :param str account_id: The external account number (int) or account ID Guid. (required) 2381 :param str signature_id: The ID of the signature being accessed. (required) 2382 :return: AccountSignature 2383 If the method is called asynchronously, 2384 returns the request thread. 2385 """ 2386 kwargs['_return_http_data_only'] = True 2387 if kwargs.get('callback'): 2388 return self.get_account_signature_with_http_info(account_id, signature_id, **kwargs) 2389 else: 2390 (data) = self.get_account_signature_with_http_info(account_id, signature_id, **kwargs) 2391 return data 2392 2393 def get_account_signature_with_http_info(self, account_id, signature_id, **kwargs): 2394 """ 2395 Returns information about a single signature by specifed signatureId. 2396 2397 This method makes a synchronous HTTP request by default. To make an 2398 asynchronous HTTP request, please define a `callback` function 2399 to be invoked when receiving the response. 2400 >>> def callback_function(response): 2401 >>> pprint(response) 2402 >>> 2403 >>> thread = api.get_account_signature_with_http_info(account_id, signature_id, callback=callback_function) 2404 2405 :param callback function: The callback function 2406 for asynchronous request. (optional) 2407 :param str account_id: The external account number (int) or account ID Guid. (required) 2408 :param str signature_id: The ID of the signature being accessed. (required) 2409 :return: AccountSignature 2410 If the method is called asynchronously, 2411 returns the request thread. 2412 """ 2413 2414 all_params = ['account_id', 'signature_id'] 2415 all_params.append('callback') 2416 all_params.append('_return_http_data_only') 2417 all_params.append('_preload_content') 2418 all_params.append('_request_timeout') 2419 2420 params = locals() 2421 for key, val in iteritems(params['kwargs']): 2422 if key not in all_params: 2423 raise TypeError( 2424 "Got an unexpected keyword argument '%s'" 2425 " to method get_account_signature" % key 2426 ) 2427 params[key] = val 2428 del params['kwargs'] 2429 # verify the required parameter 'account_id' is set 2430 if ('account_id' not in params) or (params['account_id'] is None): 2431 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signature`") 2432 # verify the required parameter 'signature_id' is set 2433 if ('signature_id' not in params) or (params['signature_id'] is None): 2434 raise ValueError("Missing the required parameter `signature_id` when calling `get_account_signature`") 2435 2436 2437 collection_formats = {} 2438 2439 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 2440 path_params = {} 2441 if 'account_id' in params: 2442 path_params['accountId'] = params['account_id'] 2443 if 'signature_id' in params: 2444 path_params['signatureId'] = params['signature_id'] 2445 2446 query_params = {} 2447 2448 header_params = {} 2449 2450 form_params = [] 2451 local_var_files = {} 2452 2453 body_params = None 2454 # HTTP header `Accept` 2455 header_params['Accept'] = self.api_client.\ 2456 select_header_accept(['application/json']) 2457 2458 # Authentication setting 2459 auth_settings = [] 2460 2461 return self.api_client.call_api(resource_path, 'GET', 2462 path_params, 2463 query_params, 2464 header_params, 2465 body=body_params, 2466 post_params=form_params, 2467 files=local_var_files, 2468 response_type='AccountSignature', 2469 auth_settings=auth_settings, 2470 callback=params.get('callback'), 2471 _return_http_data_only=params.get('_return_http_data_only'), 2472 _preload_content=params.get('_preload_content', True), 2473 _request_timeout=params.get('_request_timeout'), 2474 collection_formats=collection_formats) 2475 2476 def get_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 2477 """ 2478 Returns a signature, initials, or stamps image. 2479 2480 This method makes a synchronous HTTP request by default. To make an 2481 asynchronous HTTP request, please define a `callback` function 2482 to be invoked when receiving the response. 2483 >>> def callback_function(response): 2484 >>> pprint(response) 2485 >>> 2486 >>> thread = api.get_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 2487 2488 :param callback function: The callback function 2489 for asynchronous request. (optional) 2490 :param str account_id: The external account number (int) or account ID Guid. (required) 2491 :param str image_type: One of **signature_image** or **initials_image**. (required) 2492 :param str signature_id: The ID of the signature being accessed. (required) 2493 :param str include_chrome: 2494 :return: file 2495 If the method is called asynchronously, 2496 returns the request thread. 2497 """ 2498 kwargs['_return_http_data_only'] = True 2499 if kwargs.get('callback'): 2500 return self.get_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 2501 else: 2502 (data) = self.get_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 2503 return data 2504 2505 def get_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 2506 """ 2507 Returns a signature, initials, or stamps image. 2508 2509 This method makes a synchronous HTTP request by default. To make an 2510 asynchronous HTTP request, please define a `callback` function 2511 to be invoked when receiving the response. 2512 >>> def callback_function(response): 2513 >>> pprint(response) 2514 >>> 2515 >>> thread = api.get_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 2516 2517 :param callback function: The callback function 2518 for asynchronous request. (optional) 2519 :param str account_id: The external account number (int) or account ID Guid. (required) 2520 :param str image_type: One of **signature_image** or **initials_image**. (required) 2521 :param str signature_id: The ID of the signature being accessed. (required) 2522 :param str include_chrome: 2523 :return: file 2524 If the method is called asynchronously, 2525 returns the request thread. 2526 """ 2527 2528 all_params = ['account_id', 'image_type', 'signature_id', 'include_chrome'] 2529 all_params.append('callback') 2530 all_params.append('_return_http_data_only') 2531 all_params.append('_preload_content') 2532 all_params.append('_request_timeout') 2533 2534 params = locals() 2535 for key, val in iteritems(params['kwargs']): 2536 if key not in all_params: 2537 raise TypeError( 2538 "Got an unexpected keyword argument '%s'" 2539 " to method get_account_signature_image" % key 2540 ) 2541 params[key] = val 2542 del params['kwargs'] 2543 # verify the required parameter 'account_id' is set 2544 if ('account_id' not in params) or (params['account_id'] is None): 2545 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signature_image`") 2546 # verify the required parameter 'image_type' is set 2547 if ('image_type' not in params) or (params['image_type'] is None): 2548 raise ValueError("Missing the required parameter `image_type` when calling `get_account_signature_image`") 2549 # verify the required parameter 'signature_id' is set 2550 if ('signature_id' not in params) or (params['signature_id'] is None): 2551 raise ValueError("Missing the required parameter `signature_id` when calling `get_account_signature_image`") 2552 2553 2554 collection_formats = {} 2555 2556 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 2557 path_params = {} 2558 if 'account_id' in params: 2559 path_params['accountId'] = params['account_id'] 2560 if 'image_type' in params: 2561 path_params['imageType'] = params['image_type'] 2562 if 'signature_id' in params: 2563 path_params['signatureId'] = params['signature_id'] 2564 2565 query_params = {} 2566 if 'include_chrome' in params: 2567 query_params['include_chrome'] = params['include_chrome'] 2568 2569 header_params = {} 2570 2571 form_params = [] 2572 local_var_files = {} 2573 2574 body_params = None 2575 # HTTP header `Accept` 2576 header_params['Accept'] = self.api_client.\ 2577 select_header_accept(['image/gif']) 2578 2579 # Authentication setting 2580 auth_settings = [] 2581 2582 return self.api_client.call_api(resource_path, 'GET', 2583 path_params, 2584 query_params, 2585 header_params, 2586 body=body_params, 2587 post_params=form_params, 2588 files=local_var_files, 2589 response_type='file', 2590 auth_settings=auth_settings, 2591 callback=params.get('callback'), 2592 _return_http_data_only=params.get('_return_http_data_only'), 2593 _preload_content=params.get('_preload_content', True), 2594 _request_timeout=params.get('_request_timeout'), 2595 collection_formats=collection_formats) 2596 2597 def get_account_signatures(self, account_id, **kwargs): 2598 """ 2599 Returns the managed signature definitions for the account 2600 2601 This method makes a synchronous HTTP request by default. To make an 2602 asynchronous HTTP request, please define a `callback` function 2603 to be invoked when receiving the response. 2604 >>> def callback_function(response): 2605 >>> pprint(response) 2606 >>> 2607 >>> thread = api.get_account_signatures(account_id, callback=callback_function) 2608 2609 :param callback function: The callback function 2610 for asynchronous request. (optional) 2611 :param str account_id: The external account number (int) or account ID Guid. (required) 2612 :param str stamp_format: 2613 :param str stamp_name: 2614 :param str stamp_type: 2615 :return: AccountSignaturesInformation 2616 If the method is called asynchronously, 2617 returns the request thread. 2618 """ 2619 kwargs['_return_http_data_only'] = True 2620 if kwargs.get('callback'): 2621 return self.get_account_signatures_with_http_info(account_id, **kwargs) 2622 else: 2623 (data) = self.get_account_signatures_with_http_info(account_id, **kwargs) 2624 return data 2625 2626 def get_account_signatures_with_http_info(self, account_id, **kwargs): 2627 """ 2628 Returns the managed signature definitions for the account 2629 2630 This method makes a synchronous HTTP request by default. To make an 2631 asynchronous HTTP request, please define a `callback` function 2632 to be invoked when receiving the response. 2633 >>> def callback_function(response): 2634 >>> pprint(response) 2635 >>> 2636 >>> thread = api.get_account_signatures_with_http_info(account_id, callback=callback_function) 2637 2638 :param callback function: The callback function 2639 for asynchronous request. (optional) 2640 :param str account_id: The external account number (int) or account ID Guid. (required) 2641 :param str stamp_format: 2642 :param str stamp_name: 2643 :param str stamp_type: 2644 :return: AccountSignaturesInformation 2645 If the method is called asynchronously, 2646 returns the request thread. 2647 """ 2648 2649 all_params = ['account_id', 'stamp_format', 'stamp_name', 'stamp_type'] 2650 all_params.append('callback') 2651 all_params.append('_return_http_data_only') 2652 all_params.append('_preload_content') 2653 all_params.append('_request_timeout') 2654 2655 params = locals() 2656 for key, val in iteritems(params['kwargs']): 2657 if key not in all_params: 2658 raise TypeError( 2659 "Got an unexpected keyword argument '%s'" 2660 " to method get_account_signatures" % key 2661 ) 2662 params[key] = val 2663 del params['kwargs'] 2664 # verify the required parameter 'account_id' is set 2665 if ('account_id' not in params) or (params['account_id'] is None): 2666 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signatures`") 2667 2668 2669 collection_formats = {} 2670 2671 resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json') 2672 path_params = {} 2673 if 'account_id' in params: 2674 path_params['accountId'] = params['account_id'] 2675 2676 query_params = {} 2677 if 'stamp_format' in params: 2678 query_params['stamp_format'] = params['stamp_format'] 2679 if 'stamp_name' in params: 2680 query_params['stamp_name'] = params['stamp_name'] 2681 if 'stamp_type' in params: 2682 query_params['stamp_type'] = params['stamp_type'] 2683 2684 header_params = {} 2685 2686 form_params = [] 2687 local_var_files = {} 2688 2689 body_params = None 2690 # HTTP header `Accept` 2691 header_params['Accept'] = self.api_client.\ 2692 select_header_accept(['application/json']) 2693 2694 # Authentication setting 2695 auth_settings = [] 2696 2697 return self.api_client.call_api(resource_path, 'GET', 2698 path_params, 2699 query_params, 2700 header_params, 2701 body=body_params, 2702 post_params=form_params, 2703 files=local_var_files, 2704 response_type='AccountSignaturesInformation', 2705 auth_settings=auth_settings, 2706 callback=params.get('callback'), 2707 _return_http_data_only=params.get('_return_http_data_only'), 2708 _preload_content=params.get('_preload_content', True), 2709 _request_timeout=params.get('_request_timeout'), 2710 collection_formats=collection_formats) 2711 2712 def get_account_tab_settings(self, account_id, **kwargs): 2713 """ 2714 Returns tab settings list for specified account 2715 This method returns information about the tab types and tab functionality that is currently enabled for an account. 2716 This method makes a synchronous HTTP request by default. To make an 2717 asynchronous HTTP request, please define a `callback` function 2718 to be invoked when receiving the response. 2719 >>> def callback_function(response): 2720 >>> pprint(response) 2721 >>> 2722 >>> thread = api.get_account_tab_settings(account_id, callback=callback_function) 2723 2724 :param callback function: The callback function 2725 for asynchronous request. (optional) 2726 :param str account_id: The external account number (int) or account ID Guid. (required) 2727 :return: TabAccountSettings 2728 If the method is called asynchronously, 2729 returns the request thread. 2730 """ 2731 kwargs['_return_http_data_only'] = True 2732 if kwargs.get('callback'): 2733 return self.get_account_tab_settings_with_http_info(account_id, **kwargs) 2734 else: 2735 (data) = self.get_account_tab_settings_with_http_info(account_id, **kwargs) 2736 return data 2737 2738 def get_account_tab_settings_with_http_info(self, account_id, **kwargs): 2739 """ 2740 Returns tab settings list for specified account 2741 This method returns information about the tab types and tab functionality that is currently enabled for an account. 2742 This method makes a synchronous HTTP request by default. To make an 2743 asynchronous HTTP request, please define a `callback` function 2744 to be invoked when receiving the response. 2745 >>> def callback_function(response): 2746 >>> pprint(response) 2747 >>> 2748 >>> thread = api.get_account_tab_settings_with_http_info(account_id, callback=callback_function) 2749 2750 :param callback function: The callback function 2751 for asynchronous request. (optional) 2752 :param str account_id: The external account number (int) or account ID Guid. (required) 2753 :return: TabAccountSettings 2754 If the method is called asynchronously, 2755 returns the request thread. 2756 """ 2757 2758 all_params = ['account_id'] 2759 all_params.append('callback') 2760 all_params.append('_return_http_data_only') 2761 all_params.append('_preload_content') 2762 all_params.append('_request_timeout') 2763 2764 params = locals() 2765 for key, val in iteritems(params['kwargs']): 2766 if key not in all_params: 2767 raise TypeError( 2768 "Got an unexpected keyword argument '%s'" 2769 " to method get_account_tab_settings" % key 2770 ) 2771 params[key] = val 2772 del params['kwargs'] 2773 # verify the required parameter 'account_id' is set 2774 if ('account_id' not in params) or (params['account_id'] is None): 2775 raise ValueError("Missing the required parameter `account_id` when calling `get_account_tab_settings`") 2776 2777 2778 collection_formats = {} 2779 2780 resource_path = '/v2.1/accounts/{accountId}/settings/tabs'.replace('{format}', 'json') 2781 path_params = {} 2782 if 'account_id' in params: 2783 path_params['accountId'] = params['account_id'] 2784 2785 query_params = {} 2786 2787 header_params = {} 2788 2789 form_params = [] 2790 local_var_files = {} 2791 2792 body_params = None 2793 # HTTP header `Accept` 2794 header_params['Accept'] = self.api_client.\ 2795 select_header_accept(['application/json']) 2796 2797 # Authentication setting 2798 auth_settings = [] 2799 2800 return self.api_client.call_api(resource_path, 'GET', 2801 path_params, 2802 query_params, 2803 header_params, 2804 body=body_params, 2805 post_params=form_params, 2806 files=local_var_files, 2807 response_type='TabAccountSettings', 2808 auth_settings=auth_settings, 2809 callback=params.get('callback'), 2810 _return_http_data_only=params.get('_return_http_data_only'), 2811 _preload_content=params.get('_preload_content', True), 2812 _request_timeout=params.get('_request_timeout'), 2813 collection_formats=collection_formats) 2814 2815 def get_agent_user_authorizations(self, account_id, user_id, **kwargs): 2816 """ 2817 Returns the agent user authorizations 2818 This method makes a synchronous HTTP request by default. To make an 2819 asynchronous HTTP request, please define a `callback` function 2820 to be invoked when receiving the response. 2821 >>> def callback_function(response): 2822 >>> pprint(response) 2823 >>> 2824 >>> thread = api.get_agent_user_authorizations(account_id, user_id, callback=callback_function) 2825 2826 :param callback function: The callback function 2827 for asynchronous request. (optional) 2828 :param str account_id: The external account number (int) or account ID Guid. (required) 2829 :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required) 2830 :param str active_only: 2831 :param str count: 2832 :param str email_substring: Part (substring) of email we are searching for. 2833 :param str include_closed_users: 2834 :param str permissions: 2835 :param str start_position: 2836 :param str user_name_substring: 2837 :return: UserAuthorizations 2838 If the method is called asynchronously, 2839 returns the request thread. 2840 """ 2841 kwargs['_return_http_data_only'] = True 2842 if kwargs.get('callback'): 2843 return self.get_agent_user_authorizations_with_http_info(account_id, user_id, **kwargs) 2844 else: 2845 (data) = self.get_agent_user_authorizations_with_http_info(account_id, user_id, **kwargs) 2846 return data 2847 2848 def get_agent_user_authorizations_with_http_info(self, account_id, user_id, **kwargs): 2849 """ 2850 Returns the agent user authorizations 2851 This method makes a synchronous HTTP request by default. To make an 2852 asynchronous HTTP request, please define a `callback` function 2853 to be invoked when receiving the response. 2854 >>> def callback_function(response): 2855 >>> pprint(response) 2856 >>> 2857 >>> thread = api.get_agent_user_authorizations_with_http_info(account_id, user_id, callback=callback_function) 2858 2859 :param callback function: The callback function 2860 for asynchronous request. (optional) 2861 :param str account_id: The external account number (int) or account ID Guid. (required) 2862 :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required) 2863 :param str active_only: 2864 :param str count: 2865 :param str email_substring: Part (substring) of email we are searching for. 2866 :param str include_closed_users: 2867 :param str permissions: 2868 :param str start_position: 2869 :param str user_name_substring: 2870 :return: UserAuthorizations 2871 If the method is called asynchronously, 2872 returns the request thread. 2873 """ 2874 2875 all_params = ['account_id', 'user_id', 'active_only', 'count', 'email_substring', 'include_closed_users', 'permissions', 'start_position', 'user_name_substring'] 2876 all_params.append('callback') 2877 all_params.append('_return_http_data_only') 2878 all_params.append('_preload_content') 2879 all_params.append('_request_timeout') 2880 2881 params = locals() 2882 for key, val in iteritems(params['kwargs']): 2883 if key not in all_params: 2884 raise TypeError( 2885 "Got an unexpected keyword argument '%s'" 2886 " to method get_agent_user_authorizations" % key 2887 ) 2888 params[key] = val 2889 del params['kwargs'] 2890 # verify the required parameter 'account_id' is set 2891 if ('account_id' not in params) or (params['account_id'] is None): 2892 raise ValueError("Missing the required parameter `account_id` when calling `get_agent_user_authorizations`") 2893 # verify the required parameter 'user_id' is set 2894 if ('user_id' not in params) or (params['user_id'] is None): 2895 raise ValueError("Missing the required parameter `user_id` when calling `get_agent_user_authorizations`") 2896 2897 2898 collection_formats = {} 2899 2900 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorizations/agent'.replace('{format}', 'json') 2901 path_params = {} 2902 if 'account_id' in params: 2903 path_params['accountId'] = params['account_id'] 2904 if 'user_id' in params: 2905 path_params['userId'] = params['user_id'] 2906 2907 query_params = {} 2908 if 'active_only' in params: 2909 query_params['active_only'] = params['active_only'] 2910 if 'count' in params: 2911 query_params['count'] = params['count'] 2912 if 'email_substring' in params: 2913 query_params['email_substring'] = params['email_substring'] 2914 if 'include_closed_users' in params: 2915 query_params['include_closed_users'] = params['include_closed_users'] 2916 if 'permissions' in params: 2917 query_params['permissions'] = params['permissions'] 2918 if 'start_position' in params: 2919 query_params['start_position'] = params['start_position'] 2920 if 'user_name_substring' in params: 2921 query_params['user_name_substring'] = params['user_name_substring'] 2922 2923 header_params = {} 2924 2925 form_params = [] 2926 local_var_files = {} 2927 2928 body_params = None 2929 # HTTP header `Accept` 2930 header_params['Accept'] = self.api_client.\ 2931 select_header_accept(['application/json']) 2932 2933 # Authentication setting 2934 auth_settings = [] 2935 2936 return self.api_client.call_api(resource_path, 'GET', 2937 path_params, 2938 query_params, 2939 header_params, 2940 body=body_params, 2941 post_params=form_params, 2942 files=local_var_files, 2943 response_type='UserAuthorizations', 2944 auth_settings=auth_settings, 2945 callback=params.get('callback'), 2946 _return_http_data_only=params.get('_return_http_data_only'), 2947 _preload_content=params.get('_preload_content', True), 2948 _request_timeout=params.get('_request_timeout'), 2949 collection_formats=collection_formats) 2950 2951 def get_all_payment_gateway_accounts(self, account_id, **kwargs): 2952 """ 2953 Get all payment gateway account for the provided accountId 2954 This method returns a list of payment gateway accounts and basic information about them. 2955 This method makes a synchronous HTTP request by default. To make an 2956 asynchronous HTTP request, please define a `callback` function 2957 to be invoked when receiving the response. 2958 >>> def callback_function(response): 2959 >>> pprint(response) 2960 >>> 2961 >>> thread = api.get_all_payment_gateway_accounts(account_id, callback=callback_function) 2962 2963 :param callback function: The callback function 2964 for asynchronous request. (optional) 2965 :param str account_id: The external account number (int) or account ID Guid. (required) 2966 :return: PaymentGatewayAccountsInfo 2967 If the method is called asynchronously, 2968 returns the request thread. 2969 """ 2970 kwargs['_return_http_data_only'] = True 2971 if kwargs.get('callback'): 2972 return self.get_all_payment_gateway_accounts_with_http_info(account_id, **kwargs) 2973 else: 2974 (data) = self.get_all_payment_gateway_accounts_with_http_info(account_id, **kwargs) 2975 return data 2976 2977 def get_all_payment_gateway_accounts_with_http_info(self, account_id, **kwargs): 2978 """ 2979 Get all payment gateway account for the provided accountId 2980 This method returns a list of payment gateway accounts and basic information about them. 2981 This method makes a synchronous HTTP request by default. To make an 2982 asynchronous HTTP request, please define a `callback` function 2983 to be invoked when receiving the response. 2984 >>> def callback_function(response): 2985 >>> pprint(response) 2986 >>> 2987 >>> thread = api.get_all_payment_gateway_accounts_with_http_info(account_id, callback=callback_function) 2988 2989 :param callback function: The callback function 2990 for asynchronous request. (optional) 2991 :param str account_id: The external account number (int) or account ID Guid. (required) 2992 :return: PaymentGatewayAccountsInfo 2993 If the method is called asynchronously, 2994 returns the request thread. 2995 """ 2996 2997 all_params = ['account_id'] 2998 all_params.append('callback') 2999 all_params.append('_return_http_data_only') 3000 all_params.append('_preload_content') 3001 all_params.append('_request_timeout') 3002 3003 params = locals() 3004 for key, val in iteritems(params['kwargs']): 3005 if key not in all_params: 3006 raise TypeError( 3007 "Got an unexpected keyword argument '%s'" 3008 " to method get_all_payment_gateway_accounts" % key 3009 ) 3010 params[key] = val 3011 del params['kwargs'] 3012 # verify the required parameter 'account_id' is set 3013 if ('account_id' not in params) or (params['account_id'] is None): 3014 raise ValueError("Missing the required parameter `account_id` when calling `get_all_payment_gateway_accounts`") 3015 3016 3017 collection_formats = {} 3018 3019 resource_path = '/v2.1/accounts/{accountId}/payment_gateway_accounts'.replace('{format}', 'json') 3020 path_params = {} 3021 if 'account_id' in params: 3022 path_params['accountId'] = params['account_id'] 3023 3024 query_params = {} 3025 3026 header_params = {} 3027 3028 form_params = [] 3029 local_var_files = {} 3030 3031 body_params = None 3032 # HTTP header `Accept` 3033 header_params['Accept'] = self.api_client.\ 3034 select_header_accept(['application/json']) 3035 3036 # Authentication setting 3037 auth_settings = [] 3038 3039 return self.api_client.call_api(resource_path, 'GET', 3040 path_params, 3041 query_params, 3042 header_params, 3043 body=body_params, 3044 post_params=form_params, 3045 files=local_var_files, 3046 response_type='PaymentGatewayAccountsInfo', 3047 auth_settings=auth_settings, 3048 callback=params.get('callback'), 3049 _return_http_data_only=params.get('_return_http_data_only'), 3050 _preload_content=params.get('_preload_content', True), 3051 _request_timeout=params.get('_request_timeout'), 3052 collection_formats=collection_formats) 3053 3054 def get_billing_charges(self, account_id, **kwargs): 3055 """ 3056 Gets list of recurring and usage charges for the account. 3057 Retrieves the list of recurring and usage charges for the account. This can be used to determine the charge structure and usage of charge plan items. Privileges required: account administrator 3058 This method makes a synchronous HTTP request by default. To make an 3059 asynchronous HTTP request, please define a `callback` function 3060 to be invoked when receiving the response. 3061 >>> def callback_function(response): 3062 >>> pprint(response) 3063 >>> 3064 >>> thread = api.get_billing_charges(account_id, callback=callback_function) 3065 3066 :param callback function: The callback function 3067 for asynchronous request. (optional) 3068 :param str account_id: The external account number (int) or account ID Guid. (required) 3069 :param str include_charges: Specifies which billing charges to return. Valid values are: * envelopes * seats 3070 :return: BillingChargeResponse 3071 If the method is called asynchronously, 3072 returns the request thread. 3073 """ 3074 kwargs['_return_http_data_only'] = True 3075 if kwargs.get('callback'): 3076 return self.get_billing_charges_with_http_info(account_id, **kwargs) 3077 else: 3078 (data) = self.get_billing_charges_with_http_info(account_id, **kwargs) 3079 return data 3080 3081 def get_billing_charges_with_http_info(self, account_id, **kwargs): 3082 """ 3083 Gets list of recurring and usage charges for the account. 3084 Retrieves the list of recurring and usage charges for the account. This can be used to determine the charge structure and usage of charge plan items. Privileges required: account administrator 3085 This method makes a synchronous HTTP request by default. To make an 3086 asynchronous HTTP request, please define a `callback` function 3087 to be invoked when receiving the response. 3088 >>> def callback_function(response): 3089 >>> pprint(response) 3090 >>> 3091 >>> thread = api.get_billing_charges_with_http_info(account_id, callback=callback_function) 3092 3093 :param callback function: The callback function 3094 for asynchronous request. (optional) 3095 :param str account_id: The external account number (int) or account ID Guid. (required) 3096 :param str include_charges: Specifies which billing charges to return. Valid values are: * envelopes * seats 3097 :return: BillingChargeResponse 3098 If the method is called asynchronously, 3099 returns the request thread. 3100 """ 3101 3102 all_params = ['account_id', 'include_charges'] 3103 all_params.append('callback') 3104 all_params.append('_return_http_data_only') 3105 all_params.append('_preload_content') 3106 all_params.append('_request_timeout') 3107 3108 params = locals() 3109 for key, val in iteritems(params['kwargs']): 3110 if key not in all_params: 3111 raise TypeError( 3112 "Got an unexpected keyword argument '%s'" 3113 " to method get_billing_charges" % key 3114 ) 3115 params[key] = val 3116 del params['kwargs'] 3117 # verify the required parameter 'account_id' is set 3118 if ('account_id' not in params) or (params['account_id'] is None): 3119 raise ValueError("Missing the required parameter `account_id` when calling `get_billing_charges`") 3120 3121 3122 collection_formats = {} 3123 3124 resource_path = '/v2.1/accounts/{accountId}/billing_charges'.replace('{format}', 'json') 3125 path_params = {} 3126 if 'account_id' in params: 3127 path_params['accountId'] = params['account_id'] 3128 3129 query_params = {} 3130 if 'include_charges' in params: 3131 query_params['include_charges'] = params['include_charges'] 3132 3133 header_params = {} 3134 3135 form_params = [] 3136 local_var_files = {} 3137 3138 body_params = None 3139 # HTTP header `Accept` 3140 header_params['Accept'] = self.api_client.\ 3141 select_header_accept(['application/json']) 3142 3143 # Authentication setting 3144 auth_settings = [] 3145 3146 return self.api_client.call_api(resource_path, 'GET', 3147 path_params, 3148 query_params, 3149 header_params, 3150 body=body_params, 3151 post_params=form_params, 3152 files=local_var_files, 3153 response_type='BillingChargeResponse', 3154 auth_settings=auth_settings, 3155 callback=params.get('callback'), 3156 _return_http_data_only=params.get('_return_http_data_only'), 3157 _preload_content=params.get('_preload_content', True), 3158 _request_timeout=params.get('_request_timeout'), 3159 collection_formats=collection_formats) 3160 3161 def get_brand(self, account_id, brand_id, **kwargs): 3162 """ 3163 Get information for a specific brand. 3164 This method returns details about an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 3165 This method makes a synchronous HTTP request by default. To make an 3166 asynchronous HTTP request, please define a `callback` function 3167 to be invoked when receiving the response. 3168 >>> def callback_function(response): 3169 >>> pprint(response) 3170 >>> 3171 >>> thread = api.get_brand(account_id, brand_id, callback=callback_function) 3172 3173 :param callback function: The callback function 3174 for asynchronous request. (optional) 3175 :param str account_id: The external account number (int) or account ID Guid. (required) 3176 :param str brand_id: The unique identifier of a brand. (required) 3177 :param str include_external_references: 3178 :param str include_logos: 3179 :return: Brand 3180 If the method is called asynchronously, 3181 returns the request thread. 3182 """ 3183 kwargs['_return_http_data_only'] = True 3184 if kwargs.get('callback'): 3185 return self.get_brand_with_http_info(account_id, brand_id, **kwargs) 3186 else: 3187 (data) = self.get_brand_with_http_info(account_id, brand_id, **kwargs) 3188 return data 3189 3190 def get_brand_with_http_info(self, account_id, brand_id, **kwargs): 3191 """ 3192 Get information for a specific brand. 3193 This method returns details about an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 3194 This method makes a synchronous HTTP request by default. To make an 3195 asynchronous HTTP request, please define a `callback` function 3196 to be invoked when receiving the response. 3197 >>> def callback_function(response): 3198 >>> pprint(response) 3199 >>> 3200 >>> thread = api.get_brand_with_http_info(account_id, brand_id, callback=callback_function) 3201 3202 :param callback function: The callback function 3203 for asynchronous request. (optional) 3204 :param str account_id: The external account number (int) or account ID Guid. (required) 3205 :param str brand_id: The unique identifier of a brand. (required) 3206 :param str include_external_references: 3207 :param str include_logos: 3208 :return: Brand 3209 If the method is called asynchronously, 3210 returns the request thread. 3211 """ 3212 3213 all_params = ['account_id', 'brand_id', 'include_external_references', 'include_logos'] 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 get_brand" % 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 `get_brand`") 3231 # verify the required parameter 'brand_id' is set 3232 if ('brand_id' not in params) or (params['brand_id'] is None): 3233 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand`") 3234 3235 3236 collection_formats = {} 3237 3238 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 3239 path_params = {} 3240 if 'account_id' in params: 3241 path_params['accountId'] = params['account_id'] 3242 if 'brand_id' in params: 3243 path_params['brandId'] = params['brand_id'] 3244 3245 query_params = {} 3246 if 'include_external_references' in params: 3247 query_params['include_external_references'] = params['include_external_references'] 3248 if 'include_logos' in params: 3249 query_params['include_logos'] = params['include_logos'] 3250 3251 header_params = {} 3252 3253 form_params = [] 3254 local_var_files = {} 3255 3256 body_params = None 3257 # HTTP header `Accept` 3258 header_params['Accept'] = self.api_client.\ 3259 select_header_accept(['application/json']) 3260 3261 # Authentication setting 3262 auth_settings = [] 3263 3264 return self.api_client.call_api(resource_path, 'GET', 3265 path_params, 3266 query_params, 3267 header_params, 3268 body=body_params, 3269 post_params=form_params, 3270 files=local_var_files, 3271 response_type='Brand', 3272 auth_settings=auth_settings, 3273 callback=params.get('callback'), 3274 _return_http_data_only=params.get('_return_http_data_only'), 3275 _preload_content=params.get('_preload_content', True), 3276 _request_timeout=params.get('_request_timeout'), 3277 collection_formats=collection_formats) 3278 3279 def get_brand_export_file(self, account_id, brand_id, **kwargs): 3280 """ 3281 Export a specific brand. 3282 This method exports information about a brand to an XML file. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 3283 This method makes a synchronous HTTP request by default. To make an 3284 asynchronous HTTP request, please define a `callback` function 3285 to be invoked when receiving the response. 3286 >>> def callback_function(response): 3287 >>> pprint(response) 3288 >>> 3289 >>> thread = api.get_brand_export_file(account_id, brand_id, callback=callback_function) 3290 3291 :param callback function: The callback function 3292 for asynchronous request. (optional) 3293 :param str account_id: The external account number (int) or account ID Guid. (required) 3294 :param str brand_id: The unique identifier of a brand. (required) 3295 :return: None 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.get_brand_export_file_with_http_info(account_id, brand_id, **kwargs) 3302 else: 3303 (data) = self.get_brand_export_file_with_http_info(account_id, brand_id, **kwargs) 3304 return data 3305 3306 def get_brand_export_file_with_http_info(self, account_id, brand_id, **kwargs): 3307 """ 3308 Export a specific brand. 3309 This method exports information about a brand to an XML file. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 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.get_brand_export_file_with_http_info(account_id, brand_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 brand_id: The unique identifier of a brand. (required) 3322 :return: None 3323 If the method is called asynchronously, 3324 returns the request thread. 3325 """ 3326 3327 all_params = ['account_id', 'brand_id'] 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 get_brand_export_file" % 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 `get_brand_export_file`") 3345 # verify the required parameter 'brand_id' is set 3346 if ('brand_id' not in params) or (params['brand_id'] is None): 3347 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_export_file`") 3348 3349 3350 collection_formats = {} 3351 3352 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/file'.replace('{format}', 'json') 3353 path_params = {} 3354 if 'account_id' in params: 3355 path_params['accountId'] = params['account_id'] 3356 if 'brand_id' in params: 3357 path_params['brandId'] = params['brand_id'] 3358 3359 query_params = {} 3360 3361 header_params = {} 3362 3363 form_params = [] 3364 local_var_files = {} 3365 3366 body_params = None 3367 # HTTP header `Accept` 3368 header_params['Accept'] = self.api_client.\ 3369 select_header_accept(['application/json']) 3370 3371 # Authentication setting 3372 auth_settings = [] 3373 3374 return self.api_client.call_api(resource_path, 'GET', 3375 path_params, 3376 query_params, 3377 header_params, 3378 body=body_params, 3379 post_params=form_params, 3380 files=local_var_files, 3381 response_type=None, 3382 auth_settings=auth_settings, 3383 callback=params.get('callback'), 3384 _return_http_data_only=params.get('_return_http_data_only'), 3385 _preload_content=params.get('_preload_content', True), 3386 _request_timeout=params.get('_request_timeout'), 3387 collection_formats=collection_formats) 3388 3389 def get_brand_logo_by_type(self, account_id, brand_id, logo_type, **kwargs): 3390 """ 3391 Obtains the specified image for a brand. 3392 This method returns a specific logo that is used in a brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 3393 This method makes a synchronous HTTP request by default. To make an 3394 asynchronous HTTP request, please define a `callback` function 3395 to be invoked when receiving the response. 3396 >>> def callback_function(response): 3397 >>> pprint(response) 3398 >>> 3399 >>> thread = api.get_brand_logo_by_type(account_id, brand_id, logo_type, callback=callback_function) 3400 3401 :param callback function: The callback function 3402 for asynchronous request. (optional) 3403 :param str account_id: The external account number (int) or account ID Guid. (required) 3404 :param str brand_id: The unique identifier of a brand. (required) 3405 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 3406 :return: file 3407 If the method is called asynchronously, 3408 returns the request thread. 3409 """ 3410 kwargs['_return_http_data_only'] = True 3411 if kwargs.get('callback'): 3412 return self.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 3413 else: 3414 (data) = self.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 3415 return data 3416 3417 def get_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, **kwargs): 3418 """ 3419 Obtains the specified image for a brand. 3420 This method returns a specific logo that is used in a brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 3421 This method makes a synchronous HTTP request by default. To make an 3422 asynchronous HTTP request, please define a `callback` function 3423 to be invoked when receiving the response. 3424 >>> def callback_function(response): 3425 >>> pprint(response) 3426 >>> 3427 >>> thread = api.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, callback=callback_function) 3428 3429 :param callback function: The callback function 3430 for asynchronous request. (optional) 3431 :param str account_id: The external account number (int) or account ID Guid. (required) 3432 :param str brand_id: The unique identifier of a brand. (required) 3433 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 3434 :return: file 3435 If the method is called asynchronously, 3436 returns the request thread. 3437 """ 3438 3439 all_params = ['account_id', 'brand_id', 'logo_type'] 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 get_brand_logo_by_type" % 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 `get_brand_logo_by_type`") 3457 # verify the required parameter 'brand_id' is set 3458 if ('brand_id' not in params) or (params['brand_id'] is None): 3459 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_logo_by_type`") 3460 # verify the required parameter 'logo_type' is set 3461 if ('logo_type' not in params) or (params['logo_type'] is None): 3462 raise ValueError("Missing the required parameter `logo_type` when calling `get_brand_logo_by_type`") 3463 3464 3465 collection_formats = {} 3466 3467 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 3468 path_params = {} 3469 if 'account_id' in params: 3470 path_params['accountId'] = params['account_id'] 3471 if 'brand_id' in params: 3472 path_params['brandId'] = params['brand_id'] 3473 if 'logo_type' in params: 3474 path_params['logoType'] = params['logo_type'] 3475 3476 query_params = {} 3477 3478 header_params = {} 3479 3480 form_params = [] 3481 local_var_files = {} 3482 3483 body_params = None 3484 # HTTP header `Accept` 3485 header_params['Accept'] = self.api_client.\ 3486 select_header_accept(['image/png']) 3487 3488 # Authentication setting 3489 auth_settings = [] 3490 3491 return self.api_client.call_api(resource_path, 'GET', 3492 path_params, 3493 query_params, 3494 header_params, 3495 body=body_params, 3496 post_params=form_params, 3497 files=local_var_files, 3498 response_type='file', 3499 auth_settings=auth_settings, 3500 callback=params.get('callback'), 3501 _return_http_data_only=params.get('_return_http_data_only'), 3502 _preload_content=params.get('_preload_content', True), 3503 _request_timeout=params.get('_request_timeout'), 3504 collection_formats=collection_formats) 3505 3506 def get_brand_resources(self, account_id, brand_id, **kwargs): 3507 """ 3508 Returns the specified account's list of branding resources (metadata). 3509 This method returns metadata about the branding resources that are associated with an account. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 3510 This method makes a synchronous HTTP request by default. To make an 3511 asynchronous HTTP request, please define a `callback` function 3512 to be invoked when receiving the response. 3513 >>> def callback_function(response): 3514 >>> pprint(response) 3515 >>> 3516 >>> thread = api.get_brand_resources(account_id, brand_id, callback=callback_function) 3517 3518 :param callback function: The callback function 3519 for asynchronous request. (optional) 3520 :param str account_id: The external account number (int) or account ID Guid. (required) 3521 :param str brand_id: The unique identifier of a brand. (required) 3522 :return: BrandResourcesList 3523 If the method is called asynchronously, 3524 returns the request thread. 3525 """ 3526 kwargs['_return_http_data_only'] = True 3527 if kwargs.get('callback'): 3528 return self.get_brand_resources_with_http_info(account_id, brand_id, **kwargs) 3529 else: 3530 (data) = self.get_brand_resources_with_http_info(account_id, brand_id, **kwargs) 3531 return data 3532 3533 def get_brand_resources_with_http_info(self, account_id, brand_id, **kwargs): 3534 """ 3535 Returns the specified account's list of branding resources (metadata). 3536 This method returns metadata about the branding resources that are associated with an account. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 3537 This method makes a synchronous HTTP request by default. To make an 3538 asynchronous HTTP request, please define a `callback` function 3539 to be invoked when receiving the response. 3540 >>> def callback_function(response): 3541 >>> pprint(response) 3542 >>> 3543 >>> thread = api.get_brand_resources_with_http_info(account_id, brand_id, callback=callback_function) 3544 3545 :param callback function: The callback function 3546 for asynchronous request. (optional) 3547 :param str account_id: The external account number (int) or account ID Guid. (required) 3548 :param str brand_id: The unique identifier of a brand. (required) 3549 :return: BrandResourcesList 3550 If the method is called asynchronously, 3551 returns the request thread. 3552 """ 3553 3554 all_params = ['account_id', 'brand_id'] 3555 all_params.append('callback') 3556 all_params.append('_return_http_data_only') 3557 all_params.append('_preload_content') 3558 all_params.append('_request_timeout') 3559 3560 params = locals() 3561 for key, val in iteritems(params['kwargs']): 3562 if key not in all_params: 3563 raise TypeError( 3564 "Got an unexpected keyword argument '%s'" 3565 " to method get_brand_resources" % key 3566 ) 3567 params[key] = val 3568 del params['kwargs'] 3569 # verify the required parameter 'account_id' is set 3570 if ('account_id' not in params) or (params['account_id'] is None): 3571 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_resources`") 3572 # verify the required parameter 'brand_id' is set 3573 if ('brand_id' not in params) or (params['brand_id'] is None): 3574 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_resources`") 3575 3576 3577 collection_formats = {} 3578 3579 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources'.replace('{format}', 'json') 3580 path_params = {} 3581 if 'account_id' in params: 3582 path_params['accountId'] = params['account_id'] 3583 if 'brand_id' in params: 3584 path_params['brandId'] = params['brand_id'] 3585 3586 query_params = {} 3587 3588 header_params = {} 3589 3590 form_params = [] 3591 local_var_files = {} 3592 3593 body_params = None 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, 'GET', 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='BrandResourcesList', 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 get_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, **kwargs): 3617 """ 3618 Returns the specified branding resource file. 3619 This method returns a specific branding resource file. A brand uses a set of brand resource files to control the sending, signing, email message, and captive (embedded) signing experiences. You can modify the default email messages and formats in these files and upload them to your brand to customize the user experience. **Important:** When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 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.get_brand_resources_by_content_type(account_id, brand_id, resource_content_type, 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 brand_id: The unique identifier of a brand. (required) 3632 :param str resource_content_type: (required) 3633 :param str langcode: 3634 :param str return_master: 3635 :return: None 3636 If the method is called asynchronously, 3637 returns the request thread. 3638 """ 3639 kwargs['_return_http_data_only'] = True 3640 if kwargs.get('callback'): 3641 return self.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, **kwargs) 3642 else: 3643 (data) = self.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, **kwargs) 3644 return data 3645 3646 def get_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, **kwargs): 3647 """ 3648 Returns the specified branding resource file. 3649 This method returns a specific branding resource file. A brand uses a set of brand resource files to control the sending, signing, email message, and captive (embedded) signing experiences. You can modify the default email messages and formats in these files and upload them to your brand to customize the user experience. **Important:** When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 3650 This method makes a synchronous HTTP request by default. To make an 3651 asynchronous HTTP request, please define a `callback` function 3652 to be invoked when receiving the response. 3653 >>> def callback_function(response): 3654 >>> pprint(response) 3655 >>> 3656 >>> thread = api.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, callback=callback_function) 3657 3658 :param callback function: The callback function 3659 for asynchronous request. (optional) 3660 :param str account_id: The external account number (int) or account ID Guid. (required) 3661 :param str brand_id: The unique identifier of a brand. (required) 3662 :param str resource_content_type: (required) 3663 :param str langcode: 3664 :param str return_master: 3665 :return: None 3666 If the method is called asynchronously, 3667 returns the request thread. 3668 """ 3669 3670 all_params = ['account_id', 'brand_id', 'resource_content_type', 'langcode', 'return_master'] 3671 all_params.append('callback') 3672 all_params.append('_return_http_data_only') 3673 all_params.append('_preload_content') 3674 all_params.append('_request_timeout') 3675 3676 params = locals() 3677 for key, val in iteritems(params['kwargs']): 3678 if key not in all_params: 3679 raise TypeError( 3680 "Got an unexpected keyword argument '%s'" 3681 " to method get_brand_resources_by_content_type" % key 3682 ) 3683 params[key] = val 3684 del params['kwargs'] 3685 # verify the required parameter 'account_id' is set 3686 if ('account_id' not in params) or (params['account_id'] is None): 3687 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_resources_by_content_type`") 3688 # verify the required parameter 'brand_id' is set 3689 if ('brand_id' not in params) or (params['brand_id'] is None): 3690 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_resources_by_content_type`") 3691 # verify the required parameter 'resource_content_type' is set 3692 if ('resource_content_type' not in params) or (params['resource_content_type'] is None): 3693 raise ValueError("Missing the required parameter `resource_content_type` when calling `get_brand_resources_by_content_type`") 3694 3695 3696 collection_formats = {} 3697 3698 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources/{resourceContentType}'.replace('{format}', 'json') 3699 path_params = {} 3700 if 'account_id' in params: 3701 path_params['accountId'] = params['account_id'] 3702 if 'brand_id' in params: 3703 path_params['brandId'] = params['brand_id'] 3704 if 'resource_content_type' in params: 3705 path_params['resourceContentType'] = params['resource_content_type'] 3706 3707 query_params = {} 3708 if 'langcode' in params: 3709 query_params['langcode'] = params['langcode'] 3710 if 'return_master' in params: 3711 query_params['return_master'] = params['return_master'] 3712 3713 header_params = {} 3714 3715 form_params = [] 3716 local_var_files = {} 3717 3718 body_params = None 3719 # HTTP header `Accept` 3720 header_params['Accept'] = self.api_client.\ 3721 select_header_accept(['application/json']) 3722 3723 # Authentication setting 3724 auth_settings = [] 3725 3726 return self.api_client.call_api(resource_path, 'GET', 3727 path_params, 3728 query_params, 3729 header_params, 3730 body=body_params, 3731 post_params=form_params, 3732 files=local_var_files, 3733 response_type=None, 3734 auth_settings=auth_settings, 3735 callback=params.get('callback'), 3736 _return_http_data_only=params.get('_return_http_data_only'), 3737 _preload_content=params.get('_preload_content', True), 3738 _request_timeout=params.get('_request_timeout'), 3739 collection_formats=collection_formats) 3740 3741 def get_consumer_disclosure(self, account_id, lang_code, **kwargs): 3742 """ 3743 Gets the Electronic Record and Signature Disclosure. 3744 Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, for the requested envelope recipient. This might be different than the current account disclosure depending on account settings, such as branding, and when the account disclosure was last updated. An optional query string can be included to return the language for the disclosure. 3745 This method makes a synchronous HTTP request by default. To make an 3746 asynchronous HTTP request, please define a `callback` function 3747 to be invoked when receiving the response. 3748 >>> def callback_function(response): 3749 >>> pprint(response) 3750 >>> 3751 >>> thread = api.get_consumer_disclosure(account_id, lang_code, callback=callback_function) 3752 3753 :param callback function: The callback function 3754 for asynchronous request. (optional) 3755 :param str account_id: The external account number (int) or account ID Guid. (required) 3756 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 3757 :return: ConsumerDisclosure 3758 If the method is called asynchronously, 3759 returns the request thread. 3760 """ 3761 kwargs['_return_http_data_only'] = True 3762 if kwargs.get('callback'): 3763 return self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 3764 else: 3765 (data) = self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 3766 return data 3767 3768 def get_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs): 3769 """ 3770 Gets the Electronic Record and Signature Disclosure. 3771 Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, for the requested envelope recipient. This might be different than the current account disclosure depending on account settings, such as branding, and when the account disclosure was last updated. An optional query string can be included to return the language for the disclosure. 3772 This method makes a synchronous HTTP request by default. To make an 3773 asynchronous HTTP request, please define a `callback` function 3774 to be invoked when receiving the response. 3775 >>> def callback_function(response): 3776 >>> pprint(response) 3777 >>> 3778 >>> thread = api.get_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function) 3779 3780 :param callback function: The callback function 3781 for asynchronous request. (optional) 3782 :param str account_id: The external account number (int) or account ID Guid. (required) 3783 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 3784 :return: ConsumerDisclosure 3785 If the method is called asynchronously, 3786 returns the request thread. 3787 """ 3788 3789 all_params = ['account_id', 'lang_code'] 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 get_consumer_disclosure" % 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 `get_consumer_disclosure`") 3807 # verify the required parameter 'lang_code' is set 3808 if ('lang_code' not in params) or (params['lang_code'] is None): 3809 raise ValueError("Missing the required parameter `lang_code` when calling `get_consumer_disclosure`") 3810 3811 3812 collection_formats = {} 3813 3814 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 3815 path_params = {} 3816 if 'account_id' in params: 3817 path_params['accountId'] = params['account_id'] 3818 if 'lang_code' in params: 3819 path_params['langCode'] = params['lang_code'] 3820 3821 query_params = {} 3822 3823 header_params = {} 3824 3825 form_params = [] 3826 local_var_files = {} 3827 3828 body_params = None 3829 # HTTP header `Accept` 3830 header_params['Accept'] = self.api_client.\ 3831 select_header_accept(['application/json']) 3832 3833 # Authentication setting 3834 auth_settings = [] 3835 3836 return self.api_client.call_api(resource_path, 'GET', 3837 path_params, 3838 query_params, 3839 header_params, 3840 body=body_params, 3841 post_params=form_params, 3842 files=local_var_files, 3843 response_type='ConsumerDisclosure', 3844 auth_settings=auth_settings, 3845 callback=params.get('callback'), 3846 _return_http_data_only=params.get('_return_http_data_only'), 3847 _preload_content=params.get('_preload_content', True), 3848 _request_timeout=params.get('_request_timeout'), 3849 collection_formats=collection_formats) 3850 3851 def get_consumer_disclosure_default(self, account_id, **kwargs): 3852 """ 3853 Gets the Electronic Record and Signature Disclosure for the account. 3854 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. 3855 This method makes a synchronous HTTP request by default. To make an 3856 asynchronous HTTP request, please define a `callback` function 3857 to be invoked when receiving the response. 3858 >>> def callback_function(response): 3859 >>> pprint(response) 3860 >>> 3861 >>> thread = api.get_consumer_disclosure_default(account_id, callback=callback_function) 3862 3863 :param callback function: The callback function 3864 for asynchronous request. (optional) 3865 :param str account_id: The external account number (int) or account ID Guid. (required) 3866 :param str lang_code: Specifies 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. 3867 :return: ConsumerDisclosure 3868 If the method is called asynchronously, 3869 returns the request thread. 3870 """ 3871 kwargs['_return_http_data_only'] = True 3872 if kwargs.get('callback'): 3873 return self.get_consumer_disclosure_default_with_http_info(account_id, **kwargs) 3874 else: 3875 (data) = self.get_consumer_disclosure_default_with_http_info(account_id, **kwargs) 3876 return data 3877 3878 def get_consumer_disclosure_default_with_http_info(self, account_id, **kwargs): 3879 """ 3880 Gets the Electronic Record and Signature Disclosure for the account. 3881 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. 3882 This method makes a synchronous HTTP request by default. To make an 3883 asynchronous HTTP request, please define a `callback` function 3884 to be invoked when receiving the response. 3885 >>> def callback_function(response): 3886 >>> pprint(response) 3887 >>> 3888 >>> thread = api.get_consumer_disclosure_default_with_http_info(account_id, callback=callback_function) 3889 3890 :param callback function: The callback function 3891 for asynchronous request. (optional) 3892 :param str account_id: The external account number (int) or account ID Guid. (required) 3893 :param str lang_code: Specifies 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. 3894 :return: ConsumerDisclosure 3895 If the method is called asynchronously, 3896 returns the request thread. 3897 """ 3898 3899 all_params = ['account_id', 'lang_code'] 3900 all_params.append('callback') 3901 all_params.append('_return_http_data_only') 3902 all_params.append('_preload_content') 3903 all_params.append('_request_timeout') 3904 3905 params = locals() 3906 for key, val in iteritems(params['kwargs']): 3907 if key not in all_params: 3908 raise TypeError( 3909 "Got an unexpected keyword argument '%s'" 3910 " to method get_consumer_disclosure_default" % key 3911 ) 3912 params[key] = val 3913 del params['kwargs'] 3914 # verify the required parameter 'account_id' is set 3915 if ('account_id' not in params) or (params['account_id'] is None): 3916 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure_default`") 3917 3918 3919 collection_formats = {} 3920 3921 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure'.replace('{format}', 'json') 3922 path_params = {} 3923 if 'account_id' in params: 3924 path_params['accountId'] = params['account_id'] 3925 3926 query_params = {} 3927 if 'lang_code' in params: 3928 query_params['langCode'] = params['lang_code'] 3929 3930 header_params = {} 3931 3932 form_params = [] 3933 local_var_files = {} 3934 3935 body_params = None 3936 # HTTP header `Accept` 3937 header_params['Accept'] = self.api_client.\ 3938 select_header_accept(['application/json']) 3939 3940 # Authentication setting 3941 auth_settings = [] 3942 3943 return self.api_client.call_api(resource_path, 'GET', 3944 path_params, 3945 query_params, 3946 header_params, 3947 body=body_params, 3948 post_params=form_params, 3949 files=local_var_files, 3950 response_type='ConsumerDisclosure', 3951 auth_settings=auth_settings, 3952 callback=params.get('callback'), 3953 _return_http_data_only=params.get('_return_http_data_only'), 3954 _preload_content=params.get('_preload_content', True), 3955 _request_timeout=params.get('_request_timeout'), 3956 collection_formats=collection_formats) 3957 3958 def get_e_note_configuration(self, account_id, **kwargs): 3959 """ 3960 Returns the configuration information for the eNote eOriginal integration. 3961 3962 This method makes a synchronous HTTP request by default. To make an 3963 asynchronous HTTP request, please define a `callback` function 3964 to be invoked when receiving the response. 3965 >>> def callback_function(response): 3966 >>> pprint(response) 3967 >>> 3968 >>> thread = api.get_e_note_configuration(account_id, callback=callback_function) 3969 3970 :param callback function: The callback function 3971 for asynchronous request. (optional) 3972 :param str account_id: The external account number (int) or account ID Guid. (required) 3973 :return: ENoteConfiguration 3974 If the method is called asynchronously, 3975 returns the request thread. 3976 """ 3977 kwargs['_return_http_data_only'] = True 3978 if kwargs.get('callback'): 3979 return self.get_e_note_configuration_with_http_info(account_id, **kwargs) 3980 else: 3981 (data) = self.get_e_note_configuration_with_http_info(account_id, **kwargs) 3982 return data 3983 3984 def get_e_note_configuration_with_http_info(self, account_id, **kwargs): 3985 """ 3986 Returns the configuration information for the eNote eOriginal integration. 3987 3988 This method makes a synchronous HTTP request by default. To make an 3989 asynchronous HTTP request, please define a `callback` function 3990 to be invoked when receiving the response. 3991 >>> def callback_function(response): 3992 >>> pprint(response) 3993 >>> 3994 >>> thread = api.get_e_note_configuration_with_http_info(account_id, callback=callback_function) 3995 3996 :param callback function: The callback function 3997 for asynchronous request. (optional) 3998 :param str account_id: The external account number (int) or account ID Guid. (required) 3999 :return: ENoteConfiguration 4000 If the method is called asynchronously, 4001 returns the request thread. 4002 """ 4003 4004 all_params = ['account_id'] 4005 all_params.append('callback') 4006 all_params.append('_return_http_data_only') 4007 all_params.append('_preload_content') 4008 all_params.append('_request_timeout') 4009 4010 params = locals() 4011 for key, val in iteritems(params['kwargs']): 4012 if key not in all_params: 4013 raise TypeError( 4014 "Got an unexpected keyword argument '%s'" 4015 " to method get_e_note_configuration" % key 4016 ) 4017 params[key] = val 4018 del params['kwargs'] 4019 # verify the required parameter 'account_id' is set 4020 if ('account_id' not in params) or (params['account_id'] is None): 4021 raise ValueError("Missing the required parameter `account_id` when calling `get_e_note_configuration`") 4022 4023 4024 collection_formats = {} 4025 4026 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 4027 path_params = {} 4028 if 'account_id' in params: 4029 path_params['accountId'] = params['account_id'] 4030 4031 query_params = {} 4032 4033 header_params = {} 4034 4035 form_params = [] 4036 local_var_files = {} 4037 4038 body_params = None 4039 # HTTP header `Accept` 4040 header_params['Accept'] = self.api_client.\ 4041 select_header_accept(['application/json']) 4042 4043 # Authentication setting 4044 auth_settings = [] 4045 4046 return self.api_client.call_api(resource_path, 'GET', 4047 path_params, 4048 query_params, 4049 header_params, 4050 body=body_params, 4051 post_params=form_params, 4052 files=local_var_files, 4053 response_type='ENoteConfiguration', 4054 auth_settings=auth_settings, 4055 callback=params.get('callback'), 4056 _return_http_data_only=params.get('_return_http_data_only'), 4057 _preload_content=params.get('_preload_content', True), 4058 _request_timeout=params.get('_request_timeout'), 4059 collection_formats=collection_formats) 4060 4061 def get_envelope_purge_configuration(self, account_id, **kwargs): 4062 """ 4063 Select envelope purge configuration. 4064 An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method retrieves the current envelope purge configuration for your account. **Note:** To use this method, you must be an account administrator. 4065 This method makes a synchronous HTTP request by default. To make an 4066 asynchronous HTTP request, please define a `callback` function 4067 to be invoked when receiving the response. 4068 >>> def callback_function(response): 4069 >>> pprint(response) 4070 >>> 4071 >>> thread = api.get_envelope_purge_configuration(account_id, callback=callback_function) 4072 4073 :param callback function: The callback function 4074 for asynchronous request. (optional) 4075 :param str account_id: The external account number (int) or account ID Guid. (required) 4076 :return: EnvelopePurgeConfiguration 4077 If the method is called asynchronously, 4078 returns the request thread. 4079 """ 4080 kwargs['_return_http_data_only'] = True 4081 if kwargs.get('callback'): 4082 return self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs) 4083 else: 4084 (data) = self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs) 4085 return data 4086 4087 def get_envelope_purge_configuration_with_http_info(self, account_id, **kwargs): 4088 """ 4089 Select envelope purge configuration. 4090 An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method retrieves the current envelope purge configuration for your account. **Note:** To use this method, you must be an account administrator. 4091 This method makes a synchronous HTTP request by default. To make an 4092 asynchronous HTTP request, please define a `callback` function 4093 to be invoked when receiving the response. 4094 >>> def callback_function(response): 4095 >>> pprint(response) 4096 >>> 4097 >>> thread = api.get_envelope_purge_configuration_with_http_info(account_id, callback=callback_function) 4098 4099 :param callback function: The callback function 4100 for asynchronous request. (optional) 4101 :param str account_id: The external account number (int) or account ID Guid. (required) 4102 :return: EnvelopePurgeConfiguration 4103 If the method is called asynchronously, 4104 returns the request thread. 4105 """ 4106 4107 all_params = ['account_id'] 4108 all_params.append('callback') 4109 all_params.append('_return_http_data_only') 4110 all_params.append('_preload_content') 4111 all_params.append('_request_timeout') 4112 4113 params = locals() 4114 for key, val in iteritems(params['kwargs']): 4115 if key not in all_params: 4116 raise TypeError( 4117 "Got an unexpected keyword argument '%s'" 4118 " to method get_envelope_purge_configuration" % key 4119 ) 4120 params[key] = val 4121 del params['kwargs'] 4122 # verify the required parameter 'account_id' is set 4123 if ('account_id' not in params) or (params['account_id'] is None): 4124 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_purge_configuration`") 4125 4126 4127 collection_formats = {} 4128 4129 resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json') 4130 path_params = {} 4131 if 'account_id' in params: 4132 path_params['accountId'] = params['account_id'] 4133 4134 query_params = {} 4135 4136 header_params = {} 4137 4138 form_params = [] 4139 local_var_files = {} 4140 4141 body_params = None 4142 # HTTP header `Accept` 4143 header_params['Accept'] = self.api_client.\ 4144 select_header_accept(['application/json']) 4145 4146 # Authentication setting 4147 auth_settings = [] 4148 4149 return self.api_client.call_api(resource_path, 'GET', 4150 path_params, 4151 query_params, 4152 header_params, 4153 body=body_params, 4154 post_params=form_params, 4155 files=local_var_files, 4156 response_type='EnvelopePurgeConfiguration', 4157 auth_settings=auth_settings, 4158 callback=params.get('callback'), 4159 _return_http_data_only=params.get('_return_http_data_only'), 4160 _preload_content=params.get('_preload_content', True), 4161 _request_timeout=params.get('_request_timeout'), 4162 collection_formats=collection_formats) 4163 4164 def get_favorite_templates(self, account_id, **kwargs): 4165 """ 4166 Retrieves the list of favorited templates for this caller 4167 4168 This method makes a synchronous HTTP request by default. To make an 4169 asynchronous HTTP request, please define a `callback` function 4170 to be invoked when receiving the response. 4171 >>> def callback_function(response): 4172 >>> pprint(response) 4173 >>> 4174 >>> thread = api.get_favorite_templates(account_id, callback=callback_function) 4175 4176 :param callback function: The callback function 4177 for asynchronous request. (optional) 4178 :param str account_id: The external account number (int) or account ID Guid. (required) 4179 :return: FavoriteTemplatesInfo 4180 If the method is called asynchronously, 4181 returns the request thread. 4182 """ 4183 kwargs['_return_http_data_only'] = True 4184 if kwargs.get('callback'): 4185 return self.get_favorite_templates_with_http_info(account_id, **kwargs) 4186 else: 4187 (data) = self.get_favorite_templates_with_http_info(account_id, **kwargs) 4188 return data 4189 4190 def get_favorite_templates_with_http_info(self, account_id, **kwargs): 4191 """ 4192 Retrieves the list of favorited templates for this caller 4193 4194 This method makes a synchronous HTTP request by default. To make an 4195 asynchronous HTTP request, please define a `callback` function 4196 to be invoked when receiving the response. 4197 >>> def callback_function(response): 4198 >>> pprint(response) 4199 >>> 4200 >>> thread = api.get_favorite_templates_with_http_info(account_id, callback=callback_function) 4201 4202 :param callback function: The callback function 4203 for asynchronous request. (optional) 4204 :param str account_id: The external account number (int) or account ID Guid. (required) 4205 :return: FavoriteTemplatesInfo 4206 If the method is called asynchronously, 4207 returns the request thread. 4208 """ 4209 4210 all_params = ['account_id'] 4211 all_params.append('callback') 4212 all_params.append('_return_http_data_only') 4213 all_params.append('_preload_content') 4214 all_params.append('_request_timeout') 4215 4216 params = locals() 4217 for key, val in iteritems(params['kwargs']): 4218 if key not in all_params: 4219 raise TypeError( 4220 "Got an unexpected keyword argument '%s'" 4221 " to method get_favorite_templates" % key 4222 ) 4223 params[key] = val 4224 del params['kwargs'] 4225 # verify the required parameter 'account_id' is set 4226 if ('account_id' not in params) or (params['account_id'] is None): 4227 raise ValueError("Missing the required parameter `account_id` when calling `get_favorite_templates`") 4228 4229 4230 collection_formats = {} 4231 4232 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 4233 path_params = {} 4234 if 'account_id' in params: 4235 path_params['accountId'] = params['account_id'] 4236 4237 query_params = {} 4238 4239 header_params = {} 4240 4241 form_params = [] 4242 local_var_files = {} 4243 4244 body_params = None 4245 # HTTP header `Accept` 4246 header_params['Accept'] = self.api_client.\ 4247 select_header_accept(['application/json']) 4248 4249 # Authentication setting 4250 auth_settings = [] 4251 4252 return self.api_client.call_api(resource_path, 'GET', 4253 path_params, 4254 query_params, 4255 header_params, 4256 body=body_params, 4257 post_params=form_params, 4258 files=local_var_files, 4259 response_type='FavoriteTemplatesInfo', 4260 auth_settings=auth_settings, 4261 callback=params.get('callback'), 4262 _return_http_data_only=params.get('_return_http_data_only'), 4263 _preload_content=params.get('_preload_content', True), 4264 _request_timeout=params.get('_request_timeout'), 4265 collection_formats=collection_formats) 4266 4267 def get_notification_defaults(self, account_id, **kwargs): 4268 """ 4269 Returns default user level settings for a specified account 4270 This method returns the default settings for the email notifications that signers and senders receive about envelopes. 4271 This method makes a synchronous HTTP request by default. To make an 4272 asynchronous HTTP request, please define a `callback` function 4273 to be invoked when receiving the response. 4274 >>> def callback_function(response): 4275 >>> pprint(response) 4276 >>> 4277 >>> thread = api.get_notification_defaults(account_id, callback=callback_function) 4278 4279 :param callback function: The callback function 4280 for asynchronous request. (optional) 4281 :param str account_id: The external account number (int) or account ID Guid. (required) 4282 :return: NotificationDefaults 4283 If the method is called asynchronously, 4284 returns the request thread. 4285 """ 4286 kwargs['_return_http_data_only'] = True 4287 if kwargs.get('callback'): 4288 return self.get_notification_defaults_with_http_info(account_id, **kwargs) 4289 else: 4290 (data) = self.get_notification_defaults_with_http_info(account_id, **kwargs) 4291 return data 4292 4293 def get_notification_defaults_with_http_info(self, account_id, **kwargs): 4294 """ 4295 Returns default user level settings for a specified account 4296 This method returns the default settings for the email notifications that signers and senders receive about envelopes. 4297 This method makes a synchronous HTTP request by default. To make an 4298 asynchronous HTTP request, please define a `callback` function 4299 to be invoked when receiving the response. 4300 >>> def callback_function(response): 4301 >>> pprint(response) 4302 >>> 4303 >>> thread = api.get_notification_defaults_with_http_info(account_id, callback=callback_function) 4304 4305 :param callback function: The callback function 4306 for asynchronous request. (optional) 4307 :param str account_id: The external account number (int) or account ID Guid. (required) 4308 :return: NotificationDefaults 4309 If the method is called asynchronously, 4310 returns the request thread. 4311 """ 4312 4313 all_params = ['account_id'] 4314 all_params.append('callback') 4315 all_params.append('_return_http_data_only') 4316 all_params.append('_preload_content') 4317 all_params.append('_request_timeout') 4318 4319 params = locals() 4320 for key, val in iteritems(params['kwargs']): 4321 if key not in all_params: 4322 raise TypeError( 4323 "Got an unexpected keyword argument '%s'" 4324 " to method get_notification_defaults" % key 4325 ) 4326 params[key] = val 4327 del params['kwargs'] 4328 # verify the required parameter 'account_id' is set 4329 if ('account_id' not in params) or (params['account_id'] is None): 4330 raise ValueError("Missing the required parameter `account_id` when calling `get_notification_defaults`") 4331 4332 4333 collection_formats = {} 4334 4335 resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json') 4336 path_params = {} 4337 if 'account_id' in params: 4338 path_params['accountId'] = params['account_id'] 4339 4340 query_params = {} 4341 4342 header_params = {} 4343 4344 form_params = [] 4345 local_var_files = {} 4346 4347 body_params = None 4348 # HTTP header `Accept` 4349 header_params['Accept'] = self.api_client.\ 4350 select_header_accept(['application/json']) 4351 4352 # Authentication setting 4353 auth_settings = [] 4354 4355 return self.api_client.call_api(resource_path, 'GET', 4356 path_params, 4357 query_params, 4358 header_params, 4359 body=body_params, 4360 post_params=form_params, 4361 files=local_var_files, 4362 response_type='NotificationDefaults', 4363 auth_settings=auth_settings, 4364 callback=params.get('callback'), 4365 _return_http_data_only=params.get('_return_http_data_only'), 4366 _preload_content=params.get('_preload_content', True), 4367 _request_timeout=params.get('_request_timeout'), 4368 collection_formats=collection_formats) 4369 4370 def get_password_rules(self, account_id, **kwargs): 4371 """ 4372 Get the password rules 4373 This method retrieves the password rules for an account. 4374 This method makes a synchronous HTTP request by default. To make an 4375 asynchronous HTTP request, please define a `callback` function 4376 to be invoked when receiving the response. 4377 >>> def callback_function(response): 4378 >>> pprint(response) 4379 >>> 4380 >>> thread = api.get_password_rules(account_id, callback=callback_function) 4381 4382 :param callback function: The callback function 4383 for asynchronous request. (optional) 4384 :param str account_id: The external account number (int) or account ID Guid. (required) 4385 :return: AccountPasswordRules 4386 If the method is called asynchronously, 4387 returns the request thread. 4388 """ 4389 kwargs['_return_http_data_only'] = True 4390 if kwargs.get('callback'): 4391 return self.get_password_rules_with_http_info(account_id, **kwargs) 4392 else: 4393 (data) = self.get_password_rules_with_http_info(account_id, **kwargs) 4394 return data 4395 4396 def get_password_rules_with_http_info(self, account_id, **kwargs): 4397 """ 4398 Get the password rules 4399 This method retrieves the password rules for an account. 4400 This method makes a synchronous HTTP request by default. To make an 4401 asynchronous HTTP request, please define a `callback` function 4402 to be invoked when receiving the response. 4403 >>> def callback_function(response): 4404 >>> pprint(response) 4405 >>> 4406 >>> thread = api.get_password_rules_with_http_info(account_id, callback=callback_function) 4407 4408 :param callback function: The callback function 4409 for asynchronous request. (optional) 4410 :param str account_id: The external account number (int) or account ID Guid. (required) 4411 :return: AccountPasswordRules 4412 If the method is called asynchronously, 4413 returns the request thread. 4414 """ 4415 4416 all_params = ['account_id'] 4417 all_params.append('callback') 4418 all_params.append('_return_http_data_only') 4419 all_params.append('_preload_content') 4420 all_params.append('_request_timeout') 4421 4422 params = locals() 4423 for key, val in iteritems(params['kwargs']): 4424 if key not in all_params: 4425 raise TypeError( 4426 "Got an unexpected keyword argument '%s'" 4427 " to method get_password_rules" % key 4428 ) 4429 params[key] = val 4430 del params['kwargs'] 4431 # verify the required parameter 'account_id' is set 4432 if ('account_id' not in params) or (params['account_id'] is None): 4433 raise ValueError("Missing the required parameter `account_id` when calling `get_password_rules`") 4434 4435 4436 collection_formats = {} 4437 4438 resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json') 4439 path_params = {} 4440 if 'account_id' in params: 4441 path_params['accountId'] = params['account_id'] 4442 4443 query_params = {} 4444 4445 header_params = {} 4446 4447 form_params = [] 4448 local_var_files = {} 4449 4450 body_params = None 4451 # HTTP header `Accept` 4452 header_params['Accept'] = self.api_client.\ 4453 select_header_accept(['application/json']) 4454 4455 # Authentication setting 4456 auth_settings = [] 4457 4458 return self.api_client.call_api(resource_path, 'GET', 4459 path_params, 4460 query_params, 4461 header_params, 4462 body=body_params, 4463 post_params=form_params, 4464 files=local_var_files, 4465 response_type='AccountPasswordRules', 4466 auth_settings=auth_settings, 4467 callback=params.get('callback'), 4468 _return_http_data_only=params.get('_return_http_data_only'), 4469 _preload_content=params.get('_preload_content', True), 4470 _request_timeout=params.get('_request_timeout'), 4471 collection_formats=collection_formats) 4472 4473 def get_password_rules_0(self, **kwargs): 4474 """ 4475 Get membership account password rules 4476 4477 This method makes a synchronous HTTP request by default. To make an 4478 asynchronous HTTP request, please define a `callback` function 4479 to be invoked when receiving the response. 4480 >>> def callback_function(response): 4481 >>> pprint(response) 4482 >>> 4483 >>> thread = api.get_password_rules_0(callback=callback_function) 4484 4485 :param callback function: The callback function 4486 for asynchronous request. (optional) 4487 :return: UserPasswordRules 4488 If the method is called asynchronously, 4489 returns the request thread. 4490 """ 4491 kwargs['_return_http_data_only'] = True 4492 if kwargs.get('callback'): 4493 return self.get_password_rules_0_with_http_info(**kwargs) 4494 else: 4495 (data) = self.get_password_rules_0_with_http_info(**kwargs) 4496 return data 4497 4498 def get_password_rules_0_with_http_info(self, **kwargs): 4499 """ 4500 Get membership account password rules 4501 4502 This method makes a synchronous HTTP request by default. To make an 4503 asynchronous HTTP request, please define a `callback` function 4504 to be invoked when receiving the response. 4505 >>> def callback_function(response): 4506 >>> pprint(response) 4507 >>> 4508 >>> thread = api.get_password_rules_0_with_http_info(callback=callback_function) 4509 4510 :param callback function: The callback function 4511 for asynchronous request. (optional) 4512 :return: UserPasswordRules 4513 If the method is called asynchronously, 4514 returns the request thread. 4515 """ 4516 4517 all_params = [] 4518 all_params.append('callback') 4519 all_params.append('_return_http_data_only') 4520 all_params.append('_preload_content') 4521 all_params.append('_request_timeout') 4522 4523 params = locals() 4524 for key, val in iteritems(params['kwargs']): 4525 if key not in all_params: 4526 raise TypeError( 4527 "Got an unexpected keyword argument '%s'" 4528 " to method get_password_rules_0" % key 4529 ) 4530 params[key] = val 4531 del params['kwargs'] 4532 4533 collection_formats = {} 4534 4535 resource_path = '/v2.1/current_user/password_rules'.replace('{format}', 'json') 4536 path_params = {} 4537 4538 query_params = {} 4539 4540 header_params = {} 4541 4542 form_params = [] 4543 local_var_files = {} 4544 4545 body_params = None 4546 # HTTP header `Accept` 4547 header_params['Accept'] = self.api_client.\ 4548 select_header_accept(['application/json']) 4549 4550 # Authentication setting 4551 auth_settings = [] 4552 4553 return self.api_client.call_api(resource_path, 'GET', 4554 path_params, 4555 query_params, 4556 header_params, 4557 body=body_params, 4558 post_params=form_params, 4559 files=local_var_files, 4560 response_type='UserPasswordRules', 4561 auth_settings=auth_settings, 4562 callback=params.get('callback'), 4563 _return_http_data_only=params.get('_return_http_data_only'), 4564 _preload_content=params.get('_preload_content', True), 4565 _request_timeout=params.get('_request_timeout'), 4566 collection_formats=collection_formats) 4567 4568 def get_permission_profile(self, account_id, permission_profile_id, **kwargs): 4569 """ 4570 Returns a permissions profile in the specified account. 4571 This method returns information about a specific permission profile that is associated with an account. ### Related topics - [How to set a permission profile](/docs/esign-rest-api/how-to/permission-profile-setting/) 4572 This method makes a synchronous HTTP request by default. To make an 4573 asynchronous HTTP request, please define a `callback` function 4574 to be invoked when receiving the response. 4575 >>> def callback_function(response): 4576 >>> pprint(response) 4577 >>> 4578 >>> thread = api.get_permission_profile(account_id, permission_profile_id, callback=callback_function) 4579 4580 :param callback function: The callback function 4581 for asynchronous request. (optional) 4582 :param str account_id: The external account number (int) or account ID Guid. (required) 4583 :param str permission_profile_id: (required) 4584 :param str include: 4585 :return: PermissionProfile 4586 If the method is called asynchronously, 4587 returns the request thread. 4588 """ 4589 kwargs['_return_http_data_only'] = True 4590 if kwargs.get('callback'): 4591 return self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 4592 else: 4593 (data) = self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 4594 return data 4595 4596 def get_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 4597 """ 4598 Returns a permissions profile in the specified account. 4599 This method returns information about a specific permission profile that is associated with an account. ### Related topics - [How to set a permission profile](/docs/esign-rest-api/how-to/permission-profile-setting/) 4600 This method makes a synchronous HTTP request by default. To make an 4601 asynchronous HTTP request, please define a `callback` function 4602 to be invoked when receiving the response. 4603 >>> def callback_function(response): 4604 >>> pprint(response) 4605 >>> 4606 >>> thread = api.get_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 4607 4608 :param callback function: The callback function 4609 for asynchronous request. (optional) 4610 :param str account_id: The external account number (int) or account ID Guid. (required) 4611 :param str permission_profile_id: (required) 4612 :param str include: 4613 :return: PermissionProfile 4614 If the method is called asynchronously, 4615 returns the request thread. 4616 """ 4617 4618 all_params = ['account_id', 'permission_profile_id', 'include'] 4619 all_params.append('callback') 4620 all_params.append('_return_http_data_only') 4621 all_params.append('_preload_content') 4622 all_params.append('_request_timeout') 4623 4624 params = locals() 4625 for key, val in iteritems(params['kwargs']): 4626 if key not in all_params: 4627 raise TypeError( 4628 "Got an unexpected keyword argument '%s'" 4629 " to method get_permission_profile" % key 4630 ) 4631 params[key] = val 4632 del params['kwargs'] 4633 # verify the required parameter 'account_id' is set 4634 if ('account_id' not in params) or (params['account_id'] is None): 4635 raise ValueError("Missing the required parameter `account_id` when calling `get_permission_profile`") 4636 # verify the required parameter 'permission_profile_id' is set 4637 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 4638 raise ValueError("Missing the required parameter `permission_profile_id` when calling `get_permission_profile`") 4639 4640 4641 collection_formats = {} 4642 4643 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 4644 path_params = {} 4645 if 'account_id' in params: 4646 path_params['accountId'] = params['account_id'] 4647 if 'permission_profile_id' in params: 4648 path_params['permissionProfileId'] = params['permission_profile_id'] 4649 4650 query_params = {} 4651 if 'include' in params: 4652 query_params['include'] = params['include'] 4653 4654 header_params = {} 4655 4656 form_params = [] 4657 local_var_files = {} 4658 4659 body_params = None 4660 # HTTP header `Accept` 4661 header_params['Accept'] = self.api_client.\ 4662 select_header_accept(['application/json']) 4663 4664 # Authentication setting 4665 auth_settings = [] 4666 4667 return self.api_client.call_api(resource_path, 'GET', 4668 path_params, 4669 query_params, 4670 header_params, 4671 body=body_params, 4672 post_params=form_params, 4673 files=local_var_files, 4674 response_type='PermissionProfile', 4675 auth_settings=auth_settings, 4676 callback=params.get('callback'), 4677 _return_http_data_only=params.get('_return_http_data_only'), 4678 _preload_content=params.get('_preload_content', True), 4679 _request_timeout=params.get('_request_timeout'), 4680 collection_formats=collection_formats) 4681 4682 def get_principal_user_authorizations(self, account_id, user_id, **kwargs): 4683 """ 4684 Returns the principal user authorizations 4685 This method makes a synchronous HTTP request by default. To make an 4686 asynchronous HTTP request, please define a `callback` function 4687 to be invoked when receiving the response. 4688 >>> def callback_function(response): 4689 >>> pprint(response) 4690 >>> 4691 >>> thread = api.get_principal_user_authorizations(account_id, user_id, callback=callback_function) 4692 4693 :param callback function: The callback function 4694 for asynchronous request. (optional) 4695 :param str account_id: The external account number (int) or account ID Guid. (required) 4696 :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required) 4697 :param str active_only: 4698 :param str count: 4699 :param str email_substring: Part (substring) of email we are searching for. 4700 :param str include_closed_users: 4701 :param str permissions: 4702 :param str start_position: 4703 :param str user_name_substring: 4704 :return: UserAuthorizations 4705 If the method is called asynchronously, 4706 returns the request thread. 4707 """ 4708 kwargs['_return_http_data_only'] = True 4709 if kwargs.get('callback'): 4710 return self.get_principal_user_authorizations_with_http_info(account_id, user_id, **kwargs) 4711 else: 4712 (data) = self.get_principal_user_authorizations_with_http_info(account_id, user_id, **kwargs) 4713 return data 4714 4715 def get_principal_user_authorizations_with_http_info(self, account_id, user_id, **kwargs): 4716 """ 4717 Returns the principal user authorizations 4718 This method makes a synchronous HTTP request by default. To make an 4719 asynchronous HTTP request, please define a `callback` function 4720 to be invoked when receiving the response. 4721 >>> def callback_function(response): 4722 >>> pprint(response) 4723 >>> 4724 >>> thread = api.get_principal_user_authorizations_with_http_info(account_id, user_id, callback=callback_function) 4725 4726 :param callback function: The callback function 4727 for asynchronous request. (optional) 4728 :param str account_id: The external account number (int) or account ID Guid. (required) 4729 :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required) 4730 :param str active_only: 4731 :param str count: 4732 :param str email_substring: Part (substring) of email we are searching for. 4733 :param str include_closed_users: 4734 :param str permissions: 4735 :param str start_position: 4736 :param str user_name_substring: 4737 :return: UserAuthorizations 4738 If the method is called asynchronously, 4739 returns the request thread. 4740 """ 4741 4742 all_params = ['account_id', 'user_id', 'active_only', 'count', 'email_substring', 'include_closed_users', 'permissions', 'start_position', 'user_name_substring'] 4743 all_params.append('callback') 4744 all_params.append('_return_http_data_only') 4745 all_params.append('_preload_content') 4746 all_params.append('_request_timeout') 4747 4748 params = locals() 4749 for key, val in iteritems(params['kwargs']): 4750 if key not in all_params: 4751 raise TypeError( 4752 "Got an unexpected keyword argument '%s'" 4753 " to method get_principal_user_authorizations" % key 4754 ) 4755 params[key] = val 4756 del params['kwargs'] 4757 # verify the required parameter 'account_id' is set 4758 if ('account_id' not in params) or (params['account_id'] is None): 4759 raise ValueError("Missing the required parameter `account_id` when calling `get_principal_user_authorizations`") 4760 # verify the required parameter 'user_id' is set 4761 if ('user_id' not in params) or (params['user_id'] is None): 4762 raise ValueError("Missing the required parameter `user_id` when calling `get_principal_user_authorizations`") 4763 4764 4765 collection_formats = {} 4766 4767 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorizations'.replace('{format}', 'json') 4768 path_params = {} 4769 if 'account_id' in params: 4770 path_params['accountId'] = params['account_id'] 4771 if 'user_id' in params: 4772 path_params['userId'] = params['user_id'] 4773 4774 query_params = {} 4775 if 'active_only' in params: 4776 query_params['active_only'] = params['active_only'] 4777 if 'count' in params: 4778 query_params['count'] = params['count'] 4779 if 'email_substring' in params: 4780 query_params['email_substring'] = params['email_substring'] 4781 if 'include_closed_users' in params: 4782 query_params['include_closed_users'] = params['include_closed_users'] 4783 if 'permissions' in params: 4784 query_params['permissions'] = params['permissions'] 4785 if 'start_position' in params: 4786 query_params['start_position'] = params['start_position'] 4787 if 'user_name_substring' in params: 4788 query_params['user_name_substring'] = params['user_name_substring'] 4789 4790 header_params = {} 4791 4792 form_params = [] 4793 local_var_files = {} 4794 4795 body_params = None 4796 # HTTP header `Accept` 4797 header_params['Accept'] = self.api_client.\ 4798 select_header_accept(['application/json']) 4799 4800 # Authentication setting 4801 auth_settings = [] 4802 4803 return self.api_client.call_api(resource_path, 'GET', 4804 path_params, 4805 query_params, 4806 header_params, 4807 body=body_params, 4808 post_params=form_params, 4809 files=local_var_files, 4810 response_type='UserAuthorizations', 4811 auth_settings=auth_settings, 4812 callback=params.get('callback'), 4813 _return_http_data_only=params.get('_return_http_data_only'), 4814 _preload_content=params.get('_preload_content', True), 4815 _request_timeout=params.get('_request_timeout'), 4816 collection_formats=collection_formats) 4817 4818 def get_provisioning(self, **kwargs): 4819 """ 4820 Retrieves the account provisioning information for the account. 4821 Retrieves the account provisioning information for the account. 4822 This method makes a synchronous HTTP request by default. To make an 4823 asynchronous HTTP request, please define a `callback` function 4824 to be invoked when receiving the response. 4825 >>> def callback_function(response): 4826 >>> pprint(response) 4827 >>> 4828 >>> thread = api.get_provisioning(callback=callback_function) 4829 4830 :param callback function: The callback function 4831 for asynchronous request. (optional) 4832 :return: ProvisioningInformation 4833 If the method is called asynchronously, 4834 returns the request thread. 4835 """ 4836 kwargs['_return_http_data_only'] = True 4837 if kwargs.get('callback'): 4838 return self.get_provisioning_with_http_info(**kwargs) 4839 else: 4840 (data) = self.get_provisioning_with_http_info(**kwargs) 4841 return data 4842 4843 def get_provisioning_with_http_info(self, **kwargs): 4844 """ 4845 Retrieves the account provisioning information for the account. 4846 Retrieves the account provisioning information for the account. 4847 This method makes a synchronous HTTP request by default. To make an 4848 asynchronous HTTP request, please define a `callback` function 4849 to be invoked when receiving the response. 4850 >>> def callback_function(response): 4851 >>> pprint(response) 4852 >>> 4853 >>> thread = api.get_provisioning_with_http_info(callback=callback_function) 4854 4855 :param callback function: The callback function 4856 for asynchronous request. (optional) 4857 :return: ProvisioningInformation 4858 If the method is called asynchronously, 4859 returns the request thread. 4860 """ 4861 4862 all_params = [] 4863 all_params.append('callback') 4864 all_params.append('_return_http_data_only') 4865 all_params.append('_preload_content') 4866 all_params.append('_request_timeout') 4867 4868 params = locals() 4869 for key, val in iteritems(params['kwargs']): 4870 if key not in all_params: 4871 raise TypeError( 4872 "Got an unexpected keyword argument '%s'" 4873 " to method get_provisioning" % key 4874 ) 4875 params[key] = val 4876 del params['kwargs'] 4877 4878 collection_formats = {} 4879 4880 resource_path = '/v2.1/accounts/provisioning'.replace('{format}', 'json') 4881 path_params = {} 4882 4883 query_params = {} 4884 4885 header_params = {} 4886 4887 form_params = [] 4888 local_var_files = {} 4889 4890 body_params = None 4891 # HTTP header `Accept` 4892 header_params['Accept'] = self.api_client.\ 4893 select_header_accept(['application/json']) 4894 4895 # Authentication setting 4896 auth_settings = [] 4897 4898 return self.api_client.call_api(resource_path, 'GET', 4899 path_params, 4900 query_params, 4901 header_params, 4902 body=body_params, 4903 post_params=form_params, 4904 files=local_var_files, 4905 response_type='ProvisioningInformation', 4906 auth_settings=auth_settings, 4907 callback=params.get('callback'), 4908 _return_http_data_only=params.get('_return_http_data_only'), 4909 _preload_content=params.get('_preload_content', True), 4910 _request_timeout=params.get('_request_timeout'), 4911 collection_formats=collection_formats) 4912 4913 def get_supported_languages(self, account_id, **kwargs): 4914 """ 4915 Gets list of supported languages for recipient language setting. 4916 Retrieves a list of supported languages that you can set for an individual recipient when creating an envelope, as well as their simple type enumeration values. These are the languages that you can set for the standard email format and signing view for each recipient. For example, in the recipient's email notification, this setting affects elements such as the standard introductory text describing the request to sign. It also determines the language used for buttons and tabs in both the email notification and the signing experience. **Note:** Setting a language for a recipient affects only the DocuSign standard text. Any custom text that you enter for the `emailBody` and `emailSubject` of the notification is not translated, and appears exactly as you enter it. For more information, see [Set Recipient Language and Specify Custom Email Messages](https://support.docusign.com/en/guides/ndse-user-guide-recipient-language). 4917 This method makes a synchronous HTTP request by default. To make an 4918 asynchronous HTTP request, please define a `callback` function 4919 to be invoked when receiving the response. 4920 >>> def callback_function(response): 4921 >>> pprint(response) 4922 >>> 4923 >>> thread = api.get_supported_languages(account_id, callback=callback_function) 4924 4925 :param callback function: The callback function 4926 for asynchronous request. (optional) 4927 :param str account_id: The external account number (int) or account ID Guid. (required) 4928 :return: SupportedLanguages 4929 If the method is called asynchronously, 4930 returns the request thread. 4931 """ 4932 kwargs['_return_http_data_only'] = True 4933 if kwargs.get('callback'): 4934 return self.get_supported_languages_with_http_info(account_id, **kwargs) 4935 else: 4936 (data) = self.get_supported_languages_with_http_info(account_id, **kwargs) 4937 return data 4938 4939 def get_supported_languages_with_http_info(self, account_id, **kwargs): 4940 """ 4941 Gets list of supported languages for recipient language setting. 4942 Retrieves a list of supported languages that you can set for an individual recipient when creating an envelope, as well as their simple type enumeration values. These are the languages that you can set for the standard email format and signing view for each recipient. For example, in the recipient's email notification, this setting affects elements such as the standard introductory text describing the request to sign. It also determines the language used for buttons and tabs in both the email notification and the signing experience. **Note:** Setting a language for a recipient affects only the DocuSign standard text. Any custom text that you enter for the `emailBody` and `emailSubject` of the notification is not translated, and appears exactly as you enter it. For more information, see [Set Recipient Language and Specify Custom Email Messages](https://support.docusign.com/en/guides/ndse-user-guide-recipient-language). 4943 This method makes a synchronous HTTP request by default. To make an 4944 asynchronous HTTP request, please define a `callback` function 4945 to be invoked when receiving the response. 4946 >>> def callback_function(response): 4947 >>> pprint(response) 4948 >>> 4949 >>> thread = api.get_supported_languages_with_http_info(account_id, callback=callback_function) 4950 4951 :param callback function: The callback function 4952 for asynchronous request. (optional) 4953 :param str account_id: The external account number (int) or account ID Guid. (required) 4954 :return: SupportedLanguages 4955 If the method is called asynchronously, 4956 returns the request thread. 4957 """ 4958 4959 all_params = ['account_id'] 4960 all_params.append('callback') 4961 all_params.append('_return_http_data_only') 4962 all_params.append('_preload_content') 4963 all_params.append('_request_timeout') 4964 4965 params = locals() 4966 for key, val in iteritems(params['kwargs']): 4967 if key not in all_params: 4968 raise TypeError( 4969 "Got an unexpected keyword argument '%s'" 4970 " to method get_supported_languages" % key 4971 ) 4972 params[key] = val 4973 del params['kwargs'] 4974 # verify the required parameter 'account_id' is set 4975 if ('account_id' not in params) or (params['account_id'] is None): 4976 raise ValueError("Missing the required parameter `account_id` when calling `get_supported_languages`") 4977 4978 4979 collection_formats = {} 4980 4981 resource_path = '/v2.1/accounts/{accountId}/supported_languages'.replace('{format}', 'json') 4982 path_params = {} 4983 if 'account_id' in params: 4984 path_params['accountId'] = params['account_id'] 4985 4986 query_params = {} 4987 4988 header_params = {} 4989 4990 form_params = [] 4991 local_var_files = {} 4992 4993 body_params = None 4994 # HTTP header `Accept` 4995 header_params['Accept'] = self.api_client.\ 4996 select_header_accept(['application/json']) 4997 4998 # Authentication setting 4999 auth_settings = [] 5000 5001 return self.api_client.call_api(resource_path, 'GET', 5002 path_params, 5003 query_params, 5004 header_params, 5005 body=body_params, 5006 post_params=form_params, 5007 files=local_var_files, 5008 response_type='SupportedLanguages', 5009 auth_settings=auth_settings, 5010 callback=params.get('callback'), 5011 _return_http_data_only=params.get('_return_http_data_only'), 5012 _preload_content=params.get('_preload_content', True), 5013 _request_timeout=params.get('_request_timeout'), 5014 collection_formats=collection_formats) 5015 5016 def get_user_authorization(self, account_id, authorization_id, user_id, **kwargs): 5017 """ 5018 Returns the user authorization for a given authorization id 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.get_user_authorization(account_id, authorization_id, user_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 authorization_id: (required) 5031 :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required) 5032 :return: UserAuthorization 5033 If the method is called asynchronously, 5034 returns the request thread. 5035 """ 5036 kwargs['_return_http_data_only'] = True 5037 if kwargs.get('callback'): 5038 return self.get_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 5039 else: 5040 (data) = self.get_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 5041 return data 5042 5043 def get_user_authorization_with_http_info(self, account_id, authorization_id, user_id, **kwargs): 5044 """ 5045 Returns the user authorization for a given authorization id 5046 This method makes a synchronous HTTP request by default. To make an 5047 asynchronous HTTP request, please define a `callback` function 5048 to be invoked when receiving the response. 5049 >>> def callback_function(response): 5050 >>> pprint(response) 5051 >>> 5052 >>> thread = api.get_user_authorization_with_http_info(account_id, authorization_id, user_id, callback=callback_function) 5053 5054 :param callback function: The callback function 5055 for asynchronous request. (optional) 5056 :param str account_id: The external account number (int) or account ID Guid. (required) 5057 :param str authorization_id: (required) 5058 :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required) 5059 :return: UserAuthorization 5060 If the method is called asynchronously, 5061 returns the request thread. 5062 """ 5063 5064 all_params = ['account_id', 'authorization_id', 'user_id'] 5065 all_params.append('callback') 5066 all_params.append('_return_http_data_only') 5067 all_params.append('_preload_content') 5068 all_params.append('_request_timeout') 5069 5070 params = locals() 5071 for key, val in iteritems(params['kwargs']): 5072 if key not in all_params: 5073 raise TypeError( 5074 "Got an unexpected keyword argument '%s'" 5075 " to method get_user_authorization" % key 5076 ) 5077 params[key] = val 5078 del params['kwargs'] 5079 # verify the required parameter 'account_id' is set 5080 if ('account_id' not in params) or (params['account_id'] is None): 5081 raise ValueError("Missing the required parameter `account_id` when calling `get_user_authorization`") 5082 # verify the required parameter 'authorization_id' is set 5083 if ('authorization_id' not in params) or (params['authorization_id'] is None): 5084 raise ValueError("Missing the required parameter `authorization_id` when calling `get_user_authorization`") 5085 # verify the required parameter 'user_id' is set 5086 if ('user_id' not in params) or (params['user_id'] is None): 5087 raise ValueError("Missing the required parameter `user_id` when calling `get_user_authorization`") 5088 5089 5090 collection_formats = {} 5091 5092 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorization/{authorizationId}'.replace('{format}', 'json') 5093 path_params = {} 5094 if 'account_id' in params: 5095 path_params['accountId'] = params['account_id'] 5096 if 'authorization_id' in params: 5097 path_params['authorizationId'] = params['authorization_id'] 5098 if 'user_id' in params: 5099 path_params['userId'] = params['user_id'] 5100 5101 query_params = {} 5102 5103 header_params = {} 5104 5105 form_params = [] 5106 local_var_files = {} 5107 5108 body_params = None 5109 # HTTP header `Accept` 5110 header_params['Accept'] = self.api_client.\ 5111 select_header_accept(['application/json']) 5112 5113 # Authentication setting 5114 auth_settings = [] 5115 5116 return self.api_client.call_api(resource_path, 'GET', 5117 path_params, 5118 query_params, 5119 header_params, 5120 body=body_params, 5121 post_params=form_params, 5122 files=local_var_files, 5123 response_type='UserAuthorization', 5124 auth_settings=auth_settings, 5125 callback=params.get('callback'), 5126 _return_http_data_only=params.get('_return_http_data_only'), 5127 _preload_content=params.get('_preload_content', True), 5128 _request_timeout=params.get('_request_timeout'), 5129 collection_formats=collection_formats) 5130 5131 def get_watermark(self, account_id, **kwargs): 5132 """ 5133 Get watermark information. 5134 5135 This method makes a synchronous HTTP request by default. To make an 5136 asynchronous HTTP request, please define a `callback` function 5137 to be invoked when receiving the response. 5138 >>> def callback_function(response): 5139 >>> pprint(response) 5140 >>> 5141 >>> thread = api.get_watermark(account_id, callback=callback_function) 5142 5143 :param callback function: The callback function 5144 for asynchronous request. (optional) 5145 :param str account_id: The external account number (int) or account ID Guid. (required) 5146 :return: Watermark 5147 If the method is called asynchronously, 5148 returns the request thread. 5149 """ 5150 kwargs['_return_http_data_only'] = True 5151 if kwargs.get('callback'): 5152 return self.get_watermark_with_http_info(account_id, **kwargs) 5153 else: 5154 (data) = self.get_watermark_with_http_info(account_id, **kwargs) 5155 return data 5156 5157 def get_watermark_with_http_info(self, account_id, **kwargs): 5158 """ 5159 Get watermark information. 5160 5161 This method makes a synchronous HTTP request by default. To make an 5162 asynchronous HTTP request, please define a `callback` function 5163 to be invoked when receiving the response. 5164 >>> def callback_function(response): 5165 >>> pprint(response) 5166 >>> 5167 >>> thread = api.get_watermark_with_http_info(account_id, callback=callback_function) 5168 5169 :param callback function: The callback function 5170 for asynchronous request. (optional) 5171 :param str account_id: The external account number (int) or account ID Guid. (required) 5172 :return: Watermark 5173 If the method is called asynchronously, 5174 returns the request thread. 5175 """ 5176 5177 all_params = ['account_id'] 5178 all_params.append('callback') 5179 all_params.append('_return_http_data_only') 5180 all_params.append('_preload_content') 5181 all_params.append('_request_timeout') 5182 5183 params = locals() 5184 for key, val in iteritems(params['kwargs']): 5185 if key not in all_params: 5186 raise TypeError( 5187 "Got an unexpected keyword argument '%s'" 5188 " to method get_watermark" % key 5189 ) 5190 params[key] = val 5191 del params['kwargs'] 5192 # verify the required parameter 'account_id' is set 5193 if ('account_id' not in params) or (params['account_id'] is None): 5194 raise ValueError("Missing the required parameter `account_id` when calling `get_watermark`") 5195 5196 5197 collection_formats = {} 5198 5199 resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json') 5200 path_params = {} 5201 if 'account_id' in params: 5202 path_params['accountId'] = params['account_id'] 5203 5204 query_params = {} 5205 5206 header_params = {} 5207 5208 form_params = [] 5209 local_var_files = {} 5210 5211 body_params = None 5212 # HTTP header `Accept` 5213 header_params['Accept'] = self.api_client.\ 5214 select_header_accept(['application/json']) 5215 5216 # Authentication setting 5217 auth_settings = [] 5218 5219 return self.api_client.call_api(resource_path, 'GET', 5220 path_params, 5221 query_params, 5222 header_params, 5223 body=body_params, 5224 post_params=form_params, 5225 files=local_var_files, 5226 response_type='Watermark', 5227 auth_settings=auth_settings, 5228 callback=params.get('callback'), 5229 _return_http_data_only=params.get('_return_http_data_only'), 5230 _preload_content=params.get('_preload_content', True), 5231 _request_timeout=params.get('_request_timeout'), 5232 collection_formats=collection_formats) 5233 5234 def get_watermark_preview(self, account_id, **kwargs): 5235 """ 5236 Get watermark preview. 5237 5238 This method makes a synchronous HTTP request by default. To make an 5239 asynchronous HTTP request, please define a `callback` function 5240 to be invoked when receiving the response. 5241 >>> def callback_function(response): 5242 >>> pprint(response) 5243 >>> 5244 >>> thread = api.get_watermark_preview(account_id, callback=callback_function) 5245 5246 :param callback function: The callback function 5247 for asynchronous request. (optional) 5248 :param str account_id: The external account number (int) or account ID Guid. (required) 5249 :param Watermark watermark: 5250 :return: Watermark 5251 If the method is called asynchronously, 5252 returns the request thread. 5253 """ 5254 kwargs['_return_http_data_only'] = True 5255 if kwargs.get('callback'): 5256 return self.get_watermark_preview_with_http_info(account_id, **kwargs) 5257 else: 5258 (data) = self.get_watermark_preview_with_http_info(account_id, **kwargs) 5259 return data 5260 5261 def get_watermark_preview_with_http_info(self, account_id, **kwargs): 5262 """ 5263 Get watermark preview. 5264 5265 This method makes a synchronous HTTP request by default. To make an 5266 asynchronous HTTP request, please define a `callback` function 5267 to be invoked when receiving the response. 5268 >>> def callback_function(response): 5269 >>> pprint(response) 5270 >>> 5271 >>> thread = api.get_watermark_preview_with_http_info(account_id, callback=callback_function) 5272 5273 :param callback function: The callback function 5274 for asynchronous request. (optional) 5275 :param str account_id: The external account number (int) or account ID Guid. (required) 5276 :param Watermark watermark: 5277 :return: Watermark 5278 If the method is called asynchronously, 5279 returns the request thread. 5280 """ 5281 5282 all_params = ['account_id', 'watermark'] 5283 all_params.append('callback') 5284 all_params.append('_return_http_data_only') 5285 all_params.append('_preload_content') 5286 all_params.append('_request_timeout') 5287 5288 params = locals() 5289 for key, val in iteritems(params['kwargs']): 5290 if key not in all_params: 5291 raise TypeError( 5292 "Got an unexpected keyword argument '%s'" 5293 " to method get_watermark_preview" % key 5294 ) 5295 params[key] = val 5296 del params['kwargs'] 5297 # verify the required parameter 'account_id' is set 5298 if ('account_id' not in params) or (params['account_id'] is None): 5299 raise ValueError("Missing the required parameter `account_id` when calling `get_watermark_preview`") 5300 5301 5302 collection_formats = {} 5303 5304 resource_path = '/v2.1/accounts/{accountId}/watermark/preview'.replace('{format}', 'json') 5305 path_params = {} 5306 if 'account_id' in params: 5307 path_params['accountId'] = params['account_id'] 5308 5309 query_params = {} 5310 5311 header_params = {} 5312 5313 form_params = [] 5314 local_var_files = {} 5315 5316 body_params = None 5317 if 'watermark' in params: 5318 body_params = params['watermark'] 5319 # HTTP header `Accept` 5320 header_params['Accept'] = self.api_client.\ 5321 select_header_accept(['application/json']) 5322 5323 # Authentication setting 5324 auth_settings = [] 5325 5326 return self.api_client.call_api(resource_path, 'PUT', 5327 path_params, 5328 query_params, 5329 header_params, 5330 body=body_params, 5331 post_params=form_params, 5332 files=local_var_files, 5333 response_type='Watermark', 5334 auth_settings=auth_settings, 5335 callback=params.get('callback'), 5336 _return_http_data_only=params.get('_return_http_data_only'), 5337 _preload_content=params.get('_preload_content', True), 5338 _request_timeout=params.get('_request_timeout'), 5339 collection_formats=collection_formats) 5340 5341 def list_brands(self, account_id, **kwargs): 5342 """ 5343 Gets a list of brand profiles. 5344 Retrieves the list of brand profiles associated with the account and the default brand profiles. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`) must be set to **true** for the account to use this call. 5345 This method makes a synchronous HTTP request by default. To make an 5346 asynchronous HTTP request, please define a `callback` function 5347 to be invoked when receiving the response. 5348 >>> def callback_function(response): 5349 >>> pprint(response) 5350 >>> 5351 >>> thread = api.list_brands(account_id, callback=callback_function) 5352 5353 :param callback function: The callback function 5354 for asynchronous request. (optional) 5355 :param str account_id: The external account number (int) or account ID Guid. (required) 5356 :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set. 5357 :param str include_logos: When set to **true**, returns the logos associated with the brand. 5358 :return: BrandsResponse 5359 If the method is called asynchronously, 5360 returns the request thread. 5361 """ 5362 kwargs['_return_http_data_only'] = True 5363 if kwargs.get('callback'): 5364 return self.list_brands_with_http_info(account_id, **kwargs) 5365 else: 5366 (data) = self.list_brands_with_http_info(account_id, **kwargs) 5367 return data 5368 5369 def list_brands_with_http_info(self, account_id, **kwargs): 5370 """ 5371 Gets a list of brand profiles. 5372 Retrieves the list of brand profiles associated with the account and the default brand profiles. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`) must be set to **true** for the account to use this call. 5373 This method makes a synchronous HTTP request by default. To make an 5374 asynchronous HTTP request, please define a `callback` function 5375 to be invoked when receiving the response. 5376 >>> def callback_function(response): 5377 >>> pprint(response) 5378 >>> 5379 >>> thread = api.list_brands_with_http_info(account_id, callback=callback_function) 5380 5381 :param callback function: The callback function 5382 for asynchronous request. (optional) 5383 :param str account_id: The external account number (int) or account ID Guid. (required) 5384 :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set. 5385 :param str include_logos: When set to **true**, returns the logos associated with the brand. 5386 :return: BrandsResponse 5387 If the method is called asynchronously, 5388 returns the request thread. 5389 """ 5390 5391 all_params = ['account_id', 'exclude_distributor_brand', 'include_logos'] 5392 all_params.append('callback') 5393 all_params.append('_return_http_data_only') 5394 all_params.append('_preload_content') 5395 all_params.append('_request_timeout') 5396 5397 params = locals() 5398 for key, val in iteritems(params['kwargs']): 5399 if key not in all_params: 5400 raise TypeError( 5401 "Got an unexpected keyword argument '%s'" 5402 " to method list_brands" % key 5403 ) 5404 params[key] = val 5405 del params['kwargs'] 5406 # verify the required parameter 'account_id' is set 5407 if ('account_id' not in params) or (params['account_id'] is None): 5408 raise ValueError("Missing the required parameter `account_id` when calling `list_brands`") 5409 5410 5411 collection_formats = {} 5412 5413 resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json') 5414 path_params = {} 5415 if 'account_id' in params: 5416 path_params['accountId'] = params['account_id'] 5417 5418 query_params = {} 5419 if 'exclude_distributor_brand' in params: 5420 query_params['exclude_distributor_brand'] = params['exclude_distributor_brand'] 5421 if 'include_logos' in params: 5422 query_params['include_logos'] = params['include_logos'] 5423 5424 header_params = {} 5425 5426 form_params = [] 5427 local_var_files = {} 5428 5429 body_params = None 5430 # HTTP header `Accept` 5431 header_params['Accept'] = self.api_client.\ 5432 select_header_accept(['application/json']) 5433 5434 # Authentication setting 5435 auth_settings = [] 5436 5437 return self.api_client.call_api(resource_path, 'GET', 5438 path_params, 5439 query_params, 5440 header_params, 5441 body=body_params, 5442 post_params=form_params, 5443 files=local_var_files, 5444 response_type='BrandsResponse', 5445 auth_settings=auth_settings, 5446 callback=params.get('callback'), 5447 _return_http_data_only=params.get('_return_http_data_only'), 5448 _preload_content=params.get('_preload_content', True), 5449 _request_timeout=params.get('_request_timeout'), 5450 collection_formats=collection_formats) 5451 5452 def list_custom_fields(self, account_id, **kwargs): 5453 """ 5454 Gets a list of custom fields associated with the account. 5455 Retrieves a list of envelope custom fields associated with the account. 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. The list custom field lets the sender select the value of the field from a list you provide. 5456 This method makes a synchronous HTTP request by default. To make an 5457 asynchronous HTTP request, please define a `callback` function 5458 to be invoked when receiving the response. 5459 >>> def callback_function(response): 5460 >>> pprint(response) 5461 >>> 5462 >>> thread = api.list_custom_fields(account_id, callback=callback_function) 5463 5464 :param callback function: The callback function 5465 for asynchronous request. (optional) 5466 :param str account_id: The external account number (int) or account ID Guid. (required) 5467 :return: CustomFields 5468 If the method is called asynchronously, 5469 returns the request thread. 5470 """ 5471 kwargs['_return_http_data_only'] = True 5472 if kwargs.get('callback'): 5473 return self.list_custom_fields_with_http_info(account_id, **kwargs) 5474 else: 5475 (data) = self.list_custom_fields_with_http_info(account_id, **kwargs) 5476 return data 5477 5478 def list_custom_fields_with_http_info(self, account_id, **kwargs): 5479 """ 5480 Gets a list of custom fields associated with the account. 5481 Retrieves a list of envelope custom fields associated with the account. 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. The list custom field lets the sender select the value of the field from a list you provide. 5482 This method makes a synchronous HTTP request by default. To make an 5483 asynchronous HTTP request, please define a `callback` function 5484 to be invoked when receiving the response. 5485 >>> def callback_function(response): 5486 >>> pprint(response) 5487 >>> 5488 >>> thread = api.list_custom_fields_with_http_info(account_id, callback=callback_function) 5489 5490 :param callback function: The callback function 5491 for asynchronous request. (optional) 5492 :param str account_id: The external account number (int) or account ID Guid. (required) 5493 :return: CustomFields 5494 If the method is called asynchronously, 5495 returns the request thread. 5496 """ 5497 5498 all_params = ['account_id'] 5499 all_params.append('callback') 5500 all_params.append('_return_http_data_only') 5501 all_params.append('_preload_content') 5502 all_params.append('_request_timeout') 5503 5504 params = locals() 5505 for key, val in iteritems(params['kwargs']): 5506 if key not in all_params: 5507 raise TypeError( 5508 "Got an unexpected keyword argument '%s'" 5509 " to method list_custom_fields" % key 5510 ) 5511 params[key] = val 5512 del params['kwargs'] 5513 # verify the required parameter 'account_id' is set 5514 if ('account_id' not in params) or (params['account_id'] is None): 5515 raise ValueError("Missing the required parameter `account_id` when calling `list_custom_fields`") 5516 5517 5518 collection_formats = {} 5519 5520 resource_path = '/v2.1/accounts/{accountId}/custom_fields'.replace('{format}', 'json') 5521 path_params = {} 5522 if 'account_id' in params: 5523 path_params['accountId'] = params['account_id'] 5524 5525 query_params = {} 5526 5527 header_params = {} 5528 5529 form_params = [] 5530 local_var_files = {} 5531 5532 body_params = None 5533 # HTTP header `Accept` 5534 header_params['Accept'] = self.api_client.\ 5535 select_header_accept(['application/json']) 5536 5537 # Authentication setting 5538 auth_settings = [] 5539 5540 return self.api_client.call_api(resource_path, 'GET', 5541 path_params, 5542 query_params, 5543 header_params, 5544 body=body_params, 5545 post_params=form_params, 5546 files=local_var_files, 5547 response_type='CustomFields', 5548 auth_settings=auth_settings, 5549 callback=params.get('callback'), 5550 _return_http_data_only=params.get('_return_http_data_only'), 5551 _preload_content=params.get('_preload_content', True), 5552 _request_timeout=params.get('_request_timeout'), 5553 collection_formats=collection_formats) 5554 5555 def list_permissions(self, account_id, **kwargs): 5556 """ 5557 Gets a list of permission profiles. 5558 Retrieves a list of Permission Profiles. Permission Profiles are a standard set of user permissions that you can apply to individual users or users in a Group. This makes it easier to manage user permissions for a large number of users, without having to change permissions on a user-by-user basis. Currently, Permission Profiles can only be created and modified in the DocuSign console. 5559 This method makes a synchronous HTTP request by default. To make an 5560 asynchronous HTTP request, please define a `callback` function 5561 to be invoked when receiving the response. 5562 >>> def callback_function(response): 5563 >>> pprint(response) 5564 >>> 5565 >>> thread = api.list_permissions(account_id, callback=callback_function) 5566 5567 :param callback function: The callback function 5568 for asynchronous request. (optional) 5569 :param str account_id: The external account number (int) or account ID Guid. (required) 5570 :param str include: 5571 :return: PermissionProfileInformation 5572 If the method is called asynchronously, 5573 returns the request thread. 5574 """ 5575 kwargs['_return_http_data_only'] = True 5576 if kwargs.get('callback'): 5577 return self.list_permissions_with_http_info(account_id, **kwargs) 5578 else: 5579 (data) = self.list_permissions_with_http_info(account_id, **kwargs) 5580 return data 5581 5582 def list_permissions_with_http_info(self, account_id, **kwargs): 5583 """ 5584 Gets a list of permission profiles. 5585 Retrieves a list of Permission Profiles. Permission Profiles are a standard set of user permissions that you can apply to individual users or users in a Group. This makes it easier to manage user permissions for a large number of users, without having to change permissions on a user-by-user basis. Currently, Permission Profiles can only be created and modified in the DocuSign console. 5586 This method makes a synchronous HTTP request by default. To make an 5587 asynchronous HTTP request, please define a `callback` function 5588 to be invoked when receiving the response. 5589 >>> def callback_function(response): 5590 >>> pprint(response) 5591 >>> 5592 >>> thread = api.list_permissions_with_http_info(account_id, callback=callback_function) 5593 5594 :param callback function: The callback function 5595 for asynchronous request. (optional) 5596 :param str account_id: The external account number (int) or account ID Guid. (required) 5597 :param str include: 5598 :return: PermissionProfileInformation 5599 If the method is called asynchronously, 5600 returns the request thread. 5601 """ 5602 5603 all_params = ['account_id', 'include'] 5604 all_params.append('callback') 5605 all_params.append('_return_http_data_only') 5606 all_params.append('_preload_content') 5607 all_params.append('_request_timeout') 5608 5609 params = locals() 5610 for key, val in iteritems(params['kwargs']): 5611 if key not in all_params: 5612 raise TypeError( 5613 "Got an unexpected keyword argument '%s'" 5614 " to method list_permissions" % key 5615 ) 5616 params[key] = val 5617 del params['kwargs'] 5618 # verify the required parameter 'account_id' is set 5619 if ('account_id' not in params) or (params['account_id'] is None): 5620 raise ValueError("Missing the required parameter `account_id` when calling `list_permissions`") 5621 5622 5623 collection_formats = {} 5624 5625 resource_path = '/v2.1/accounts/{accountId}/permission_profiles'.replace('{format}', 'json') 5626 path_params = {} 5627 if 'account_id' in params: 5628 path_params['accountId'] = params['account_id'] 5629 5630 query_params = {} 5631 if 'include' in params: 5632 query_params['include'] = params['include'] 5633 5634 header_params = {} 5635 5636 form_params = [] 5637 local_var_files = {} 5638 5639 body_params = None 5640 # HTTP header `Accept` 5641 header_params['Accept'] = self.api_client.\ 5642 select_header_accept(['application/json']) 5643 5644 # Authentication setting 5645 auth_settings = [] 5646 5647 return self.api_client.call_api(resource_path, 'GET', 5648 path_params, 5649 query_params, 5650 header_params, 5651 body=body_params, 5652 post_params=form_params, 5653 files=local_var_files, 5654 response_type='PermissionProfileInformation', 5655 auth_settings=auth_settings, 5656 callback=params.get('callback'), 5657 _return_http_data_only=params.get('_return_http_data_only'), 5658 _preload_content=params.get('_preload_content', True), 5659 _request_timeout=params.get('_request_timeout'), 5660 collection_formats=collection_formats) 5661 5662 def list_recipient_names_by_email(self, account_id, **kwargs): 5663 """ 5664 Gets recipient names associated with an email address. 5665 Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string. 5666 This method makes a synchronous HTTP request by default. To make an 5667 asynchronous HTTP request, please define a `callback` function 5668 to be invoked when receiving the response. 5669 >>> def callback_function(response): 5670 >>> pprint(response) 5671 >>> 5672 >>> thread = api.list_recipient_names_by_email(account_id, callback=callback_function) 5673 5674 :param callback function: The callback function 5675 for asynchronous request. (optional) 5676 :param str account_id: The external account number (int) or account ID Guid. (required) 5677 :param str email: The email address for the user 5678 :return: RecipientNamesResponse 5679 If the method is called asynchronously, 5680 returns the request thread. 5681 """ 5682 kwargs['_return_http_data_only'] = True 5683 if kwargs.get('callback'): 5684 return self.list_recipient_names_by_email_with_http_info(account_id, **kwargs) 5685 else: 5686 (data) = self.list_recipient_names_by_email_with_http_info(account_id, **kwargs) 5687 return data 5688 5689 def list_recipient_names_by_email_with_http_info(self, account_id, **kwargs): 5690 """ 5691 Gets recipient names associated with an email address. 5692 Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string. 5693 This method makes a synchronous HTTP request by default. To make an 5694 asynchronous HTTP request, please define a `callback` function 5695 to be invoked when receiving the response. 5696 >>> def callback_function(response): 5697 >>> pprint(response) 5698 >>> 5699 >>> thread = api.list_recipient_names_by_email_with_http_info(account_id, callback=callback_function) 5700 5701 :param callback function: The callback function 5702 for asynchronous request. (optional) 5703 :param str account_id: The external account number (int) or account ID Guid. (required) 5704 :param str email: The email address for the user 5705 :return: RecipientNamesResponse 5706 If the method is called asynchronously, 5707 returns the request thread. 5708 """ 5709 5710 all_params = ['account_id', 'email'] 5711 all_params.append('callback') 5712 all_params.append('_return_http_data_only') 5713 all_params.append('_preload_content') 5714 all_params.append('_request_timeout') 5715 5716 params = locals() 5717 for key, val in iteritems(params['kwargs']): 5718 if key not in all_params: 5719 raise TypeError( 5720 "Got an unexpected keyword argument '%s'" 5721 " to method list_recipient_names_by_email" % key 5722 ) 5723 params[key] = val 5724 del params['kwargs'] 5725 # verify the required parameter 'account_id' is set 5726 if ('account_id' not in params) or (params['account_id'] is None): 5727 raise ValueError("Missing the required parameter `account_id` when calling `list_recipient_names_by_email`") 5728 5729 5730 collection_formats = {} 5731 5732 resource_path = '/v2.1/accounts/{accountId}/recipient_names'.replace('{format}', 'json') 5733 path_params = {} 5734 if 'account_id' in params: 5735 path_params['accountId'] = params['account_id'] 5736 5737 query_params = {} 5738 if 'email' in params: 5739 query_params['email'] = params['email'] 5740 5741 header_params = {} 5742 5743 form_params = [] 5744 local_var_files = {} 5745 5746 body_params = None 5747 # HTTP header `Accept` 5748 header_params['Accept'] = self.api_client.\ 5749 select_header_accept(['application/json']) 5750 5751 # Authentication setting 5752 auth_settings = [] 5753 5754 return self.api_client.call_api(resource_path, 'GET', 5755 path_params, 5756 query_params, 5757 header_params, 5758 body=body_params, 5759 post_params=form_params, 5760 files=local_var_files, 5761 response_type='RecipientNamesResponse', 5762 auth_settings=auth_settings, 5763 callback=params.get('callback'), 5764 _return_http_data_only=params.get('_return_http_data_only'), 5765 _preload_content=params.get('_preload_content', True), 5766 _request_timeout=params.get('_request_timeout'), 5767 collection_formats=collection_formats) 5768 5769 def list_settings(self, account_id, **kwargs): 5770 """ 5771 Gets account settings information. 5772 Retrieves the account settings information for the specified account. 5773 This method makes a synchronous HTTP request by default. To make an 5774 asynchronous HTTP request, please define a `callback` function 5775 to be invoked when receiving the response. 5776 >>> def callback_function(response): 5777 >>> pprint(response) 5778 >>> 5779 >>> thread = api.list_settings(account_id, callback=callback_function) 5780 5781 :param callback function: The callback function 5782 for asynchronous request. (optional) 5783 :param str account_id: The external account number (int) or account ID Guid. (required) 5784 :return: AccountSettingsInformation 5785 If the method is called asynchronously, 5786 returns the request thread. 5787 """ 5788 kwargs['_return_http_data_only'] = True 5789 if kwargs.get('callback'): 5790 return self.list_settings_with_http_info(account_id, **kwargs) 5791 else: 5792 (data) = self.list_settings_with_http_info(account_id, **kwargs) 5793 return data 5794 5795 def list_settings_with_http_info(self, account_id, **kwargs): 5796 """ 5797 Gets account settings information. 5798 Retrieves the account settings information for the specified account. 5799 This method makes a synchronous HTTP request by default. To make an 5800 asynchronous HTTP request, please define a `callback` function 5801 to be invoked when receiving the response. 5802 >>> def callback_function(response): 5803 >>> pprint(response) 5804 >>> 5805 >>> thread = api.list_settings_with_http_info(account_id, callback=callback_function) 5806 5807 :param callback function: The callback function 5808 for asynchronous request. (optional) 5809 :param str account_id: The external account number (int) or account ID Guid. (required) 5810 :return: AccountSettingsInformation 5811 If the method is called asynchronously, 5812 returns the request thread. 5813 """ 5814 5815 all_params = ['account_id'] 5816 all_params.append('callback') 5817 all_params.append('_return_http_data_only') 5818 all_params.append('_preload_content') 5819 all_params.append('_request_timeout') 5820 5821 params = locals() 5822 for key, val in iteritems(params['kwargs']): 5823 if key not in all_params: 5824 raise TypeError( 5825 "Got an unexpected keyword argument '%s'" 5826 " to method list_settings" % key 5827 ) 5828 params[key] = val 5829 del params['kwargs'] 5830 # verify the required parameter 'account_id' is set 5831 if ('account_id' not in params) or (params['account_id'] is None): 5832 raise ValueError("Missing the required parameter `account_id` when calling `list_settings`") 5833 5834 5835 collection_formats = {} 5836 5837 resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json') 5838 path_params = {} 5839 if 'account_id' in params: 5840 path_params['accountId'] = params['account_id'] 5841 5842 query_params = {} 5843 5844 header_params = {} 5845 5846 form_params = [] 5847 local_var_files = {} 5848 5849 body_params = None 5850 # HTTP header `Accept` 5851 header_params['Accept'] = self.api_client.\ 5852 select_header_accept(['application/json']) 5853 5854 # Authentication setting 5855 auth_settings = [] 5856 5857 return self.api_client.call_api(resource_path, 'GET', 5858 path_params, 5859 query_params, 5860 header_params, 5861 body=body_params, 5862 post_params=form_params, 5863 files=local_var_files, 5864 response_type='AccountSettingsInformation', 5865 auth_settings=auth_settings, 5866 callback=params.get('callback'), 5867 _return_http_data_only=params.get('_return_http_data_only'), 5868 _preload_content=params.get('_preload_content', True), 5869 _request_timeout=params.get('_request_timeout'), 5870 collection_formats=collection_formats) 5871 5872 def list_shared_access(self, account_id, **kwargs): 5873 """ 5874 Reserved: Gets the shared item status for one or more users. 5875 Reserved: Retrieves shared item status for one or more users and types of items. Users with account administration privileges can retrieve shared access information for all account users. Users without account administrator privileges can only retrieve shared access information for themselves and the returned information is limited to the retrieving the status of all members of the account that are sharing their folders to the user. This is equivalent to setting the shared=shared_from. 5876 This method makes a synchronous HTTP request by default. To make an 5877 asynchronous HTTP request, please define a `callback` function 5878 to be invoked when receiving the response. 5879 >>> def callback_function(response): 5880 >>> pprint(response) 5881 >>> 5882 >>> thread = api.list_shared_access(account_id, callback=callback_function) 5883 5884 :param callback function: The callback function 5885 for asynchronous request. (optional) 5886 :param str account_id: The external account number (int) or account ID Guid. (required) 5887 :param str count: Specifies maximum number of results included in the response. If no value is specified, this defaults to 1000. 5888 :param str envelopes_not_shared_user_status: 5889 :param str folder_ids: 5890 :param str item_type: Specifies the type of shared item being requested. The accepted values are: -envelopes: returns information about envelope sharing between users. 5891 :param str search_text: This can be used to filter user names in the response. The wild-card '*' (asterisk) can be used around the string. 5892 :param str shared: Specifies which users should be included in the response. Multiple values can be used in the query by using a comma separated list of shared values. If the requestor does not have account administrator privileges, the shared_to value is used. Requestors that do not have account administrator privileges can only use the shared_to, any other setting will result in an error. The accepted values are: -not_shared: Returns account users that the specified item type is not being shared with and that are not sharing the specified item type with the user. User X (Share) X Account user -shared_to: Returns account users that the specified item type is not being shared with and who are sharing the specified item type with the user (only shared to the user). User X (Share) Account user -shared_from: Returns account users that the specified item type is being shared with and who are not sharing the specified item type with the user (only shared from the user). User (Share) >> Account user -shared_to_and_from: Returns account users that the specified item type is being shared with and who are sharing the specified item type with the user. User << (Share) >> Account user 5893 :param str start_position: If the response set exceeds Count, this can be used to specify that the method should return users starting at the specified index. The first index is 0, and should be used in the first GET call. Typically this number is a multiple of Count. If no value is specified, this defaults to be 0. 5894 :param str user_ids: A comma separated list of userIds for whom the shared item information is being requested. 5895 :return: AccountSharedAccess 5896 If the method is called asynchronously, 5897 returns the request thread. 5898 """ 5899 kwargs['_return_http_data_only'] = True 5900 if kwargs.get('callback'): 5901 return self.list_shared_access_with_http_info(account_id, **kwargs) 5902 else: 5903 (data) = self.list_shared_access_with_http_info(account_id, **kwargs) 5904 return data 5905 5906 def list_shared_access_with_http_info(self, account_id, **kwargs): 5907 """ 5908 Reserved: Gets the shared item status for one or more users. 5909 Reserved: Retrieves shared item status for one or more users and types of items. Users with account administration privileges can retrieve shared access information for all account users. Users without account administrator privileges can only retrieve shared access information for themselves and the returned information is limited to the retrieving the status of all members of the account that are sharing their folders to the user. This is equivalent to setting the shared=shared_from. 5910 This method makes a synchronous HTTP request by default. To make an 5911 asynchronous HTTP request, please define a `callback` function 5912 to be invoked when receiving the response. 5913 >>> def callback_function(response): 5914 >>> pprint(response) 5915 >>> 5916 >>> thread = api.list_shared_access_with_http_info(account_id, callback=callback_function) 5917 5918 :param callback function: The callback function 5919 for asynchronous request. (optional) 5920 :param str account_id: The external account number (int) or account ID Guid. (required) 5921 :param str count: Specifies maximum number of results included in the response. If no value is specified, this defaults to 1000. 5922 :param str envelopes_not_shared_user_status: 5923 :param str folder_ids: 5924 :param str item_type: Specifies the type of shared item being requested. The accepted values are: -envelopes: returns information about envelope sharing between users. 5925 :param str search_text: This can be used to filter user names in the response. The wild-card '*' (asterisk) can be used around the string. 5926 :param str shared: Specifies which users should be included in the response. Multiple values can be used in the query by using a comma separated list of shared values. If the requestor does not have account administrator privileges, the shared_to value is used. Requestors that do not have account administrator privileges can only use the shared_to, any other setting will result in an error. The accepted values are: -not_shared: Returns account users that the specified item type is not being shared with and that are not sharing the specified item type with the user. User X (Share) X Account user -shared_to: Returns account users that the specified item type is not being shared with and who are sharing the specified item type with the user (only shared to the user). User X (Share) Account user -shared_from: Returns account users that the specified item type is being shared with and who are not sharing the specified item type with the user (only shared from the user). User (Share) >> Account user -shared_to_and_from: Returns account users that the specified item type is being shared with and who are sharing the specified item type with the user. User << (Share) >> Account user 5927 :param str start_position: If the response set exceeds Count, this can be used to specify that the method should return users starting at the specified index. The first index is 0, and should be used in the first GET call. Typically this number is a multiple of Count. If no value is specified, this defaults to be 0. 5928 :param str user_ids: A comma separated list of userIds for whom the shared item information is being requested. 5929 :return: AccountSharedAccess 5930 If the method is called asynchronously, 5931 returns the request thread. 5932 """ 5933 5934 all_params = ['account_id', 'count', 'envelopes_not_shared_user_status', 'folder_ids', 'item_type', 'search_text', 'shared', 'start_position', 'user_ids'] 5935 all_params.append('callback') 5936 all_params.append('_return_http_data_only') 5937 all_params.append('_preload_content') 5938 all_params.append('_request_timeout') 5939 5940 params = locals() 5941 for key, val in iteritems(params['kwargs']): 5942 if key not in all_params: 5943 raise TypeError( 5944 "Got an unexpected keyword argument '%s'" 5945 " to method list_shared_access" % key 5946 ) 5947 params[key] = val 5948 del params['kwargs'] 5949 # verify the required parameter 'account_id' is set 5950 if ('account_id' not in params) or (params['account_id'] is None): 5951 raise ValueError("Missing the required parameter `account_id` when calling `list_shared_access`") 5952 5953 5954 collection_formats = {} 5955 5956 resource_path = '/v2.1/accounts/{accountId}/shared_access'.replace('{format}', 'json') 5957 path_params = {} 5958 if 'account_id' in params: 5959 path_params['accountId'] = params['account_id'] 5960 5961 query_params = {} 5962 if 'count' in params: 5963 query_params['count'] = params['count'] 5964 if 'envelopes_not_shared_user_status' in params: 5965 query_params['envelopes_not_shared_user_status'] = params['envelopes_not_shared_user_status'] 5966 if 'folder_ids' in params: 5967 query_params['folder_ids'] = params['folder_ids'] 5968 if 'item_type' in params: 5969 query_params['item_type'] = params['item_type'] 5970 if 'search_text' in params: 5971 query_params['search_text'] = params['search_text'] 5972 if 'shared' in params: 5973 query_params['shared'] = params['shared'] 5974 if 'start_position' in params: 5975 query_params['start_position'] = params['start_position'] 5976 if 'user_ids' in params: 5977 query_params['user_ids'] = params['user_ids'] 5978 5979 header_params = {} 5980 5981 form_params = [] 5982 local_var_files = {} 5983 5984 body_params = None 5985 # HTTP header `Accept` 5986 header_params['Accept'] = self.api_client.\ 5987 select_header_accept(['application/json']) 5988 5989 # Authentication setting 5990 auth_settings = [] 5991 5992 return self.api_client.call_api(resource_path, 'GET', 5993 path_params, 5994 query_params, 5995 header_params, 5996 body=body_params, 5997 post_params=form_params, 5998 files=local_var_files, 5999 response_type='AccountSharedAccess', 6000 auth_settings=auth_settings, 6001 callback=params.get('callback'), 6002 _return_http_data_only=params.get('_return_http_data_only'), 6003 _preload_content=params.get('_preload_content', True), 6004 _request_timeout=params.get('_request_timeout'), 6005 collection_formats=collection_formats) 6006 6007 def list_signature_providers(self, account_id, **kwargs): 6008 """ 6009 Returns Account available signature providers for specified account. 6010 Returns a list of signature providers that the specified account can use. 6011 This method makes a synchronous HTTP request by default. To make an 6012 asynchronous HTTP request, please define a `callback` function 6013 to be invoked when receiving the response. 6014 >>> def callback_function(response): 6015 >>> pprint(response) 6016 >>> 6017 >>> thread = api.list_signature_providers(account_id, callback=callback_function) 6018 6019 :param callback function: The callback function 6020 for asynchronous request. (optional) 6021 :param str account_id: The external account number (int) or account ID Guid. (required) 6022 :return: AccountSignatureProviders 6023 If the method is called asynchronously, 6024 returns the request thread. 6025 """ 6026 kwargs['_return_http_data_only'] = True 6027 if kwargs.get('callback'): 6028 return self.list_signature_providers_with_http_info(account_id, **kwargs) 6029 else: 6030 (data) = self.list_signature_providers_with_http_info(account_id, **kwargs) 6031 return data 6032 6033 def list_signature_providers_with_http_info(self, account_id, **kwargs): 6034 """ 6035 Returns Account available signature providers for specified account. 6036 Returns a list of signature providers that the specified account can use. 6037 This method makes a synchronous HTTP request by default. To make an 6038 asynchronous HTTP request, please define a `callback` function 6039 to be invoked when receiving the response. 6040 >>> def callback_function(response): 6041 >>> pprint(response) 6042 >>> 6043 >>> thread = api.list_signature_providers_with_http_info(account_id, callback=callback_function) 6044 6045 :param callback function: The callback function 6046 for asynchronous request. (optional) 6047 :param str account_id: The external account number (int) or account ID Guid. (required) 6048 :return: AccountSignatureProviders 6049 If the method is called asynchronously, 6050 returns the request thread. 6051 """ 6052 6053 all_params = ['account_id'] 6054 all_params.append('callback') 6055 all_params.append('_return_http_data_only') 6056 all_params.append('_preload_content') 6057 all_params.append('_request_timeout') 6058 6059 params = locals() 6060 for key, val in iteritems(params['kwargs']): 6061 if key not in all_params: 6062 raise TypeError( 6063 "Got an unexpected keyword argument '%s'" 6064 " to method list_signature_providers" % key 6065 ) 6066 params[key] = val 6067 del params['kwargs'] 6068 # verify the required parameter 'account_id' is set 6069 if ('account_id' not in params) or (params['account_id'] is None): 6070 raise ValueError("Missing the required parameter `account_id` when calling `list_signature_providers`") 6071 6072 6073 collection_formats = {} 6074 6075 resource_path = '/v2.1/accounts/{accountId}/signatureProviders'.replace('{format}', 'json') 6076 path_params = {} 6077 if 'account_id' in params: 6078 path_params['accountId'] = params['account_id'] 6079 6080 query_params = {} 6081 6082 header_params = {} 6083 6084 form_params = [] 6085 local_var_files = {} 6086 6087 body_params = None 6088 # HTTP header `Accept` 6089 header_params['Accept'] = self.api_client.\ 6090 select_header_accept(['application/json']) 6091 6092 # Authentication setting 6093 auth_settings = [] 6094 6095 return self.api_client.call_api(resource_path, 'GET', 6096 path_params, 6097 query_params, 6098 header_params, 6099 body=body_params, 6100 post_params=form_params, 6101 files=local_var_files, 6102 response_type='AccountSignatureProviders', 6103 auth_settings=auth_settings, 6104 callback=params.get('callback'), 6105 _return_http_data_only=params.get('_return_http_data_only'), 6106 _preload_content=params.get('_preload_content', True), 6107 _request_timeout=params.get('_request_timeout'), 6108 collection_formats=collection_formats) 6109 6110 def list_unsupported_file_types(self, account_id, **kwargs): 6111 """ 6112 Gets a list of unsupported file types. 6113 Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system. 6114 This method makes a synchronous HTTP request by default. To make an 6115 asynchronous HTTP request, please define a `callback` function 6116 to be invoked when receiving the response. 6117 >>> def callback_function(response): 6118 >>> pprint(response) 6119 >>> 6120 >>> thread = api.list_unsupported_file_types(account_id, callback=callback_function) 6121 6122 :param callback function: The callback function 6123 for asynchronous request. (optional) 6124 :param str account_id: The external account number (int) or account ID Guid. (required) 6125 :return: FileTypeList 6126 If the method is called asynchronously, 6127 returns the request thread. 6128 """ 6129 kwargs['_return_http_data_only'] = True 6130 if kwargs.get('callback'): 6131 return self.list_unsupported_file_types_with_http_info(account_id, **kwargs) 6132 else: 6133 (data) = self.list_unsupported_file_types_with_http_info(account_id, **kwargs) 6134 return data 6135 6136 def list_unsupported_file_types_with_http_info(self, account_id, **kwargs): 6137 """ 6138 Gets a list of unsupported file types. 6139 Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system. 6140 This method makes a synchronous HTTP request by default. To make an 6141 asynchronous HTTP request, please define a `callback` function 6142 to be invoked when receiving the response. 6143 >>> def callback_function(response): 6144 >>> pprint(response) 6145 >>> 6146 >>> thread = api.list_unsupported_file_types_with_http_info(account_id, callback=callback_function) 6147 6148 :param callback function: The callback function 6149 for asynchronous request. (optional) 6150 :param str account_id: The external account number (int) or account ID Guid. (required) 6151 :return: FileTypeList 6152 If the method is called asynchronously, 6153 returns the request thread. 6154 """ 6155 6156 all_params = ['account_id'] 6157 all_params.append('callback') 6158 all_params.append('_return_http_data_only') 6159 all_params.append('_preload_content') 6160 all_params.append('_request_timeout') 6161 6162 params = locals() 6163 for key, val in iteritems(params['kwargs']): 6164 if key not in all_params: 6165 raise TypeError( 6166 "Got an unexpected keyword argument '%s'" 6167 " to method list_unsupported_file_types" % key 6168 ) 6169 params[key] = val 6170 del params['kwargs'] 6171 # verify the required parameter 'account_id' is set 6172 if ('account_id' not in params) or (params['account_id'] is None): 6173 raise ValueError("Missing the required parameter `account_id` when calling `list_unsupported_file_types`") 6174 6175 6176 collection_formats = {} 6177 6178 resource_path = '/v2.1/accounts/{accountId}/unsupported_file_types'.replace('{format}', 'json') 6179 path_params = {} 6180 if 'account_id' in params: 6181 path_params['accountId'] = params['account_id'] 6182 6183 query_params = {} 6184 6185 header_params = {} 6186 6187 form_params = [] 6188 local_var_files = {} 6189 6190 body_params = None 6191 # HTTP header `Accept` 6192 header_params['Accept'] = self.api_client.\ 6193 select_header_accept(['application/json']) 6194 6195 # Authentication setting 6196 auth_settings = [] 6197 6198 return self.api_client.call_api(resource_path, 'GET', 6199 path_params, 6200 query_params, 6201 header_params, 6202 body=body_params, 6203 post_params=form_params, 6204 files=local_var_files, 6205 response_type='FileTypeList', 6206 auth_settings=auth_settings, 6207 callback=params.get('callback'), 6208 _return_http_data_only=params.get('_return_http_data_only'), 6209 _preload_content=params.get('_preload_content', True), 6210 _request_timeout=params.get('_request_timeout'), 6211 collection_formats=collection_formats) 6212 6213 def un_favorite_template(self, account_id, **kwargs): 6214 """ 6215 Unfavorite a template 6216 6217 This method makes a synchronous HTTP request by default. To make an 6218 asynchronous HTTP request, please define a `callback` function 6219 to be invoked when receiving the response. 6220 >>> def callback_function(response): 6221 >>> pprint(response) 6222 >>> 6223 >>> thread = api.un_favorite_template(account_id, callback=callback_function) 6224 6225 :param callback function: The callback function 6226 for asynchronous request. (optional) 6227 :param str account_id: The external account number (int) or account ID Guid. (required) 6228 :param FavoriteTemplatesInfo favorite_templates_info: 6229 :return: FavoriteTemplatesInfo 6230 If the method is called asynchronously, 6231 returns the request thread. 6232 """ 6233 kwargs['_return_http_data_only'] = True 6234 if kwargs.get('callback'): 6235 return self.un_favorite_template_with_http_info(account_id, **kwargs) 6236 else: 6237 (data) = self.un_favorite_template_with_http_info(account_id, **kwargs) 6238 return data 6239 6240 def un_favorite_template_with_http_info(self, account_id, **kwargs): 6241 """ 6242 Unfavorite a template 6243 6244 This method makes a synchronous HTTP request by default. To make an 6245 asynchronous HTTP request, please define a `callback` function 6246 to be invoked when receiving the response. 6247 >>> def callback_function(response): 6248 >>> pprint(response) 6249 >>> 6250 >>> thread = api.un_favorite_template_with_http_info(account_id, callback=callback_function) 6251 6252 :param callback function: The callback function 6253 for asynchronous request. (optional) 6254 :param str account_id: The external account number (int) or account ID Guid. (required) 6255 :param FavoriteTemplatesInfo favorite_templates_info: 6256 :return: FavoriteTemplatesInfo 6257 If the method is called asynchronously, 6258 returns the request thread. 6259 """ 6260 6261 all_params = ['account_id', 'favorite_templates_info'] 6262 all_params.append('callback') 6263 all_params.append('_return_http_data_only') 6264 all_params.append('_preload_content') 6265 all_params.append('_request_timeout') 6266 6267 params = locals() 6268 for key, val in iteritems(params['kwargs']): 6269 if key not in all_params: 6270 raise TypeError( 6271 "Got an unexpected keyword argument '%s'" 6272 " to method un_favorite_template" % key 6273 ) 6274 params[key] = val 6275 del params['kwargs'] 6276 # verify the required parameter 'account_id' is set 6277 if ('account_id' not in params) or (params['account_id'] is None): 6278 raise ValueError("Missing the required parameter `account_id` when calling `un_favorite_template`") 6279 6280 6281 collection_formats = {} 6282 6283 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 6284 path_params = {} 6285 if 'account_id' in params: 6286 path_params['accountId'] = params['account_id'] 6287 6288 query_params = {} 6289 6290 header_params = {} 6291 6292 form_params = [] 6293 local_var_files = {} 6294 6295 body_params = None 6296 if 'favorite_templates_info' in params: 6297 body_params = params['favorite_templates_info'] 6298 # HTTP header `Accept` 6299 header_params['Accept'] = self.api_client.\ 6300 select_header_accept(['application/json']) 6301 6302 # Authentication setting 6303 auth_settings = [] 6304 6305 return self.api_client.call_api(resource_path, 'DELETE', 6306 path_params, 6307 query_params, 6308 header_params, 6309 body=body_params, 6310 post_params=form_params, 6311 files=local_var_files, 6312 response_type='FavoriteTemplatesInfo', 6313 auth_settings=auth_settings, 6314 callback=params.get('callback'), 6315 _return_http_data_only=params.get('_return_http_data_only'), 6316 _preload_content=params.get('_preload_content', True), 6317 _request_timeout=params.get('_request_timeout'), 6318 collection_formats=collection_formats) 6319 6320 def update_account_signature(self, account_id, **kwargs): 6321 """ 6322 Updates a account signature. 6323 6324 This method makes a synchronous HTTP request by default. To make an 6325 asynchronous HTTP request, please define a `callback` function 6326 to be invoked when receiving the response. 6327 >>> def callback_function(response): 6328 >>> pprint(response) 6329 >>> 6330 >>> thread = api.update_account_signature(account_id, callback=callback_function) 6331 6332 :param callback function: The callback function 6333 for asynchronous request. (optional) 6334 :param str account_id: The external account number (int) or account ID Guid. (required) 6335 :param AccountSignaturesInformation account_signatures_information: 6336 :return: AccountSignaturesInformation 6337 If the method is called asynchronously, 6338 returns the request thread. 6339 """ 6340 kwargs['_return_http_data_only'] = True 6341 if kwargs.get('callback'): 6342 return self.update_account_signature_with_http_info(account_id, **kwargs) 6343 else: 6344 (data) = self.update_account_signature_with_http_info(account_id, **kwargs) 6345 return data 6346 6347 def update_account_signature_with_http_info(self, account_id, **kwargs): 6348 """ 6349 Updates a account signature. 6350 6351 This method makes a synchronous HTTP request by default. To make an 6352 asynchronous HTTP request, please define a `callback` function 6353 to be invoked when receiving the response. 6354 >>> def callback_function(response): 6355 >>> pprint(response) 6356 >>> 6357 >>> thread = api.update_account_signature_with_http_info(account_id, callback=callback_function) 6358 6359 :param callback function: The callback function 6360 for asynchronous request. (optional) 6361 :param str account_id: The external account number (int) or account ID Guid. (required) 6362 :param AccountSignaturesInformation account_signatures_information: 6363 :return: AccountSignaturesInformation 6364 If the method is called asynchronously, 6365 returns the request thread. 6366 """ 6367 6368 all_params = ['account_id', 'account_signatures_information'] 6369 all_params.append('callback') 6370 all_params.append('_return_http_data_only') 6371 all_params.append('_preload_content') 6372 all_params.append('_request_timeout') 6373 6374 params = locals() 6375 for key, val in iteritems(params['kwargs']): 6376 if key not in all_params: 6377 raise TypeError( 6378 "Got an unexpected keyword argument '%s'" 6379 " to method update_account_signature" % key 6380 ) 6381 params[key] = val 6382 del params['kwargs'] 6383 # verify the required parameter 'account_id' is set 6384 if ('account_id' not in params) or (params['account_id'] is None): 6385 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature`") 6386 6387 6388 collection_formats = {} 6389 6390 resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json') 6391 path_params = {} 6392 if 'account_id' in params: 6393 path_params['accountId'] = params['account_id'] 6394 6395 query_params = {} 6396 6397 header_params = {} 6398 6399 form_params = [] 6400 local_var_files = {} 6401 6402 body_params = None 6403 if 'account_signatures_information' in params: 6404 body_params = params['account_signatures_information'] 6405 # HTTP header `Accept` 6406 header_params['Accept'] = self.api_client.\ 6407 select_header_accept(['application/json']) 6408 6409 # Authentication setting 6410 auth_settings = [] 6411 6412 return self.api_client.call_api(resource_path, 'PUT', 6413 path_params, 6414 query_params, 6415 header_params, 6416 body=body_params, 6417 post_params=form_params, 6418 files=local_var_files, 6419 response_type='AccountSignaturesInformation', 6420 auth_settings=auth_settings, 6421 callback=params.get('callback'), 6422 _return_http_data_only=params.get('_return_http_data_only'), 6423 _preload_content=params.get('_preload_content', True), 6424 _request_timeout=params.get('_request_timeout'), 6425 collection_formats=collection_formats) 6426 6427 def update_account_signature_by_id(self, account_id, signature_id, **kwargs): 6428 """ 6429 Updates a account signature. 6430 6431 This method makes a synchronous HTTP request by default. To make an 6432 asynchronous HTTP request, please define a `callback` function 6433 to be invoked when receiving the response. 6434 >>> def callback_function(response): 6435 >>> pprint(response) 6436 >>> 6437 >>> thread = api.update_account_signature_by_id(account_id, signature_id, callback=callback_function) 6438 6439 :param callback function: The callback function 6440 for asynchronous request. (optional) 6441 :param str account_id: The external account number (int) or account ID Guid. (required) 6442 :param str signature_id: The ID of the signature being accessed. (required) 6443 :param str close_existing_signature: 6444 :param AccountSignatureDefinition account_signature_definition: 6445 :return: AccountSignature 6446 If the method is called asynchronously, 6447 returns the request thread. 6448 """ 6449 kwargs['_return_http_data_only'] = True 6450 if kwargs.get('callback'): 6451 return self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs) 6452 else: 6453 (data) = self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs) 6454 return data 6455 6456 def update_account_signature_by_id_with_http_info(self, account_id, signature_id, **kwargs): 6457 """ 6458 Updates a account signature. 6459 6460 This method makes a synchronous HTTP request by default. To make an 6461 asynchronous HTTP request, please define a `callback` function 6462 to be invoked when receiving the response. 6463 >>> def callback_function(response): 6464 >>> pprint(response) 6465 >>> 6466 >>> thread = api.update_account_signature_by_id_with_http_info(account_id, signature_id, callback=callback_function) 6467 6468 :param callback function: The callback function 6469 for asynchronous request. (optional) 6470 :param str account_id: The external account number (int) or account ID Guid. (required) 6471 :param str signature_id: The ID of the signature being accessed. (required) 6472 :param str close_existing_signature: 6473 :param AccountSignatureDefinition account_signature_definition: 6474 :return: AccountSignature 6475 If the method is called asynchronously, 6476 returns the request thread. 6477 """ 6478 6479 all_params = ['account_id', 'signature_id', 'close_existing_signature', 'account_signature_definition'] 6480 all_params.append('callback') 6481 all_params.append('_return_http_data_only') 6482 all_params.append('_preload_content') 6483 all_params.append('_request_timeout') 6484 6485 params = locals() 6486 for key, val in iteritems(params['kwargs']): 6487 if key not in all_params: 6488 raise TypeError( 6489 "Got an unexpected keyword argument '%s'" 6490 " to method update_account_signature_by_id" % key 6491 ) 6492 params[key] = val 6493 del params['kwargs'] 6494 # verify the required parameter 'account_id' is set 6495 if ('account_id' not in params) or (params['account_id'] is None): 6496 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_by_id`") 6497 # verify the required parameter 'signature_id' is set 6498 if ('signature_id' not in params) or (params['signature_id'] is None): 6499 raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_by_id`") 6500 6501 6502 collection_formats = {} 6503 6504 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 6505 path_params = {} 6506 if 'account_id' in params: 6507 path_params['accountId'] = params['account_id'] 6508 if 'signature_id' in params: 6509 path_params['signatureId'] = params['signature_id'] 6510 6511 query_params = {} 6512 if 'close_existing_signature' in params: 6513 query_params['close_existing_signature'] = params['close_existing_signature'] 6514 6515 header_params = {} 6516 6517 form_params = [] 6518 local_var_files = {} 6519 6520 body_params = None 6521 if 'account_signature_definition' in params: 6522 body_params = params['account_signature_definition'] 6523 # HTTP header `Accept` 6524 header_params['Accept'] = self.api_client.\ 6525 select_header_accept(['application/json']) 6526 6527 # Authentication setting 6528 auth_settings = [] 6529 6530 return self.api_client.call_api(resource_path, 'PUT', 6531 path_params, 6532 query_params, 6533 header_params, 6534 body=body_params, 6535 post_params=form_params, 6536 files=local_var_files, 6537 response_type='AccountSignature', 6538 auth_settings=auth_settings, 6539 callback=params.get('callback'), 6540 _return_http_data_only=params.get('_return_http_data_only'), 6541 _preload_content=params.get('_preload_content', True), 6542 _request_timeout=params.get('_request_timeout'), 6543 collection_formats=collection_formats) 6544 6545 def update_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 6546 """ 6547 Sets a signature, initials, or stamps image. 6548 6549 This method makes a synchronous HTTP request by default. To make an 6550 asynchronous HTTP request, please define a `callback` function 6551 to be invoked when receiving the response. 6552 >>> def callback_function(response): 6553 >>> pprint(response) 6554 >>> 6555 >>> thread = api.update_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 6556 6557 :param callback function: The callback function 6558 for asynchronous request. (optional) 6559 :param str account_id: The external account number (int) or account ID Guid. (required) 6560 :param str image_type: One of **signature_image** or **initials_image**. (required) 6561 :param str signature_id: The ID of the signature being accessed. (required) 6562 :param str transparent_png: 6563 :return: AccountSignature 6564 If the method is called asynchronously, 6565 returns the request thread. 6566 """ 6567 kwargs['_return_http_data_only'] = True 6568 if kwargs.get('callback'): 6569 return self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 6570 else: 6571 (data) = self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 6572 return data 6573 6574 def update_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 6575 """ 6576 Sets a signature, initials, or stamps image. 6577 6578 This method makes a synchronous HTTP request by default. To make an 6579 asynchronous HTTP request, please define a `callback` function 6580 to be invoked when receiving the response. 6581 >>> def callback_function(response): 6582 >>> pprint(response) 6583 >>> 6584 >>> thread = api.update_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 6585 6586 :param callback function: The callback function 6587 for asynchronous request. (optional) 6588 :param str account_id: The external account number (int) or account ID Guid. (required) 6589 :param str image_type: One of **signature_image** or **initials_image**. (required) 6590 :param str signature_id: The ID of the signature being accessed. (required) 6591 :param str transparent_png: 6592 :return: AccountSignature 6593 If the method is called asynchronously, 6594 returns the request thread. 6595 """ 6596 6597 all_params = ['account_id', 'image_type', 'signature_id', 'transparent_png'] 6598 all_params.append('callback') 6599 all_params.append('_return_http_data_only') 6600 all_params.append('_preload_content') 6601 all_params.append('_request_timeout') 6602 6603 params = locals() 6604 for key, val in iteritems(params['kwargs']): 6605 if key not in all_params: 6606 raise TypeError( 6607 "Got an unexpected keyword argument '%s'" 6608 " to method update_account_signature_image" % key 6609 ) 6610 params[key] = val 6611 del params['kwargs'] 6612 # verify the required parameter 'account_id' is set 6613 if ('account_id' not in params) or (params['account_id'] is None): 6614 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_image`") 6615 # verify the required parameter 'image_type' is set 6616 if ('image_type' not in params) or (params['image_type'] is None): 6617 raise ValueError("Missing the required parameter `image_type` when calling `update_account_signature_image`") 6618 # verify the required parameter 'signature_id' is set 6619 if ('signature_id' not in params) or (params['signature_id'] is None): 6620 raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_image`") 6621 6622 6623 collection_formats = {} 6624 6625 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 6626 path_params = {} 6627 if 'account_id' in params: 6628 path_params['accountId'] = params['account_id'] 6629 if 'image_type' in params: 6630 path_params['imageType'] = params['image_type'] 6631 if 'signature_id' in params: 6632 path_params['signatureId'] = params['signature_id'] 6633 6634 query_params = {} 6635 if 'transparent_png' in params: 6636 query_params['transparent_png'] = params['transparent_png'] 6637 6638 header_params = {} 6639 6640 form_params = [] 6641 local_var_files = {} 6642 6643 body_params = None 6644 # HTTP header `Accept` 6645 header_params['Accept'] = self.api_client.\ 6646 select_header_accept(['application/json']) 6647 6648 # HTTP header `Content-Type` 6649 header_params['Content-Type'] = self.api_client.\ 6650 select_header_content_type(['image/gif']) 6651 6652 # Authentication setting 6653 auth_settings = [] 6654 6655 return self.api_client.call_api(resource_path, 'PUT', 6656 path_params, 6657 query_params, 6658 header_params, 6659 body=body_params, 6660 post_params=form_params, 6661 files=local_var_files, 6662 response_type='AccountSignature', 6663 auth_settings=auth_settings, 6664 callback=params.get('callback'), 6665 _return_http_data_only=params.get('_return_http_data_only'), 6666 _preload_content=params.get('_preload_content', True), 6667 _request_timeout=params.get('_request_timeout'), 6668 collection_formats=collection_formats) 6669 6670 def update_account_tab_settings(self, account_id, **kwargs): 6671 """ 6672 Modifies tab settings for specified account 6673 This method modifies the tab types and tab functionality that is enabled for an account. 6674 This method makes a synchronous HTTP request by default. To make an 6675 asynchronous HTTP request, please define a `callback` function 6676 to be invoked when receiving the response. 6677 >>> def callback_function(response): 6678 >>> pprint(response) 6679 >>> 6680 >>> thread = api.update_account_tab_settings(account_id, callback=callback_function) 6681 6682 :param callback function: The callback function 6683 for asynchronous request. (optional) 6684 :param str account_id: The external account number (int) or account ID Guid. (required) 6685 :param TabAccountSettings tab_account_settings: 6686 :return: TabAccountSettings 6687 If the method is called asynchronously, 6688 returns the request thread. 6689 """ 6690 kwargs['_return_http_data_only'] = True 6691 if kwargs.get('callback'): 6692 return self.update_account_tab_settings_with_http_info(account_id, **kwargs) 6693 else: 6694 (data) = self.update_account_tab_settings_with_http_info(account_id, **kwargs) 6695 return data 6696 6697 def update_account_tab_settings_with_http_info(self, account_id, **kwargs): 6698 """ 6699 Modifies tab settings for specified account 6700 This method modifies the tab types and tab functionality that is enabled for an account. 6701 This method makes a synchronous HTTP request by default. To make an 6702 asynchronous HTTP request, please define a `callback` function 6703 to be invoked when receiving the response. 6704 >>> def callback_function(response): 6705 >>> pprint(response) 6706 >>> 6707 >>> thread = api.update_account_tab_settings_with_http_info(account_id, callback=callback_function) 6708 6709 :param callback function: The callback function 6710 for asynchronous request. (optional) 6711 :param str account_id: The external account number (int) or account ID Guid. (required) 6712 :param TabAccountSettings tab_account_settings: 6713 :return: TabAccountSettings 6714 If the method is called asynchronously, 6715 returns the request thread. 6716 """ 6717 6718 all_params = ['account_id', 'tab_account_settings'] 6719 all_params.append('callback') 6720 all_params.append('_return_http_data_only') 6721 all_params.append('_preload_content') 6722 all_params.append('_request_timeout') 6723 6724 params = locals() 6725 for key, val in iteritems(params['kwargs']): 6726 if key not in all_params: 6727 raise TypeError( 6728 "Got an unexpected keyword argument '%s'" 6729 " to method update_account_tab_settings" % key 6730 ) 6731 params[key] = val 6732 del params['kwargs'] 6733 # verify the required parameter 'account_id' is set 6734 if ('account_id' not in params) or (params['account_id'] is None): 6735 raise ValueError("Missing the required parameter `account_id` when calling `update_account_tab_settings`") 6736 6737 6738 collection_formats = {} 6739 6740 resource_path = '/v2.1/accounts/{accountId}/settings/tabs'.replace('{format}', 'json') 6741 path_params = {} 6742 if 'account_id' in params: 6743 path_params['accountId'] = params['account_id'] 6744 6745 query_params = {} 6746 6747 header_params = {} 6748 6749 form_params = [] 6750 local_var_files = {} 6751 6752 body_params = None 6753 if 'tab_account_settings' in params: 6754 body_params = params['tab_account_settings'] 6755 # HTTP header `Accept` 6756 header_params['Accept'] = self.api_client.\ 6757 select_header_accept(['application/json']) 6758 6759 # Authentication setting 6760 auth_settings = [] 6761 6762 return self.api_client.call_api(resource_path, 'PUT', 6763 path_params, 6764 query_params, 6765 header_params, 6766 body=body_params, 6767 post_params=form_params, 6768 files=local_var_files, 6769 response_type='TabAccountSettings', 6770 auth_settings=auth_settings, 6771 callback=params.get('callback'), 6772 _return_http_data_only=params.get('_return_http_data_only'), 6773 _preload_content=params.get('_preload_content', True), 6774 _request_timeout=params.get('_request_timeout'), 6775 collection_formats=collection_formats) 6776 6777 def update_brand(self, account_id, brand_id, **kwargs): 6778 """ 6779 Updates an existing brand. 6780 This method updates an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 6781 This method makes a synchronous HTTP request by default. To make an 6782 asynchronous HTTP request, please define a `callback` function 6783 to be invoked when receiving the response. 6784 >>> def callback_function(response): 6785 >>> pprint(response) 6786 >>> 6787 >>> thread = api.update_brand(account_id, brand_id, callback=callback_function) 6788 6789 :param callback function: The callback function 6790 for asynchronous request. (optional) 6791 :param str account_id: The external account number (int) or account ID Guid. (required) 6792 :param str brand_id: The unique identifier of a brand. (required) 6793 :param str replace_brand: 6794 :param Brand brand: 6795 :return: Brand 6796 If the method is called asynchronously, 6797 returns the request thread. 6798 """ 6799 kwargs['_return_http_data_only'] = True 6800 if kwargs.get('callback'): 6801 return self.update_brand_with_http_info(account_id, brand_id, **kwargs) 6802 else: 6803 (data) = self.update_brand_with_http_info(account_id, brand_id, **kwargs) 6804 return data 6805 6806 def update_brand_with_http_info(self, account_id, brand_id, **kwargs): 6807 """ 6808 Updates an existing brand. 6809 This method updates an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 6810 This method makes a synchronous HTTP request by default. To make an 6811 asynchronous HTTP request, please define a `callback` function 6812 to be invoked when receiving the response. 6813 >>> def callback_function(response): 6814 >>> pprint(response) 6815 >>> 6816 >>> thread = api.update_brand_with_http_info(account_id, brand_id, callback=callback_function) 6817 6818 :param callback function: The callback function 6819 for asynchronous request. (optional) 6820 :param str account_id: The external account number (int) or account ID Guid. (required) 6821 :param str brand_id: The unique identifier of a brand. (required) 6822 :param str replace_brand: 6823 :param Brand brand: 6824 :return: Brand 6825 If the method is called asynchronously, 6826 returns the request thread. 6827 """ 6828 6829 all_params = ['account_id', 'brand_id', 'replace_brand', 'brand'] 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 update_brand" % 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 `update_brand`") 6847 # verify the required parameter 'brand_id' is set 6848 if ('brand_id' not in params) or (params['brand_id'] is None): 6849 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand`") 6850 6851 6852 collection_formats = {} 6853 6854 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 6855 path_params = {} 6856 if 'account_id' in params: 6857 path_params['accountId'] = params['account_id'] 6858 if 'brand_id' in params: 6859 path_params['brandId'] = params['brand_id'] 6860 6861 query_params = {} 6862 if 'replace_brand' in params: 6863 query_params['replace_brand'] = params['replace_brand'] 6864 6865 header_params = {} 6866 6867 form_params = [] 6868 local_var_files = {} 6869 6870 body_params = None 6871 if 'brand' in params: 6872 body_params = params['brand'] 6873 # HTTP header `Accept` 6874 header_params['Accept'] = self.api_client.\ 6875 select_header_accept(['application/json']) 6876 6877 # Authentication setting 6878 auth_settings = [] 6879 6880 return self.api_client.call_api(resource_path, 'PUT', 6881 path_params, 6882 query_params, 6883 header_params, 6884 body=body_params, 6885 post_params=form_params, 6886 files=local_var_files, 6887 response_type='Brand', 6888 auth_settings=auth_settings, 6889 callback=params.get('callback'), 6890 _return_http_data_only=params.get('_return_http_data_only'), 6891 _preload_content=params.get('_preload_content', True), 6892 _request_timeout=params.get('_request_timeout'), 6893 collection_formats=collection_formats) 6894 6895 def update_brand_logo_by_type(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs): 6896 """ 6897 Put one branding logo. 6898 This method updates a single brand logo. You pass in the new version of the resource in the `Content-Disposition` header. Example: `Content-Disposition: form-data; name=\"file\"; filename=\"logo.jpg\"` **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 6899 This method makes a synchronous HTTP request by default. To make an 6900 asynchronous HTTP request, please define a `callback` function 6901 to be invoked when receiving the response. 6902 >>> def callback_function(response): 6903 >>> pprint(response) 6904 >>> 6905 >>> thread = api.update_brand_logo_by_type(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function) 6906 6907 :param callback function: The callback function 6908 for asynchronous request. (optional) 6909 :param str account_id: The external account number (int) or account ID GUID. (required) 6910 :param str brand_id: The ID of the brand. (required) 6911 :param str logo_type: The type of logo. Valid values are: - `primary` - `secondary` - `email` (required) 6912 :param str logo_file_bytes: Brand logo binary Stream. Supported formats: JPG, GIF, PNG. Maximum file size: 300 KB. Recommended dimensions: 296 x 76 pixels (larger images will be resized). Changes may take up to one hour to display in all places (required) 6913 :return: None 6914 If the method is called asynchronously, 6915 returns the request thread. 6916 """ 6917 kwargs['_return_http_data_only'] = True 6918 if kwargs.get('callback'): 6919 return self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs) 6920 else: 6921 (data) = self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs) 6922 return data 6923 6924 def update_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs): 6925 """ 6926 Put one branding logo. 6927 This method updates a single brand logo. You pass in the new version of the resource in the `Content-Disposition` header. Example: `Content-Disposition: form-data; name=\"file\"; filename=\"logo.jpg\"` **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 6928 This method makes a synchronous HTTP request by default. To make an 6929 asynchronous HTTP request, please define a `callback` function 6930 to be invoked when receiving the response. 6931 >>> def callback_function(response): 6932 >>> pprint(response) 6933 >>> 6934 >>> thread = api.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function) 6935 6936 :param callback function: The callback function 6937 for asynchronous request. (optional) 6938 :param str account_id: The external account number (int) or account ID GUID. (required) 6939 :param str brand_id: The ID of the brand. (required) 6940 :param str logo_type: The type of logo. Valid values are: - `primary` - `secondary` - `email` (required) 6941 :param str logo_file_bytes: Brand logo binary Stream. Supported formats: JPG, GIF, PNG. Maximum file size: 300 KB. Recommended dimensions: 296 x 76 pixels (larger images will be resized). Changes may take up to one hour to display in all places (required) 6942 :return: None 6943 If the method is called asynchronously, 6944 returns the request thread. 6945 """ 6946 6947 all_params = ['account_id', 'brand_id', 'logo_type', 'logo_file_bytes'] 6948 all_params.append('callback') 6949 all_params.append('_return_http_data_only') 6950 all_params.append('_preload_content') 6951 all_params.append('_request_timeout') 6952 6953 params = locals() 6954 for key, val in iteritems(params['kwargs']): 6955 if key not in all_params: 6956 raise TypeError( 6957 "Got an unexpected keyword argument '%s'" 6958 " to method update_brand_logo_by_type" % key 6959 ) 6960 params[key] = val 6961 del params['kwargs'] 6962 # verify the required parameter 'account_id' is set 6963 if ('account_id' not in params) or (params['account_id'] is None): 6964 raise ValueError("Missing the required parameter `account_id` when calling `update_brand_logo_by_type`") 6965 # verify the required parameter 'brand_id' is set 6966 if ('brand_id' not in params) or (params['brand_id'] is None): 6967 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_logo_by_type`") 6968 # verify the required parameter 'logo_type' is set 6969 if ('logo_type' not in params) or (params['logo_type'] is None): 6970 raise ValueError("Missing the required parameter `logo_type` when calling `update_brand_logo_by_type`") 6971 # verify the required parameter 'logo_file_bytes' is set 6972 if ('logo_file_bytes' not in params) or (params['logo_file_bytes'] is None): 6973 raise ValueError("Missing the required parameter `logo_file_bytes` when calling `update_brand_logo_by_type`") 6974 6975 6976 collection_formats = {} 6977 6978 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 6979 path_params = {} 6980 if 'account_id' in params: 6981 path_params['accountId'] = params['account_id'] 6982 if 'brand_id' in params: 6983 path_params['brandId'] = params['brand_id'] 6984 if 'logo_type' in params: 6985 path_params['logoType'] = params['logo_type'] 6986 6987 query_params = {} 6988 6989 header_params = {} 6990 6991 form_params = [] 6992 local_var_files = {} 6993 6994 body_params = None 6995 if 'logo_file_bytes' in params: 6996 body_params = params['logo_file_bytes'] 6997 # HTTP header `Accept` 6998 header_params['Accept'] = self.api_client.\ 6999 select_header_accept(['application/json']) 7000 7001 # HTTP header `Content-Type` 7002 header_params['Content-Type'] = self.api_client.\ 7003 select_header_content_type(['image/png']) 7004 7005 # Authentication setting 7006 auth_settings = [] 7007 7008 return self.api_client.call_api(resource_path, 'PUT', 7009 path_params, 7010 query_params, 7011 header_params, 7012 body=body_params, 7013 post_params=form_params, 7014 files=local_var_files, 7015 response_type=None, 7016 auth_settings=auth_settings, 7017 callback=params.get('callback'), 7018 _return_http_data_only=params.get('_return_http_data_only'), 7019 _preload_content=params.get('_preload_content', True), 7020 _request_timeout=params.get('_request_timeout'), 7021 collection_formats=collection_formats) 7022 7023 def update_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, file_xml, **kwargs): 7024 """ 7025 Uploads a branding resource file. 7026 This method updates a branding resource file. You pass in the new version of the resource file in the `Content-Disposition` header. Example: `Content-Disposition: form-data; name=\"file\"; filename=\"DocuSign_SigningResource_4328673.xml\"` **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). **Important:** Customizing resource files is an advanced branding configuration option which can significantly impact your account, and should be done only by someone with expertise in XML and HTML. The master resource files are subject to change without notice. If you customize your resource files, after each release, DocuSign recommends you review any changes and update your custom files as needed. When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file. 7027 This method makes a synchronous HTTP request by default. To make an 7028 asynchronous HTTP request, please define a `callback` function 7029 to be invoked when receiving the response. 7030 >>> def callback_function(response): 7031 >>> pprint(response) 7032 >>> 7033 >>> thread = api.update_brand_resources_by_content_type(account_id, brand_id, resource_content_type, file_xml, callback=callback_function) 7034 7035 :param callback function: The callback function 7036 for asynchronous request. (optional) 7037 :param str account_id: The external account number (int) or account ID GUID. (required) 7038 :param str brand_id: The ID of the brand. (required) 7039 :param str resource_content_type: The type of brand resource file that you are updating. Valid values are: - `sending` - `signing` - `email` - `signing_captive` (required) 7040 :param file file_xml: Brand resource XML file. (required) 7041 :return: BrandResources 7042 If the method is called asynchronously, 7043 returns the request thread. 7044 """ 7045 kwargs['_return_http_data_only'] = True 7046 if kwargs.get('callback'): 7047 return self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs) 7048 else: 7049 (data) = self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs) 7050 return data 7051 7052 def update_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, file_xml, **kwargs): 7053 """ 7054 Uploads a branding resource file. 7055 This method updates a branding resource file. You pass in the new version of the resource file in the `Content-Disposition` header. Example: `Content-Disposition: form-data; name=\"file\"; filename=\"DocuSign_SigningResource_4328673.xml\"` **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). **Important:** Customizing resource files is an advanced branding configuration option which can significantly impact your account, and should be done only by someone with expertise in XML and HTML. The master resource files are subject to change without notice. If you customize your resource files, after each release, DocuSign recommends you review any changes and update your custom files as needed. When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file. 7056 This method makes a synchronous HTTP request by default. To make an 7057 asynchronous HTTP request, please define a `callback` function 7058 to be invoked when receiving the response. 7059 >>> def callback_function(response): 7060 >>> pprint(response) 7061 >>> 7062 >>> thread = api.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, callback=callback_function) 7063 7064 :param callback function: The callback function 7065 for asynchronous request. (optional) 7066 :param str account_id: The external account number (int) or account ID GUID. (required) 7067 :param str brand_id: The ID of the brand. (required) 7068 :param str resource_content_type: The type of brand resource file that you are updating. Valid values are: - `sending` - `signing` - `email` - `signing_captive` (required) 7069 :param file file_xml: Brand resource XML file. (required) 7070 :return: BrandResources 7071 If the method is called asynchronously, 7072 returns the request thread. 7073 """ 7074 7075 all_params = ['account_id', 'brand_id', 'resource_content_type', 'file_xml'] 7076 all_params.append('callback') 7077 all_params.append('_return_http_data_only') 7078 all_params.append('_preload_content') 7079 all_params.append('_request_timeout') 7080 7081 params = locals() 7082 for key, val in iteritems(params['kwargs']): 7083 if key not in all_params: 7084 raise TypeError( 7085 "Got an unexpected keyword argument '%s'" 7086 " to method update_brand_resources_by_content_type" % key 7087 ) 7088 params[key] = val 7089 del params['kwargs'] 7090 # verify the required parameter 'account_id' is set 7091 if ('account_id' not in params) or (params['account_id'] is None): 7092 raise ValueError("Missing the required parameter `account_id` when calling `update_brand_resources_by_content_type`") 7093 # verify the required parameter 'brand_id' is set 7094 if ('brand_id' not in params) or (params['brand_id'] is None): 7095 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_resources_by_content_type`") 7096 # verify the required parameter 'resource_content_type' is set 7097 if ('resource_content_type' not in params) or (params['resource_content_type'] is None): 7098 raise ValueError("Missing the required parameter `resource_content_type` when calling `update_brand_resources_by_content_type`") 7099 # verify the required parameter 'file_xml' is set 7100 if ('file_xml' not in params) or (params['file_xml'] is None): 7101 raise ValueError("Missing the required parameter `file_xml` when calling `update_brand_resources_by_content_type`") 7102 7103 7104 collection_formats = {} 7105 7106 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources/{resourceContentType}'.replace('{format}', 'json') 7107 path_params = {} 7108 if 'account_id' in params: 7109 path_params['accountId'] = params['account_id'] 7110 if 'brand_id' in params: 7111 path_params['brandId'] = params['brand_id'] 7112 if 'resource_content_type' in params: 7113 path_params['resourceContentType'] = params['resource_content_type'] 7114 7115 query_params = {} 7116 7117 header_params = {} 7118 7119 form_params = [] 7120 local_var_files = {} 7121 if 'file_xml' in params: 7122 local_var_files['file.xml'] = params['file_xml'] 7123 7124 body_params = None 7125 # HTTP header `Accept` 7126 header_params['Accept'] = self.api_client.\ 7127 select_header_accept(['application/json']) 7128 7129 # HTTP header `Content-Type` 7130 header_params['Content-Type'] = self.api_client.\ 7131 select_header_content_type(['multipart/form-data']) 7132 7133 # Authentication setting 7134 auth_settings = [] 7135 7136 return self.api_client.call_api(resource_path, 'PUT', 7137 path_params, 7138 query_params, 7139 header_params, 7140 body=body_params, 7141 post_params=form_params, 7142 files=local_var_files, 7143 response_type='BrandResources', 7144 auth_settings=auth_settings, 7145 callback=params.get('callback'), 7146 _return_http_data_only=params.get('_return_http_data_only'), 7147 _preload_content=params.get('_preload_content', True), 7148 _request_timeout=params.get('_request_timeout'), 7149 collection_formats=collection_formats) 7150 7151 def update_consumer_disclosure(self, account_id, lang_code, **kwargs): 7152 """ 7153 Update Consumer Disclosure. 7154 Account administrators can use this method to perform the following tasks: - Customize values in the default disclosure. - Switch to a custom disclosure that uses your own text and HTML formatting. - Change values in your existing consumer disclosure. To specify the signer language version of the disclosure that you are updating, use the optional `langCode` query parameter. **Note:** Only account administrators can use this method. Each time you change the disclosure content, all unsigned recipients of outstanding documents will be required to accept a new version. ## Updating the default disclosure When you update the default disclosure, you can edit all properties except for the following ones: - `accountEsignId`: This property is read-only. - `custom`: The default value is **false.** Editing this property causes the default disclosure to switch to a custom disclosure. - `esignAgreement`: This property is read-only. - `esignText`: You cannot edit this property when `custom` is set to **false.** The API returns a 200 OK HTTP response, but does not update the `esignText`. - Metadata properties: These properties are read-only. **Note:** The text of the default disclosure is always in English. ## Switching to a custom disclosure To switch to a custom disclosure, set the `custom` property to **true** and customize the value for the `eSignText` property. You can also edit all of the other properties except for the following ones: - `accountEsignId`: This property is read-only. - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only. **Note:** When you use a custom disclosure, you can create versions of it in different signer languages and se the `langCode` parameter to specify the signer language version that you are updating. **Important:** When you switch from a default to a custom disclosure, note the following information: - You will not be able to return to using the default disclosure. - Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use. ## Updating a custom disclosure When you update a custom disclosure, you can update all of the properties except for the following ones: - `accountEsignId`: This property is read-only. - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only. **Important:** Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use. 7155 This method makes a synchronous HTTP request by default. To make an 7156 asynchronous HTTP request, please define a `callback` function 7157 to be invoked when receiving the response. 7158 >>> def callback_function(response): 7159 >>> pprint(response) 7160 >>> 7161 >>> thread = api.update_consumer_disclosure(account_id, lang_code, callback=callback_function) 7162 7163 :param callback function: The callback function 7164 for asynchronous request. (optional) 7165 :param str account_id: The external account number (int) or account ID Guid. (required) 7166 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 7167 :param str include_metadata: 7168 :param ConsumerDisclosure consumer_disclosure: 7169 :return: ConsumerDisclosure 7170 If the method is called asynchronously, 7171 returns the request thread. 7172 """ 7173 kwargs['_return_http_data_only'] = True 7174 if kwargs.get('callback'): 7175 return self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 7176 else: 7177 (data) = self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 7178 return data 7179 7180 def update_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs): 7181 """ 7182 Update Consumer Disclosure. 7183 Account administrators can use this method to perform the following tasks: - Customize values in the default disclosure. - Switch to a custom disclosure that uses your own text and HTML formatting. - Change values in your existing consumer disclosure. To specify the signer language version of the disclosure that you are updating, use the optional `langCode` query parameter. **Note:** Only account administrators can use this method. Each time you change the disclosure content, all unsigned recipients of outstanding documents will be required to accept a new version. ## Updating the default disclosure When you update the default disclosure, you can edit all properties except for the following ones: - `accountEsignId`: This property is read-only. - `custom`: The default value is **false.** Editing this property causes the default disclosure to switch to a custom disclosure. - `esignAgreement`: This property is read-only. - `esignText`: You cannot edit this property when `custom` is set to **false.** The API returns a 200 OK HTTP response, but does not update the `esignText`. - Metadata properties: These properties are read-only. **Note:** The text of the default disclosure is always in English. ## Switching to a custom disclosure To switch to a custom disclosure, set the `custom` property to **true** and customize the value for the `eSignText` property. You can also edit all of the other properties except for the following ones: - `accountEsignId`: This property is read-only. - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only. **Note:** When you use a custom disclosure, you can create versions of it in different signer languages and se the `langCode` parameter to specify the signer language version that you are updating. **Important:** When you switch from a default to a custom disclosure, note the following information: - You will not be able to return to using the default disclosure. - Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use. ## Updating a custom disclosure When you update a custom disclosure, you can update all of the properties except for the following ones: - `accountEsignId`: This property is read-only. - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only. **Important:** Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use. 7184 This method makes a synchronous HTTP request by default. To make an 7185 asynchronous HTTP request, please define a `callback` function 7186 to be invoked when receiving the response. 7187 >>> def callback_function(response): 7188 >>> pprint(response) 7189 >>> 7190 >>> thread = api.update_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function) 7191 7192 :param callback function: The callback function 7193 for asynchronous request. (optional) 7194 :param str account_id: The external account number (int) or account ID Guid. (required) 7195 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 7196 :param str include_metadata: 7197 :param ConsumerDisclosure consumer_disclosure: 7198 :return: ConsumerDisclosure 7199 If the method is called asynchronously, 7200 returns the request thread. 7201 """ 7202 7203 all_params = ['account_id', 'lang_code', 'include_metadata', 'consumer_disclosure'] 7204 all_params.append('callback') 7205 all_params.append('_return_http_data_only') 7206 all_params.append('_preload_content') 7207 all_params.append('_request_timeout') 7208 7209 params = locals() 7210 for key, val in iteritems(params['kwargs']): 7211 if key not in all_params: 7212 raise TypeError( 7213 "Got an unexpected keyword argument '%s'" 7214 " to method update_consumer_disclosure" % key 7215 ) 7216 params[key] = val 7217 del params['kwargs'] 7218 # verify the required parameter 'account_id' is set 7219 if ('account_id' not in params) or (params['account_id'] is None): 7220 raise ValueError("Missing the required parameter `account_id` when calling `update_consumer_disclosure`") 7221 # verify the required parameter 'lang_code' is set 7222 if ('lang_code' not in params) or (params['lang_code'] is None): 7223 raise ValueError("Missing the required parameter `lang_code` when calling `update_consumer_disclosure`") 7224 7225 7226 collection_formats = {} 7227 7228 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 7229 path_params = {} 7230 if 'account_id' in params: 7231 path_params['accountId'] = params['account_id'] 7232 if 'lang_code' in params: 7233 path_params['langCode'] = params['lang_code'] 7234 7235 query_params = {} 7236 if 'include_metadata' in params: 7237 query_params['include_metadata'] = params['include_metadata'] 7238 7239 header_params = {} 7240 7241 form_params = [] 7242 local_var_files = {} 7243 7244 body_params = None 7245 if 'consumer_disclosure' in params: 7246 body_params = params['consumer_disclosure'] 7247 # HTTP header `Accept` 7248 header_params['Accept'] = self.api_client.\ 7249 select_header_accept(['application/json']) 7250 7251 # Authentication setting 7252 auth_settings = [] 7253 7254 return self.api_client.call_api(resource_path, 'PUT', 7255 path_params, 7256 query_params, 7257 header_params, 7258 body=body_params, 7259 post_params=form_params, 7260 files=local_var_files, 7261 response_type='ConsumerDisclosure', 7262 auth_settings=auth_settings, 7263 callback=params.get('callback'), 7264 _return_http_data_only=params.get('_return_http_data_only'), 7265 _preload_content=params.get('_preload_content', True), 7266 _request_timeout=params.get('_request_timeout'), 7267 collection_formats=collection_formats) 7268 7269 def update_custom_field(self, account_id, custom_field_id, **kwargs): 7270 """ 7271 Updates an existing account custom field. 7272 This method updates an existing account custom field. 7273 This method makes a synchronous HTTP request by default. To make an 7274 asynchronous HTTP request, please define a `callback` function 7275 to be invoked when receiving the response. 7276 >>> def callback_function(response): 7277 >>> pprint(response) 7278 >>> 7279 >>> thread = api.update_custom_field(account_id, custom_field_id, callback=callback_function) 7280 7281 :param callback function: The callback function 7282 for asynchronous request. (optional) 7283 :param str account_id: The external account number (int) or account ID Guid. (required) 7284 :param str custom_field_id: (required) 7285 :param str apply_to_templates: 7286 :param CustomField custom_field: 7287 :return: CustomFields 7288 If the method is called asynchronously, 7289 returns the request thread. 7290 """ 7291 kwargs['_return_http_data_only'] = True 7292 if kwargs.get('callback'): 7293 return self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 7294 else: 7295 (data) = self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 7296 return data 7297 7298 def update_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs): 7299 """ 7300 Updates an existing account custom field. 7301 This method updates an existing account custom field. 7302 This method makes a synchronous HTTP request by default. To make an 7303 asynchronous HTTP request, please define a `callback` function 7304 to be invoked when receiving the response. 7305 >>> def callback_function(response): 7306 >>> pprint(response) 7307 >>> 7308 >>> thread = api.update_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function) 7309 7310 :param callback function: The callback function 7311 for asynchronous request. (optional) 7312 :param str account_id: The external account number (int) or account ID Guid. (required) 7313 :param str custom_field_id: (required) 7314 :param str apply_to_templates: 7315 :param CustomField custom_field: 7316 :return: CustomFields 7317 If the method is called asynchronously, 7318 returns the request thread. 7319 """ 7320 7321 all_params = ['account_id', 'custom_field_id', 'apply_to_templates', 'custom_field'] 7322 all_params.append('callback') 7323 all_params.append('_return_http_data_only') 7324 all_params.append('_preload_content') 7325 all_params.append('_request_timeout') 7326 7327 params = locals() 7328 for key, val in iteritems(params['kwargs']): 7329 if key not in all_params: 7330 raise TypeError( 7331 "Got an unexpected keyword argument '%s'" 7332 " to method update_custom_field" % key 7333 ) 7334 params[key] = val 7335 del params['kwargs'] 7336 # verify the required parameter 'account_id' is set 7337 if ('account_id' not in params) or (params['account_id'] is None): 7338 raise ValueError("Missing the required parameter `account_id` when calling `update_custom_field`") 7339 # verify the required parameter 'custom_field_id' is set 7340 if ('custom_field_id' not in params) or (params['custom_field_id'] is None): 7341 raise ValueError("Missing the required parameter `custom_field_id` when calling `update_custom_field`") 7342 7343 7344 collection_formats = {} 7345 7346 resource_path = '/v2.1/accounts/{accountId}/custom_fields/{customFieldId}'.replace('{format}', 'json') 7347 path_params = {} 7348 if 'account_id' in params: 7349 path_params['accountId'] = params['account_id'] 7350 if 'custom_field_id' in params: 7351 path_params['customFieldId'] = params['custom_field_id'] 7352 7353 query_params = {} 7354 if 'apply_to_templates' in params: 7355 query_params['apply_to_templates'] = params['apply_to_templates'] 7356 7357 header_params = {} 7358 7359 form_params = [] 7360 local_var_files = {} 7361 7362 body_params = None 7363 if 'custom_field' in params: 7364 body_params = params['custom_field'] 7365 # HTTP header `Accept` 7366 header_params['Accept'] = self.api_client.\ 7367 select_header_accept(['application/json']) 7368 7369 # Authentication setting 7370 auth_settings = [] 7371 7372 return self.api_client.call_api(resource_path, 'PUT', 7373 path_params, 7374 query_params, 7375 header_params, 7376 body=body_params, 7377 post_params=form_params, 7378 files=local_var_files, 7379 response_type='CustomFields', 7380 auth_settings=auth_settings, 7381 callback=params.get('callback'), 7382 _return_http_data_only=params.get('_return_http_data_only'), 7383 _preload_content=params.get('_preload_content', True), 7384 _request_timeout=params.get('_request_timeout'), 7385 collection_formats=collection_formats) 7386 7387 def update_e_note_configuration(self, account_id, **kwargs): 7388 """ 7389 Updates configuration information for the eNote eOriginal integration. 7390 7391 This method makes a synchronous HTTP request by default. To make an 7392 asynchronous HTTP request, please define a `callback` function 7393 to be invoked when receiving the response. 7394 >>> def callback_function(response): 7395 >>> pprint(response) 7396 >>> 7397 >>> thread = api.update_e_note_configuration(account_id, callback=callback_function) 7398 7399 :param callback function: The callback function 7400 for asynchronous request. (optional) 7401 :param str account_id: The external account number (int) or account ID Guid. (required) 7402 :param ENoteConfiguration e_note_configuration: 7403 :return: ENoteConfiguration 7404 If the method is called asynchronously, 7405 returns the request thread. 7406 """ 7407 kwargs['_return_http_data_only'] = True 7408 if kwargs.get('callback'): 7409 return self.update_e_note_configuration_with_http_info(account_id, **kwargs) 7410 else: 7411 (data) = self.update_e_note_configuration_with_http_info(account_id, **kwargs) 7412 return data 7413 7414 def update_e_note_configuration_with_http_info(self, account_id, **kwargs): 7415 """ 7416 Updates configuration information for the eNote eOriginal integration. 7417 7418 This method makes a synchronous HTTP request by default. To make an 7419 asynchronous HTTP request, please define a `callback` function 7420 to be invoked when receiving the response. 7421 >>> def callback_function(response): 7422 >>> pprint(response) 7423 >>> 7424 >>> thread = api.update_e_note_configuration_with_http_info(account_id, callback=callback_function) 7425 7426 :param callback function: The callback function 7427 for asynchronous request. (optional) 7428 :param str account_id: The external account number (int) or account ID Guid. (required) 7429 :param ENoteConfiguration e_note_configuration: 7430 :return: ENoteConfiguration 7431 If the method is called asynchronously, 7432 returns the request thread. 7433 """ 7434 7435 all_params = ['account_id', 'e_note_configuration'] 7436 all_params.append('callback') 7437 all_params.append('_return_http_data_only') 7438 all_params.append('_preload_content') 7439 all_params.append('_request_timeout') 7440 7441 params = locals() 7442 for key, val in iteritems(params['kwargs']): 7443 if key not in all_params: 7444 raise TypeError( 7445 "Got an unexpected keyword argument '%s'" 7446 " to method update_e_note_configuration" % key 7447 ) 7448 params[key] = val 7449 del params['kwargs'] 7450 # verify the required parameter 'account_id' is set 7451 if ('account_id' not in params) or (params['account_id'] is None): 7452 raise ValueError("Missing the required parameter `account_id` when calling `update_e_note_configuration`") 7453 7454 7455 collection_formats = {} 7456 7457 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 7458 path_params = {} 7459 if 'account_id' in params: 7460 path_params['accountId'] = params['account_id'] 7461 7462 query_params = {} 7463 7464 header_params = {} 7465 7466 form_params = [] 7467 local_var_files = {} 7468 7469 body_params = None 7470 if 'e_note_configuration' in params: 7471 body_params = params['e_note_configuration'] 7472 # HTTP header `Accept` 7473 header_params['Accept'] = self.api_client.\ 7474 select_header_accept(['application/json']) 7475 7476 # Authentication setting 7477 auth_settings = [] 7478 7479 return self.api_client.call_api(resource_path, 'PUT', 7480 path_params, 7481 query_params, 7482 header_params, 7483 body=body_params, 7484 post_params=form_params, 7485 files=local_var_files, 7486 response_type='ENoteConfiguration', 7487 auth_settings=auth_settings, 7488 callback=params.get('callback'), 7489 _return_http_data_only=params.get('_return_http_data_only'), 7490 _preload_content=params.get('_preload_content', True), 7491 _request_timeout=params.get('_request_timeout'), 7492 collection_formats=collection_formats) 7493 7494 def update_envelope_purge_configuration(self, account_id, **kwargs): 7495 """ 7496 Updates envelope purge configuration. 7497 An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method sets the envelope purge configuration for your account. **Note:** To use this method, you must be an account administrator. For more information, see [Purge Envelopes](https://support.docusign.com/en/guides/ndse-user-guide-purge-envelopes). 7498 This method makes a synchronous HTTP request by default. To make an 7499 asynchronous HTTP request, please define a `callback` function 7500 to be invoked when receiving the response. 7501 >>> def callback_function(response): 7502 >>> pprint(response) 7503 >>> 7504 >>> thread = api.update_envelope_purge_configuration(account_id, callback=callback_function) 7505 7506 :param callback function: The callback function 7507 for asynchronous request. (optional) 7508 :param str account_id: The external account number (int) or account ID Guid. (required) 7509 :param EnvelopePurgeConfiguration envelope_purge_configuration: 7510 :return: EnvelopePurgeConfiguration 7511 If the method is called asynchronously, 7512 returns the request thread. 7513 """ 7514 kwargs['_return_http_data_only'] = True 7515 if kwargs.get('callback'): 7516 return self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs) 7517 else: 7518 (data) = self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs) 7519 return data 7520 7521 def update_envelope_purge_configuration_with_http_info(self, account_id, **kwargs): 7522 """ 7523 Updates envelope purge configuration. 7524 An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method sets the envelope purge configuration for your account. **Note:** To use this method, you must be an account administrator. For more information, see [Purge Envelopes](https://support.docusign.com/en/guides/ndse-user-guide-purge-envelopes). 7525 This method makes a synchronous HTTP request by default. To make an 7526 asynchronous HTTP request, please define a `callback` function 7527 to be invoked when receiving the response. 7528 >>> def callback_function(response): 7529 >>> pprint(response) 7530 >>> 7531 >>> thread = api.update_envelope_purge_configuration_with_http_info(account_id, callback=callback_function) 7532 7533 :param callback function: The callback function 7534 for asynchronous request. (optional) 7535 :param str account_id: The external account number (int) or account ID Guid. (required) 7536 :param EnvelopePurgeConfiguration envelope_purge_configuration: 7537 :return: EnvelopePurgeConfiguration 7538 If the method is called asynchronously, 7539 returns the request thread. 7540 """ 7541 7542 all_params = ['account_id', 'envelope_purge_configuration'] 7543 all_params.append('callback') 7544 all_params.append('_return_http_data_only') 7545 all_params.append('_preload_content') 7546 all_params.append('_request_timeout') 7547 7548 params = locals() 7549 for key, val in iteritems(params['kwargs']): 7550 if key not in all_params: 7551 raise TypeError( 7552 "Got an unexpected keyword argument '%s'" 7553 " to method update_envelope_purge_configuration" % key 7554 ) 7555 params[key] = val 7556 del params['kwargs'] 7557 # verify the required parameter 'account_id' is set 7558 if ('account_id' not in params) or (params['account_id'] is None): 7559 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_purge_configuration`") 7560 7561 7562 collection_formats = {} 7563 7564 resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json') 7565 path_params = {} 7566 if 'account_id' in params: 7567 path_params['accountId'] = params['account_id'] 7568 7569 query_params = {} 7570 7571 header_params = {} 7572 7573 form_params = [] 7574 local_var_files = {} 7575 7576 body_params = None 7577 if 'envelope_purge_configuration' in params: 7578 body_params = params['envelope_purge_configuration'] 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, 'PUT', 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='EnvelopePurgeConfiguration', 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 update_favorite_template(self, account_id, **kwargs): 7602 """ 7603 Favorites a template 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.update_favorite_template(account_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 FavoriteTemplatesInfo favorite_templates_info: 7617 :return: FavoriteTemplatesInfo 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.update_favorite_template_with_http_info(account_id, **kwargs) 7624 else: 7625 (data) = self.update_favorite_template_with_http_info(account_id, **kwargs) 7626 return data 7627 7628 def update_favorite_template_with_http_info(self, account_id, **kwargs): 7629 """ 7630 Favorites a template 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.update_favorite_template_with_http_info(account_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 FavoriteTemplatesInfo favorite_templates_info: 7644 :return: FavoriteTemplatesInfo 7645 If the method is called asynchronously, 7646 returns the request thread. 7647 """ 7648 7649 all_params = ['account_id', 'favorite_templates_info'] 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 update_favorite_template" % 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 `update_favorite_template`") 7667 7668 7669 collection_formats = {} 7670 7671 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 7672 path_params = {} 7673 if 'account_id' in params: 7674 path_params['accountId'] = params['account_id'] 7675 7676 query_params = {} 7677 7678 header_params = {} 7679 7680 form_params = [] 7681 local_var_files = {} 7682 7683 body_params = None 7684 if 'favorite_templates_info' in params: 7685 body_params = params['favorite_templates_info'] 7686 # HTTP header `Accept` 7687 header_params['Accept'] = self.api_client.\ 7688 select_header_accept(['application/json']) 7689 7690 # Authentication setting 7691 auth_settings = [] 7692 7693 return self.api_client.call_api(resource_path, 'PUT', 7694 path_params, 7695 query_params, 7696 header_params, 7697 body=body_params, 7698 post_params=form_params, 7699 files=local_var_files, 7700 response_type='FavoriteTemplatesInfo', 7701 auth_settings=auth_settings, 7702 callback=params.get('callback'), 7703 _return_http_data_only=params.get('_return_http_data_only'), 7704 _preload_content=params.get('_preload_content', True), 7705 _request_timeout=params.get('_request_timeout'), 7706 collection_formats=collection_formats) 7707 7708 def update_notification_defaults(self, account_id, **kwargs): 7709 """ 7710 Updates default user level settings for a specified account 7711 This method changes the default settings for the email notifications that signers and senders receive about envelopes. 7712 This method makes a synchronous HTTP request by default. To make an 7713 asynchronous HTTP request, please define a `callback` function 7714 to be invoked when receiving the response. 7715 >>> def callback_function(response): 7716 >>> pprint(response) 7717 >>> 7718 >>> thread = api.update_notification_defaults(account_id, callback=callback_function) 7719 7720 :param callback function: The callback function 7721 for asynchronous request. (optional) 7722 :param str account_id: The external account number (int) or account ID Guid. (required) 7723 :param NotificationDefaults notification_defaults: 7724 :return: NotificationDefaults 7725 If the method is called asynchronously, 7726 returns the request thread. 7727 """ 7728 kwargs['_return_http_data_only'] = True 7729 if kwargs.get('callback'): 7730 return self.update_notification_defaults_with_http_info(account_id, **kwargs) 7731 else: 7732 (data) = self.update_notification_defaults_with_http_info(account_id, **kwargs) 7733 return data 7734 7735 def update_notification_defaults_with_http_info(self, account_id, **kwargs): 7736 """ 7737 Updates default user level settings for a specified account 7738 This method changes the default settings for the email notifications that signers and senders receive about envelopes. 7739 This method makes a synchronous HTTP request by default. To make an 7740 asynchronous HTTP request, please define a `callback` function 7741 to be invoked when receiving the response. 7742 >>> def callback_function(response): 7743 >>> pprint(response) 7744 >>> 7745 >>> thread = api.update_notification_defaults_with_http_info(account_id, callback=callback_function) 7746 7747 :param callback function: The callback function 7748 for asynchronous request. (optional) 7749 :param str account_id: The external account number (int) or account ID Guid. (required) 7750 :param NotificationDefaults notification_defaults: 7751 :return: NotificationDefaults 7752 If the method is called asynchronously, 7753 returns the request thread. 7754 """ 7755 7756 all_params = ['account_id', 'notification_defaults'] 7757 all_params.append('callback') 7758 all_params.append('_return_http_data_only') 7759 all_params.append('_preload_content') 7760 all_params.append('_request_timeout') 7761 7762 params = locals() 7763 for key, val in iteritems(params['kwargs']): 7764 if key not in all_params: 7765 raise TypeError( 7766 "Got an unexpected keyword argument '%s'" 7767 " to method update_notification_defaults" % key 7768 ) 7769 params[key] = val 7770 del params['kwargs'] 7771 # verify the required parameter 'account_id' is set 7772 if ('account_id' not in params) or (params['account_id'] is None): 7773 raise ValueError("Missing the required parameter `account_id` when calling `update_notification_defaults`") 7774 7775 7776 collection_formats = {} 7777 7778 resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json') 7779 path_params = {} 7780 if 'account_id' in params: 7781 path_params['accountId'] = params['account_id'] 7782 7783 query_params = {} 7784 7785 header_params = {} 7786 7787 form_params = [] 7788 local_var_files = {} 7789 7790 body_params = None 7791 if 'notification_defaults' in params: 7792 body_params = params['notification_defaults'] 7793 # HTTP header `Accept` 7794 header_params['Accept'] = self.api_client.\ 7795 select_header_accept(['application/json']) 7796 7797 # Authentication setting 7798 auth_settings = [] 7799 7800 return self.api_client.call_api(resource_path, 'PUT', 7801 path_params, 7802 query_params, 7803 header_params, 7804 body=body_params, 7805 post_params=form_params, 7806 files=local_var_files, 7807 response_type='NotificationDefaults', 7808 auth_settings=auth_settings, 7809 callback=params.get('callback'), 7810 _return_http_data_only=params.get('_return_http_data_only'), 7811 _preload_content=params.get('_preload_content', True), 7812 _request_timeout=params.get('_request_timeout'), 7813 collection_formats=collection_formats) 7814 7815 def update_password_rules(self, account_id, **kwargs): 7816 """ 7817 Update the password rules 7818 This method updates the password rules for an account. **Note:** To update the password rules for an account, you must be an account administrator. 7819 This method makes a synchronous HTTP request by default. To make an 7820 asynchronous HTTP request, please define a `callback` function 7821 to be invoked when receiving the response. 7822 >>> def callback_function(response): 7823 >>> pprint(response) 7824 >>> 7825 >>> thread = api.update_password_rules(account_id, callback=callback_function) 7826 7827 :param callback function: The callback function 7828 for asynchronous request. (optional) 7829 :param str account_id: The external account number (int) or account ID Guid. (required) 7830 :param AccountPasswordRules account_password_rules: 7831 :return: AccountPasswordRules 7832 If the method is called asynchronously, 7833 returns the request thread. 7834 """ 7835 kwargs['_return_http_data_only'] = True 7836 if kwargs.get('callback'): 7837 return self.update_password_rules_with_http_info(account_id, **kwargs) 7838 else: 7839 (data) = self.update_password_rules_with_http_info(account_id, **kwargs) 7840 return data 7841 7842 def update_password_rules_with_http_info(self, account_id, **kwargs): 7843 """ 7844 Update the password rules 7845 This method updates the password rules for an account. **Note:** To update the password rules for an account, you must be an account administrator. 7846 This method makes a synchronous HTTP request by default. To make an 7847 asynchronous HTTP request, please define a `callback` function 7848 to be invoked when receiving the response. 7849 >>> def callback_function(response): 7850 >>> pprint(response) 7851 >>> 7852 >>> thread = api.update_password_rules_with_http_info(account_id, callback=callback_function) 7853 7854 :param callback function: The callback function 7855 for asynchronous request. (optional) 7856 :param str account_id: The external account number (int) or account ID Guid. (required) 7857 :param AccountPasswordRules account_password_rules: 7858 :return: AccountPasswordRules 7859 If the method is called asynchronously, 7860 returns the request thread. 7861 """ 7862 7863 all_params = ['account_id', 'account_password_rules'] 7864 all_params.append('callback') 7865 all_params.append('_return_http_data_only') 7866 all_params.append('_preload_content') 7867 all_params.append('_request_timeout') 7868 7869 params = locals() 7870 for key, val in iteritems(params['kwargs']): 7871 if key not in all_params: 7872 raise TypeError( 7873 "Got an unexpected keyword argument '%s'" 7874 " to method update_password_rules" % key 7875 ) 7876 params[key] = val 7877 del params['kwargs'] 7878 # verify the required parameter 'account_id' is set 7879 if ('account_id' not in params) or (params['account_id'] is None): 7880 raise ValueError("Missing the required parameter `account_id` when calling `update_password_rules`") 7881 7882 7883 collection_formats = {} 7884 7885 resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json') 7886 path_params = {} 7887 if 'account_id' in params: 7888 path_params['accountId'] = params['account_id'] 7889 7890 query_params = {} 7891 7892 header_params = {} 7893 7894 form_params = [] 7895 local_var_files = {} 7896 7897 body_params = None 7898 if 'account_password_rules' in params: 7899 body_params = params['account_password_rules'] 7900 # HTTP header `Accept` 7901 header_params['Accept'] = self.api_client.\ 7902 select_header_accept(['application/json']) 7903 7904 # Authentication setting 7905 auth_settings = [] 7906 7907 return self.api_client.call_api(resource_path, 'PUT', 7908 path_params, 7909 query_params, 7910 header_params, 7911 body=body_params, 7912 post_params=form_params, 7913 files=local_var_files, 7914 response_type='AccountPasswordRules', 7915 auth_settings=auth_settings, 7916 callback=params.get('callback'), 7917 _return_http_data_only=params.get('_return_http_data_only'), 7918 _preload_content=params.get('_preload_content', True), 7919 _request_timeout=params.get('_request_timeout'), 7920 collection_formats=collection_formats) 7921 7922 def update_permission_profile(self, account_id, permission_profile_id, **kwargs): 7923 """ 7924 Updates a permission profile within the specified account. 7925 This method updates an account permission profile. ### Related topics - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 7926 This method makes a synchronous HTTP request by default. To make an 7927 asynchronous HTTP request, please define a `callback` function 7928 to be invoked when receiving the response. 7929 >>> def callback_function(response): 7930 >>> pprint(response) 7931 >>> 7932 >>> thread = api.update_permission_profile(account_id, permission_profile_id, callback=callback_function) 7933 7934 :param callback function: The callback function 7935 for asynchronous request. (optional) 7936 :param str account_id: The external account number (int) or account ID Guid. (required) 7937 :param str permission_profile_id: (required) 7938 :param str include: 7939 :param PermissionProfile permission_profile: 7940 :return: PermissionProfile 7941 If the method is called asynchronously, 7942 returns the request thread. 7943 """ 7944 kwargs['_return_http_data_only'] = True 7945 if kwargs.get('callback'): 7946 return self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 7947 else: 7948 (data) = self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 7949 return data 7950 7951 def update_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 7952 """ 7953 Updates a permission profile within the specified account. 7954 This method updates an account permission profile. ### Related topics - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 7955 This method makes a synchronous HTTP request by default. To make an 7956 asynchronous HTTP request, please define a `callback` function 7957 to be invoked when receiving the response. 7958 >>> def callback_function(response): 7959 >>> pprint(response) 7960 >>> 7961 >>> thread = api.update_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 7962 7963 :param callback function: The callback function 7964 for asynchronous request. (optional) 7965 :param str account_id: The external account number (int) or account ID Guid. (required) 7966 :param str permission_profile_id: (required) 7967 :param str include: 7968 :param PermissionProfile permission_profile: 7969 :return: PermissionProfile 7970 If the method is called asynchronously, 7971 returns the request thread. 7972 """ 7973 7974 all_params = ['account_id', 'permission_profile_id', 'include', 'permission_profile'] 7975 all_params.append('callback') 7976 all_params.append('_return_http_data_only') 7977 all_params.append('_preload_content') 7978 all_params.append('_request_timeout') 7979 7980 params = locals() 7981 for key, val in iteritems(params['kwargs']): 7982 if key not in all_params: 7983 raise TypeError( 7984 "Got an unexpected keyword argument '%s'" 7985 " to method update_permission_profile" % key 7986 ) 7987 params[key] = val 7988 del params['kwargs'] 7989 # verify the required parameter 'account_id' is set 7990 if ('account_id' not in params) or (params['account_id'] is None): 7991 raise ValueError("Missing the required parameter `account_id` when calling `update_permission_profile`") 7992 # verify the required parameter 'permission_profile_id' is set 7993 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 7994 raise ValueError("Missing the required parameter `permission_profile_id` when calling `update_permission_profile`") 7995 7996 7997 collection_formats = {} 7998 7999 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 8000 path_params = {} 8001 if 'account_id' in params: 8002 path_params['accountId'] = params['account_id'] 8003 if 'permission_profile_id' in params: 8004 path_params['permissionProfileId'] = params['permission_profile_id'] 8005 8006 query_params = {} 8007 if 'include' in params: 8008 query_params['include'] = params['include'] 8009 8010 header_params = {} 8011 8012 form_params = [] 8013 local_var_files = {} 8014 8015 body_params = None 8016 if 'permission_profile' in params: 8017 body_params = params['permission_profile'] 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, 'PUT', 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='PermissionProfile', 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 update_settings(self, account_id, **kwargs): 8041 """ 8042 Updates the account settings for an account. 8043 Updates the account settings for the specified account. 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.update_settings(account_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 AccountSettingsInformation account_settings_information: 8056 :return: None 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.update_settings_with_http_info(account_id, **kwargs) 8063 else: 8064 (data) = self.update_settings_with_http_info(account_id, **kwargs) 8065 return data 8066 8067 def update_settings_with_http_info(self, account_id, **kwargs): 8068 """ 8069 Updates the account settings for an account. 8070 Updates the account settings for the specified account. 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.update_settings_with_http_info(account_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 AccountSettingsInformation account_settings_information: 8083 :return: None 8084 If the method is called asynchronously, 8085 returns the request thread. 8086 """ 8087 8088 all_params = ['account_id', 'account_settings_information'] 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 update_settings" % 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 `update_settings`") 8106 8107 8108 collection_formats = {} 8109 8110 resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json') 8111 path_params = {} 8112 if 'account_id' in params: 8113 path_params['accountId'] = params['account_id'] 8114 8115 query_params = {} 8116 8117 header_params = {} 8118 8119 form_params = [] 8120 local_var_files = {} 8121 8122 body_params = None 8123 if 'account_settings_information' in params: 8124 body_params = params['account_settings_information'] 8125 # HTTP header `Accept` 8126 header_params['Accept'] = self.api_client.\ 8127 select_header_accept(['application/json']) 8128 8129 # Authentication setting 8130 auth_settings = [] 8131 8132 return self.api_client.call_api(resource_path, 'PUT', 8133 path_params, 8134 query_params, 8135 header_params, 8136 body=body_params, 8137 post_params=form_params, 8138 files=local_var_files, 8139 response_type=None, 8140 auth_settings=auth_settings, 8141 callback=params.get('callback'), 8142 _return_http_data_only=params.get('_return_http_data_only'), 8143 _preload_content=params.get('_preload_content', True), 8144 _request_timeout=params.get('_request_timeout'), 8145 collection_formats=collection_formats) 8146 8147 def update_shared_access(self, account_id, **kwargs): 8148 """ 8149 Reserved: Sets the shared access information for users. 8150 Reserved: Sets the shared access information for one or more users. 8151 This method makes a synchronous HTTP request by default. To make an 8152 asynchronous HTTP request, please define a `callback` function 8153 to be invoked when receiving the response. 8154 >>> def callback_function(response): 8155 >>> pprint(response) 8156 >>> 8157 >>> thread = api.update_shared_access(account_id, callback=callback_function) 8158 8159 :param callback function: The callback function 8160 for asynchronous request. (optional) 8161 :param str account_id: The external account number (int) or account ID Guid. (required) 8162 :param str item_type: 8163 :param str preserve_existing_shared_access: 8164 :param str user_ids: 8165 :param AccountSharedAccess account_shared_access: 8166 :return: AccountSharedAccess 8167 If the method is called asynchronously, 8168 returns the request thread. 8169 """ 8170 kwargs['_return_http_data_only'] = True 8171 if kwargs.get('callback'): 8172 return self.update_shared_access_with_http_info(account_id, **kwargs) 8173 else: 8174 (data) = self.update_shared_access_with_http_info(account_id, **kwargs) 8175 return data 8176 8177 def update_shared_access_with_http_info(self, account_id, **kwargs): 8178 """ 8179 Reserved: Sets the shared access information for users. 8180 Reserved: Sets the shared access information for one or more users. 8181 This method makes a synchronous HTTP request by default. To make an 8182 asynchronous HTTP request, please define a `callback` function 8183 to be invoked when receiving the response. 8184 >>> def callback_function(response): 8185 >>> pprint(response) 8186 >>> 8187 >>> thread = api.update_shared_access_with_http_info(account_id, callback=callback_function) 8188 8189 :param callback function: The callback function 8190 for asynchronous request. (optional) 8191 :param str account_id: The external account number (int) or account ID Guid. (required) 8192 :param str item_type: 8193 :param str preserve_existing_shared_access: 8194 :param str user_ids: 8195 :param AccountSharedAccess account_shared_access: 8196 :return: AccountSharedAccess 8197 If the method is called asynchronously, 8198 returns the request thread. 8199 """ 8200 8201 all_params = ['account_id', 'item_type', 'preserve_existing_shared_access', 'user_ids', 'account_shared_access'] 8202 all_params.append('callback') 8203 all_params.append('_return_http_data_only') 8204 all_params.append('_preload_content') 8205 all_params.append('_request_timeout') 8206 8207 params = locals() 8208 for key, val in iteritems(params['kwargs']): 8209 if key not in all_params: 8210 raise TypeError( 8211 "Got an unexpected keyword argument '%s'" 8212 " to method update_shared_access" % key 8213 ) 8214 params[key] = val 8215 del params['kwargs'] 8216 # verify the required parameter 'account_id' is set 8217 if ('account_id' not in params) or (params['account_id'] is None): 8218 raise ValueError("Missing the required parameter `account_id` when calling `update_shared_access`") 8219 8220 8221 collection_formats = {} 8222 8223 resource_path = '/v2.1/accounts/{accountId}/shared_access'.replace('{format}', 'json') 8224 path_params = {} 8225 if 'account_id' in params: 8226 path_params['accountId'] = params['account_id'] 8227 8228 query_params = {} 8229 if 'item_type' in params: 8230 query_params['item_type'] = params['item_type'] 8231 if 'preserve_existing_shared_access' in params: 8232 query_params['preserve_existing_shared_access'] = params['preserve_existing_shared_access'] 8233 if 'user_ids' in params: 8234 query_params['user_ids'] = params['user_ids'] 8235 8236 header_params = {} 8237 8238 form_params = [] 8239 local_var_files = {} 8240 8241 body_params = None 8242 if 'account_shared_access' in params: 8243 body_params = params['account_shared_access'] 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, 'PUT', 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='AccountSharedAccess', 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 update_user_authorization(self, account_id, authorization_id, user_id, **kwargs): 8267 """ 8268 Updates the user authorization 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.update_user_authorization(account_id, authorization_id, user_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 authorization_id: (required) 8281 :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required) 8282 :param UserAuthorizationUpdateRequest user_authorization_update_request: 8283 :return: UserAuthorization 8284 If the method is called asynchronously, 8285 returns the request thread. 8286 """ 8287 kwargs['_return_http_data_only'] = True 8288 if kwargs.get('callback'): 8289 return self.update_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 8290 else: 8291 (data) = self.update_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 8292 return data 8293 8294 def update_user_authorization_with_http_info(self, account_id, authorization_id, user_id, **kwargs): 8295 """ 8296 Updates the user authorization 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.update_user_authorization_with_http_info(account_id, authorization_id, user_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 authorization_id: (required) 8309 :param str user_id: The user ID of the user being accessed. Generally this is the user ID of the authenticated user, but if the authenticated user is an Admin on the account, this may be another user the Admin user is accessing. (required) 8310 :param UserAuthorizationUpdateRequest user_authorization_update_request: 8311 :return: UserAuthorization 8312 If the method is called asynchronously, 8313 returns the request thread. 8314 """ 8315 8316 all_params = ['account_id', 'authorization_id', 'user_id', 'user_authorization_update_request'] 8317 all_params.append('callback') 8318 all_params.append('_return_http_data_only') 8319 all_params.append('_preload_content') 8320 all_params.append('_request_timeout') 8321 8322 params = locals() 8323 for key, val in iteritems(params['kwargs']): 8324 if key not in all_params: 8325 raise TypeError( 8326 "Got an unexpected keyword argument '%s'" 8327 " to method update_user_authorization" % key 8328 ) 8329 params[key] = val 8330 del params['kwargs'] 8331 # verify the required parameter 'account_id' is set 8332 if ('account_id' not in params) or (params['account_id'] is None): 8333 raise ValueError("Missing the required parameter `account_id` when calling `update_user_authorization`") 8334 # verify the required parameter 'authorization_id' is set 8335 if ('authorization_id' not in params) or (params['authorization_id'] is None): 8336 raise ValueError("Missing the required parameter `authorization_id` when calling `update_user_authorization`") 8337 # verify the required parameter 'user_id' is set 8338 if ('user_id' not in params) or (params['user_id'] is None): 8339 raise ValueError("Missing the required parameter `user_id` when calling `update_user_authorization`") 8340 8341 8342 collection_formats = {} 8343 8344 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorization/{authorizationId}'.replace('{format}', 'json') 8345 path_params = {} 8346 if 'account_id' in params: 8347 path_params['accountId'] = params['account_id'] 8348 if 'authorization_id' in params: 8349 path_params['authorizationId'] = params['authorization_id'] 8350 if 'user_id' in params: 8351 path_params['userId'] = params['user_id'] 8352 8353 query_params = {} 8354 8355 header_params = {} 8356 8357 form_params = [] 8358 local_var_files = {} 8359 8360 body_params = None 8361 if 'user_authorization_update_request' in params: 8362 body_params = params['user_authorization_update_request'] 8363 # HTTP header `Accept` 8364 header_params['Accept'] = self.api_client.\ 8365 select_header_accept(['application/json']) 8366 8367 # Authentication setting 8368 auth_settings = [] 8369 8370 return self.api_client.call_api(resource_path, 'PUT', 8371 path_params, 8372 query_params, 8373 header_params, 8374 body=body_params, 8375 post_params=form_params, 8376 files=local_var_files, 8377 response_type='UserAuthorization', 8378 auth_settings=auth_settings, 8379 callback=params.get('callback'), 8380 _return_http_data_only=params.get('_return_http_data_only'), 8381 _preload_content=params.get('_preload_content', True), 8382 _request_timeout=params.get('_request_timeout'), 8383 collection_formats=collection_formats) 8384 8385 def update_watermark(self, account_id, **kwargs): 8386 """ 8387 Update watermark information. 8388 8389 This method makes a synchronous HTTP request by default. To make an 8390 asynchronous HTTP request, please define a `callback` function 8391 to be invoked when receiving the response. 8392 >>> def callback_function(response): 8393 >>> pprint(response) 8394 >>> 8395 >>> thread = api.update_watermark(account_id, callback=callback_function) 8396 8397 :param callback function: The callback function 8398 for asynchronous request. (optional) 8399 :param str account_id: The external account number (int) or account ID Guid. (required) 8400 :param Watermark watermark: 8401 :return: Watermark 8402 If the method is called asynchronously, 8403 returns the request thread. 8404 """ 8405 kwargs['_return_http_data_only'] = True 8406 if kwargs.get('callback'): 8407 return self.update_watermark_with_http_info(account_id, **kwargs) 8408 else: 8409 (data) = self.update_watermark_with_http_info(account_id, **kwargs) 8410 return data 8411 8412 def update_watermark_with_http_info(self, account_id, **kwargs): 8413 """ 8414 Update watermark information. 8415 8416 This method makes a synchronous HTTP request by default. To make an 8417 asynchronous HTTP request, please define a `callback` function 8418 to be invoked when receiving the response. 8419 >>> def callback_function(response): 8420 >>> pprint(response) 8421 >>> 8422 >>> thread = api.update_watermark_with_http_info(account_id, callback=callback_function) 8423 8424 :param callback function: The callback function 8425 for asynchronous request. (optional) 8426 :param str account_id: The external account number (int) or account ID Guid. (required) 8427 :param Watermark watermark: 8428 :return: Watermark 8429 If the method is called asynchronously, 8430 returns the request thread. 8431 """ 8432 8433 all_params = ['account_id', 'watermark'] 8434 all_params.append('callback') 8435 all_params.append('_return_http_data_only') 8436 all_params.append('_preload_content') 8437 all_params.append('_request_timeout') 8438 8439 params = locals() 8440 for key, val in iteritems(params['kwargs']): 8441 if key not in all_params: 8442 raise TypeError( 8443 "Got an unexpected keyword argument '%s'" 8444 " to method update_watermark" % key 8445 ) 8446 params[key] = val 8447 del params['kwargs'] 8448 # verify the required parameter 'account_id' is set 8449 if ('account_id' not in params) or (params['account_id'] is None): 8450 raise ValueError("Missing the required parameter `account_id` when calling `update_watermark`") 8451 8452 8453 collection_formats = {} 8454 8455 resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json') 8456 path_params = {} 8457 if 'account_id' in params: 8458 path_params['accountId'] = params['account_id'] 8459 8460 query_params = {} 8461 8462 header_params = {} 8463 8464 form_params = [] 8465 local_var_files = {} 8466 8467 body_params = None 8468 if 'watermark' in params: 8469 body_params = params['watermark'] 8470 # HTTP header `Accept` 8471 header_params['Accept'] = self.api_client.\ 8472 select_header_accept(['application/json']) 8473 8474 # Authentication setting 8475 auth_settings = [] 8476 8477 return self.api_client.call_api(resource_path, 'PUT', 8478 path_params, 8479 query_params, 8480 header_params, 8481 body=body_params, 8482 post_params=form_params, 8483 files=local_var_files, 8484 response_type='Watermark', 8485 auth_settings=auth_settings, 8486 callback=params.get('callback'), 8487 _return_http_data_only=params.get('_return_http_data_only'), 8488 _preload_content=params.get('_preload_content', True), 8489 _request_timeout=params.get('_request_timeout'), 8490 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
create(self, **kwargs)
44 def create(self, **kwargs): 45 """ 46 Creates new accounts. 47 Creates new DocuSign service accounts. This is used to create multiple DocuSign accounts with one call. It uses the same information and formats as the normal a [Accounts:create](accounts_create) call with the information included within a `newAccountRequests` element. A maximum of 100 new accounts can be created at one time. Note that the structure of the XML request is slightly different than the JSON request, in that the new account information is included in a `newAccountDefinition` property inside the `newAccountRequests` element. Response The response returns the new account ID, password and the default user information for each newly created account. A 201 code is returned if the call succeeded. While the call may have succeed, some of the individual account requests may have failed. In the case of failures to create the account, an `errorDetails` node is added in the response to each specific request that failed. 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.create(callback=callback_function) 55 56 :param callback function: The callback function 57 for asynchronous request. (optional) 58 :param str preview_billing_plan: When set to **true**, creates the account using a preview billing plan. 59 :param NewAccountDefinition new_account_definition: 60 :return: NewAccountSummary 61 If the method is called asynchronously, 62 returns the request thread. 63 """ 64 kwargs['_return_http_data_only'] = True 65 if kwargs.get('callback'): 66 return self.create_with_http_info(**kwargs) 67 else: 68 (data) = self.create_with_http_info(**kwargs) 69 return data
Creates new accounts.
Creates new DocuSign service accounts. This is used to create multiple DocuSign accounts with one call. It uses the same information and formats as the normal a Accounts:create call with the information included within a newAccountRequests element. A maximum of 100 new accounts can be created at one time. Note that the structure of the XML request is slightly different than the JSON request, in that the new account information is included in a newAccountDefinition property inside the newAccountRequests element. Response The response returns the new account ID, password and the default user information for each newly created account. A 201 code is returned if the call succeeded. While the call may have succeed, some of the individual account requests may have failed. In the case of failures to create the account, an errorDetails node is added in the response to each specific request that failed.
This method makes a synchronous HTTP request by default. To make 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(callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str preview_billing_plan: When set to true, creates the account using a preview billing plan.
- NewAccountDefinition new_account_definition:
Returns
NewAccountSummary If the method is called asynchronously, returns the request thread.
def
create_with_http_info(self, **kwargs)
71 def create_with_http_info(self, **kwargs): 72 """ 73 Creates new accounts. 74 Creates new DocuSign service accounts. This is used to create multiple DocuSign accounts with one call. It uses the same information and formats as the normal a [Accounts:create](accounts_create) call with the information included within a `newAccountRequests` element. A maximum of 100 new accounts can be created at one time. Note that the structure of the XML request is slightly different than the JSON request, in that the new account information is included in a `newAccountDefinition` property inside the `newAccountRequests` element. Response The response returns the new account ID, password and the default user information for each newly created account. A 201 code is returned if the call succeeded. While the call may have succeed, some of the individual account requests may have failed. In the case of failures to create the account, an `errorDetails` node is added in the response to each specific request that failed. 75 This method makes a synchronous HTTP request by default. To make an 76 asynchronous HTTP request, please define a `callback` function 77 to be invoked when receiving the response. 78 >>> def callback_function(response): 79 >>> pprint(response) 80 >>> 81 >>> thread = api.create_with_http_info(callback=callback_function) 82 83 :param callback function: The callback function 84 for asynchronous request. (optional) 85 :param str preview_billing_plan: When set to **true**, creates the account using a preview billing plan. 86 :param NewAccountDefinition new_account_definition: 87 :return: NewAccountSummary 88 If the method is called asynchronously, 89 returns the request thread. 90 """ 91 92 all_params = ['preview_billing_plan', 'new_account_definition'] 93 all_params.append('callback') 94 all_params.append('_return_http_data_only') 95 all_params.append('_preload_content') 96 all_params.append('_request_timeout') 97 98 params = locals() 99 for key, val in iteritems(params['kwargs']): 100 if key not in all_params: 101 raise TypeError( 102 "Got an unexpected keyword argument '%s'" 103 " to method create" % key 104 ) 105 params[key] = val 106 del params['kwargs'] 107 108 109 collection_formats = {} 110 111 resource_path = '/v2.1/accounts'.replace('{format}', 'json') 112 path_params = {} 113 114 query_params = {} 115 if 'preview_billing_plan' in params: 116 query_params['preview_billing_plan'] = params['preview_billing_plan'] 117 118 header_params = {} 119 120 form_params = [] 121 local_var_files = {} 122 123 body_params = None 124 if 'new_account_definition' in params: 125 body_params = params['new_account_definition'] 126 # HTTP header `Accept` 127 header_params['Accept'] = self.api_client.\ 128 select_header_accept(['application/json']) 129 130 # Authentication setting 131 auth_settings = [] 132 133 return self.api_client.call_api(resource_path, 'POST', 134 path_params, 135 query_params, 136 header_params, 137 body=body_params, 138 post_params=form_params, 139 files=local_var_files, 140 response_type='NewAccountSummary', 141 auth_settings=auth_settings, 142 callback=params.get('callback'), 143 _return_http_data_only=params.get('_return_http_data_only'), 144 _preload_content=params.get('_preload_content', True), 145 _request_timeout=params.get('_request_timeout'), 146 collection_formats=collection_formats)
Creates new accounts.
Creates new DocuSign service accounts. This is used to create multiple DocuSign accounts with one call. It uses the same information and formats as the normal a Accounts:create call with the information included within a newAccountRequests element. A maximum of 100 new accounts can be created at one time. Note that the structure of the XML request is slightly different than the JSON request, in that the new account information is included in a newAccountDefinition property inside the newAccountRequests element. Response The response returns the new account ID, password and the default user information for each newly created account. A 201 code is returned if the call succeeded. While the call may have succeed, some of the individual account requests may have failed. In the case of failures to create the account, an errorDetails node is added in the response to each specific request that failed.
This method makes a synchronous HTTP request by default. To make 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_with_http_info(callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str preview_billing_plan: When set to true, creates the account using a preview billing plan.
- NewAccountDefinition new_account_definition:
Returns
NewAccountSummary If the method is called asynchronously, returns the request thread.
def
create_account_signatures(self, account_id, **kwargs)
148 def create_account_signatures(self, account_id, **kwargs): 149 """ 150 Adds/updates one or more account signatures. This request may include images in multi-part format. 151 152 This method makes a synchronous HTTP request by default. To make an 153 asynchronous HTTP request, please define a `callback` function 154 to be invoked when receiving the response. 155 >>> def callback_function(response): 156 >>> pprint(response) 157 >>> 158 >>> thread = api.create_account_signatures(account_id, callback=callback_function) 159 160 :param callback function: The callback function 161 for asynchronous request. (optional) 162 :param str account_id: The external account number (int) or account ID Guid. (required) 163 :param str decode_only: 164 :param AccountSignaturesInformation account_signatures_information: 165 :return: AccountSignaturesInformation 166 If the method is called asynchronously, 167 returns the request thread. 168 """ 169 kwargs['_return_http_data_only'] = True 170 if kwargs.get('callback'): 171 return self.create_account_signatures_with_http_info(account_id, **kwargs) 172 else: 173 (data) = self.create_account_signatures_with_http_info(account_id, **kwargs) 174 return data
Adds/updates one or more account signatures. This request may include images in multi-part format.
This method makes a synchronous HTTP request by default. To make 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_account_signatures(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 decode_only:
- AccountSignaturesInformation account_signatures_information:
Returns
AccountSignaturesInformation If the method is called asynchronously, returns the request thread.
def
create_account_signatures_with_http_info(self, account_id, **kwargs)
176 def create_account_signatures_with_http_info(self, account_id, **kwargs): 177 """ 178 Adds/updates one or more account signatures. This request may include images in multi-part format. 179 180 This method makes a synchronous HTTP request by default. To make an 181 asynchronous HTTP request, please define a `callback` function 182 to be invoked when receiving the response. 183 >>> def callback_function(response): 184 >>> pprint(response) 185 >>> 186 >>> thread = api.create_account_signatures_with_http_info(account_id, callback=callback_function) 187 188 :param callback function: The callback function 189 for asynchronous request. (optional) 190 :param str account_id: The external account number (int) or account ID Guid. (required) 191 :param str decode_only: 192 :param AccountSignaturesInformation account_signatures_information: 193 :return: AccountSignaturesInformation 194 If the method is called asynchronously, 195 returns the request thread. 196 """ 197 198 all_params = ['account_id', 'decode_only', 'account_signatures_information'] 199 all_params.append('callback') 200 all_params.append('_return_http_data_only') 201 all_params.append('_preload_content') 202 all_params.append('_request_timeout') 203 204 params = locals() 205 for key, val in iteritems(params['kwargs']): 206 if key not in all_params: 207 raise TypeError( 208 "Got an unexpected keyword argument '%s'" 209 " to method create_account_signatures" % key 210 ) 211 params[key] = val 212 del params['kwargs'] 213 # verify the required parameter 'account_id' is set 214 if ('account_id' not in params) or (params['account_id'] is None): 215 raise ValueError("Missing the required parameter `account_id` when calling `create_account_signatures`") 216 217 218 collection_formats = {} 219 220 resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json') 221 path_params = {} 222 if 'account_id' in params: 223 path_params['accountId'] = params['account_id'] 224 225 query_params = {} 226 if 'decode_only' in params: 227 query_params['decode_only'] = params['decode_only'] 228 229 header_params = {} 230 231 form_params = [] 232 local_var_files = {} 233 234 body_params = None 235 if 'account_signatures_information' in params: 236 body_params = params['account_signatures_information'] 237 # HTTP header `Accept` 238 header_params['Accept'] = self.api_client.\ 239 select_header_accept(['application/json']) 240 241 # Authentication setting 242 auth_settings = [] 243 244 return self.api_client.call_api(resource_path, 'POST', 245 path_params, 246 query_params, 247 header_params, 248 body=body_params, 249 post_params=form_params, 250 files=local_var_files, 251 response_type='AccountSignaturesInformation', 252 auth_settings=auth_settings, 253 callback=params.get('callback'), 254 _return_http_data_only=params.get('_return_http_data_only'), 255 _preload_content=params.get('_preload_content', True), 256 _request_timeout=params.get('_request_timeout'), 257 collection_formats=collection_formats)
Adds/updates one or more account signatures. This request may include images in multi-part format.
This method makes a synchronous HTTP request by default. To make 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_account_signatures_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 decode_only:
- AccountSignaturesInformation account_signatures_information:
Returns
AccountSignaturesInformation If the method is called asynchronously, returns the request thread.
def
create_brand(self, account_id, **kwargs)
259 def create_brand(self, account_id, **kwargs): 260 """ 261 Creates one or more brand profile files for the account. 262 Creates one or more brand profile files for the account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSig`) must be set to **true** for the account to use this call. An error is returned if `brandId` property for a brand profile is already set for the account. To upload a new version of an existing brand profile, you must delete the profile and then upload the newer version. When brand profile files are being uploaded, they must be combined into one zip file and the `Content-Type` must be `application/zip`. 263 This method makes a synchronous HTTP request by default. To make an 264 asynchronous HTTP request, please define a `callback` function 265 to be invoked when receiving the response. 266 >>> def callback_function(response): 267 >>> pprint(response) 268 >>> 269 >>> thread = api.create_brand(account_id, callback=callback_function) 270 271 :param callback function: The callback function 272 for asynchronous request. (optional) 273 :param str account_id: The external account number (int) or account ID GUID. (required) 274 :param Brand brand: 275 :return: BrandsResponse 276 If the method is called asynchronously, 277 returns the request thread. 278 """ 279 kwargs['_return_http_data_only'] = True 280 if kwargs.get('callback'): 281 return self.create_brand_with_http_info(account_id, **kwargs) 282 else: 283 (data) = self.create_brand_with_http_info(account_id, **kwargs) 284 return data
Creates one or more brand profile files for the account.
Creates one or more brand profile files for the account. The Account Branding feature (accountSettings properties canSelfBrandSend and canSelfBrandSig) must be set to true for the account to use this call. An error is returned if brandId property for a brand profile is already set for the account. To upload a new version of an existing brand profile, you must delete the profile and then upload the newer version. When brand profile files are being uploaded, they must be combined into one zip file and the Content-Type must be application/zip.
This method makes a synchronous HTTP request by default. To make 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_brand(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)
- Brand brand:
Returns
BrandsResponse If the method is called asynchronously, returns the request thread.
def
create_brand_with_http_info(self, account_id, **kwargs)
286 def create_brand_with_http_info(self, account_id, **kwargs): 287 """ 288 Creates one or more brand profile files for the account. 289 Creates one or more brand profile files for the account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSig`) must be set to **true** for the account to use this call. An error is returned if `brandId` property for a brand profile is already set for the account. To upload a new version of an existing brand profile, you must delete the profile and then upload the newer version. When brand profile files are being uploaded, they must be combined into one zip file and the `Content-Type` must be `application/zip`. 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_brand_with_http_info(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 Brand brand: 302 :return: BrandsResponse 303 If the method is called asynchronously, 304 returns the request thread. 305 """ 306 307 all_params = ['account_id', 'brand'] 308 all_params.append('callback') 309 all_params.append('_return_http_data_only') 310 all_params.append('_preload_content') 311 all_params.append('_request_timeout') 312 313 params = locals() 314 for key, val in iteritems(params['kwargs']): 315 if key not in all_params: 316 raise TypeError( 317 "Got an unexpected keyword argument '%s'" 318 " to method create_brand" % key 319 ) 320 params[key] = val 321 del params['kwargs'] 322 # verify the required parameter 'account_id' is set 323 if ('account_id' not in params) or (params['account_id'] is None): 324 raise ValueError("Missing the required parameter `account_id` when calling `create_brand`") 325 326 327 collection_formats = {} 328 329 resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json') 330 path_params = {} 331 if 'account_id' in params: 332 path_params['accountId'] = params['account_id'] 333 334 query_params = {} 335 336 header_params = {} 337 338 form_params = [] 339 local_var_files = {} 340 341 body_params = None 342 if 'brand' in params: 343 body_params = params['brand'] 344 # HTTP header `Accept` 345 header_params['Accept'] = self.api_client.\ 346 select_header_accept(['application/json']) 347 348 # Authentication setting 349 auth_settings = [] 350 351 return self.api_client.call_api(resource_path, 'POST', 352 path_params, 353 query_params, 354 header_params, 355 body=body_params, 356 post_params=form_params, 357 files=local_var_files, 358 response_type='BrandsResponse', 359 auth_settings=auth_settings, 360 callback=params.get('callback'), 361 _return_http_data_only=params.get('_return_http_data_only'), 362 _preload_content=params.get('_preload_content', True), 363 _request_timeout=params.get('_request_timeout'), 364 collection_formats=collection_formats)
Creates one or more brand profile files for the account.
Creates one or more brand profile files for the account. The Account Branding feature (accountSettings properties canSelfBrandSend and canSelfBrandSig) must be set to true for the account to use this call. An error is returned if brandId property for a brand profile is already set for the account. To upload a new version of an existing brand profile, you must delete the profile and then upload the newer version. When brand profile files are being uploaded, they must be combined into one zip file and the Content-Type must be application/zip.
This method makes a synchronous HTTP request by default. To make 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_brand_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)
- Brand brand:
Returns
BrandsResponse If the method is called asynchronously, returns the request thread.
def
create_custom_field(self, account_id, **kwargs)
366 def create_custom_field(self, account_id, **kwargs): 367 """ 368 Creates an acount custom field. 369 This method creates a custom field and makes it available for all new envelopes associated with an account. 370 This method makes a synchronous HTTP request by default. To make an 371 asynchronous HTTP request, please define a `callback` function 372 to be invoked when receiving the response. 373 >>> def callback_function(response): 374 >>> pprint(response) 375 >>> 376 >>> thread = api.create_custom_field(account_id, callback=callback_function) 377 378 :param callback function: The callback function 379 for asynchronous request. (optional) 380 :param str account_id: The external account number (int) or account ID Guid. (required) 381 :param str apply_to_templates: 382 :param CustomField custom_field: 383 :return: CustomFields 384 If the method is called asynchronously, 385 returns the request thread. 386 """ 387 kwargs['_return_http_data_only'] = True 388 if kwargs.get('callback'): 389 return self.create_custom_field_with_http_info(account_id, **kwargs) 390 else: 391 (data) = self.create_custom_field_with_http_info(account_id, **kwargs) 392 return data
Creates an acount custom field.
This method creates a custom field and makes it available for all new envelopes associated with an 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_custom_field(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 apply_to_templates:
- CustomField custom_field:
Returns
CustomFields If the method is called asynchronously, returns the request thread.
def
create_custom_field_with_http_info(self, account_id, **kwargs)
394 def create_custom_field_with_http_info(self, account_id, **kwargs): 395 """ 396 Creates an acount custom field. 397 This method creates a custom field and makes it available for all new envelopes associated with an account. 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_custom_field_with_http_info(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 str apply_to_templates: 410 :param CustomField custom_field: 411 :return: CustomFields 412 If the method is called asynchronously, 413 returns the request thread. 414 """ 415 416 all_params = ['account_id', 'apply_to_templates', 'custom_field'] 417 all_params.append('callback') 418 all_params.append('_return_http_data_only') 419 all_params.append('_preload_content') 420 all_params.append('_request_timeout') 421 422 params = locals() 423 for key, val in iteritems(params['kwargs']): 424 if key not in all_params: 425 raise TypeError( 426 "Got an unexpected keyword argument '%s'" 427 " to method create_custom_field" % key 428 ) 429 params[key] = val 430 del params['kwargs'] 431 # verify the required parameter 'account_id' is set 432 if ('account_id' not in params) or (params['account_id'] is None): 433 raise ValueError("Missing the required parameter `account_id` when calling `create_custom_field`") 434 435 436 collection_formats = {} 437 438 resource_path = '/v2.1/accounts/{accountId}/custom_fields'.replace('{format}', 'json') 439 path_params = {} 440 if 'account_id' in params: 441 path_params['accountId'] = params['account_id'] 442 443 query_params = {} 444 if 'apply_to_templates' in params: 445 query_params['apply_to_templates'] = params['apply_to_templates'] 446 447 header_params = {} 448 449 form_params = [] 450 local_var_files = {} 451 452 body_params = None 453 if 'custom_field' in params: 454 body_params = params['custom_field'] 455 # HTTP header `Accept` 456 header_params['Accept'] = self.api_client.\ 457 select_header_accept(['application/json']) 458 459 # Authentication setting 460 auth_settings = [] 461 462 return self.api_client.call_api(resource_path, 'POST', 463 path_params, 464 query_params, 465 header_params, 466 body=body_params, 467 post_params=form_params, 468 files=local_var_files, 469 response_type='CustomFields', 470 auth_settings=auth_settings, 471 callback=params.get('callback'), 472 _return_http_data_only=params.get('_return_http_data_only'), 473 _preload_content=params.get('_preload_content', True), 474 _request_timeout=params.get('_request_timeout'), 475 collection_formats=collection_formats)
Creates an acount custom field.
This method creates a custom field and makes it available for all new envelopes associated with an 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_custom_field_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 apply_to_templates:
- CustomField custom_field:
Returns
CustomFields If the method is called asynchronously, returns the request thread.
def
create_permission_profile(self, account_id, **kwargs)
477 def create_permission_profile(self, account_id, **kwargs): 478 """ 479 Creates a new permission profile in the specified account. 480 This method creates a new permission profile for an account. ### Related topics - [How to create a permission profile](/docs/esign-rest-api/how-to/permission-profile-creating/) 481 This method makes a synchronous HTTP request by default. To make an 482 asynchronous HTTP request, please define a `callback` function 483 to be invoked when receiving the response. 484 >>> def callback_function(response): 485 >>> pprint(response) 486 >>> 487 >>> thread = api.create_permission_profile(account_id, callback=callback_function) 488 489 :param callback function: The callback function 490 for asynchronous request. (optional) 491 :param str account_id: The external account number (int) or account ID Guid. (required) 492 :param str include: 493 :param PermissionProfile permission_profile: 494 :return: PermissionProfile 495 If the method is called asynchronously, 496 returns the request thread. 497 """ 498 kwargs['_return_http_data_only'] = True 499 if kwargs.get('callback'): 500 return self.create_permission_profile_with_http_info(account_id, **kwargs) 501 else: 502 (data) = self.create_permission_profile_with_http_info(account_id, **kwargs) 503 return data
Creates a new permission profile in the specified account.
This method creates a new permission profile for an account. ### Related topics - How to create a permission profile
This method makes a synchronous HTTP request by default. To make 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_permission_profile(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 include:
- PermissionProfile permission_profile:
Returns
PermissionProfile If the method is called asynchronously, returns the request thread.
def
create_permission_profile_with_http_info(self, account_id, **kwargs)
505 def create_permission_profile_with_http_info(self, account_id, **kwargs): 506 """ 507 Creates a new permission profile in the specified account. 508 This method creates a new permission profile for an account. ### Related topics - [How to create a permission profile](/docs/esign-rest-api/how-to/permission-profile-creating/) 509 This method makes a synchronous HTTP request by default. To make an 510 asynchronous HTTP request, please define a `callback` function 511 to be invoked when receiving the response. 512 >>> def callback_function(response): 513 >>> pprint(response) 514 >>> 515 >>> thread = api.create_permission_profile_with_http_info(account_id, callback=callback_function) 516 517 :param callback function: The callback function 518 for asynchronous request. (optional) 519 :param str account_id: The external account number (int) or account ID Guid. (required) 520 :param str include: 521 :param PermissionProfile permission_profile: 522 :return: PermissionProfile 523 If the method is called asynchronously, 524 returns the request thread. 525 """ 526 527 all_params = ['account_id', 'include', 'permission_profile'] 528 all_params.append('callback') 529 all_params.append('_return_http_data_only') 530 all_params.append('_preload_content') 531 all_params.append('_request_timeout') 532 533 params = locals() 534 for key, val in iteritems(params['kwargs']): 535 if key not in all_params: 536 raise TypeError( 537 "Got an unexpected keyword argument '%s'" 538 " to method create_permission_profile" % key 539 ) 540 params[key] = val 541 del params['kwargs'] 542 # verify the required parameter 'account_id' is set 543 if ('account_id' not in params) or (params['account_id'] is None): 544 raise ValueError("Missing the required parameter `account_id` when calling `create_permission_profile`") 545 546 547 collection_formats = {} 548 549 resource_path = '/v2.1/accounts/{accountId}/permission_profiles'.replace('{format}', 'json') 550 path_params = {} 551 if 'account_id' in params: 552 path_params['accountId'] = params['account_id'] 553 554 query_params = {} 555 if 'include' in params: 556 query_params['include'] = params['include'] 557 558 header_params = {} 559 560 form_params = [] 561 local_var_files = {} 562 563 body_params = None 564 if 'permission_profile' in params: 565 body_params = params['permission_profile'] 566 # HTTP header `Accept` 567 header_params['Accept'] = self.api_client.\ 568 select_header_accept(['application/json']) 569 570 # Authentication setting 571 auth_settings = [] 572 573 return self.api_client.call_api(resource_path, 'POST', 574 path_params, 575 query_params, 576 header_params, 577 body=body_params, 578 post_params=form_params, 579 files=local_var_files, 580 response_type='PermissionProfile', 581 auth_settings=auth_settings, 582 callback=params.get('callback'), 583 _return_http_data_only=params.get('_return_http_data_only'), 584 _preload_content=params.get('_preload_content', True), 585 _request_timeout=params.get('_request_timeout'), 586 collection_formats=collection_formats)
Creates a new permission profile in the specified account.
This method creates a new permission profile for an account. ### Related topics - How to create a permission profile
This method makes a synchronous HTTP request by default. To make 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_permission_profile_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 include:
- PermissionProfile permission_profile:
Returns
PermissionProfile If the method is called asynchronously, returns the request thread.
def
delete(self, account_id, **kwargs)
812 def delete(self, account_id, **kwargs): 813 """ 814 Deletes the specified account. 815 This closes the specified account. You must be an account admin to close your account. Once closed, an account must be reopened by DocuSign. 816 This method makes a synchronous HTTP request by default. To make an 817 asynchronous HTTP request, please define a `callback` function 818 to be invoked when receiving the response. 819 >>> def callback_function(response): 820 >>> pprint(response) 821 >>> 822 >>> thread = api.delete(account_id, callback=callback_function) 823 824 :param callback function: The callback function 825 for asynchronous request. (optional) 826 :param str account_id: The external account number (int) or account ID Guid. (required) 827 :param str redact_user_data: 828 :return: None 829 If the method is called asynchronously, 830 returns the request thread. 831 """ 832 kwargs['_return_http_data_only'] = True 833 if kwargs.get('callback'): 834 return self.delete_with_http_info(account_id, **kwargs) 835 else: 836 (data) = self.delete_with_http_info(account_id, **kwargs) 837 return data
Deletes the specified account.
This closes the specified account. You must be an account admin to close your account. Once closed, an account must be reopened by DocuSign.
This method makes a synchronous HTTP request by default. To make 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(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 redact_user_data:
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_with_http_info(self, account_id, **kwargs)
839 def delete_with_http_info(self, account_id, **kwargs): 840 """ 841 Deletes the specified account. 842 This closes the specified account. You must be an account admin to close your account. Once closed, an account must be reopened by DocuSign. 843 This method makes a synchronous HTTP request by default. To make an 844 asynchronous HTTP request, please define a `callback` function 845 to be invoked when receiving the response. 846 >>> def callback_function(response): 847 >>> pprint(response) 848 >>> 849 >>> thread = api.delete_with_http_info(account_id, callback=callback_function) 850 851 :param callback function: The callback function 852 for asynchronous request. (optional) 853 :param str account_id: The external account number (int) or account ID Guid. (required) 854 :param str redact_user_data: 855 :return: None 856 If the method is called asynchronously, 857 returns the request thread. 858 """ 859 860 all_params = ['account_id', 'redact_user_data'] 861 all_params.append('callback') 862 all_params.append('_return_http_data_only') 863 all_params.append('_preload_content') 864 all_params.append('_request_timeout') 865 866 params = locals() 867 for key, val in iteritems(params['kwargs']): 868 if key not in all_params: 869 raise TypeError( 870 "Got an unexpected keyword argument '%s'" 871 " to method delete" % key 872 ) 873 params[key] = val 874 del params['kwargs'] 875 # verify the required parameter 'account_id' is set 876 if ('account_id' not in params) or (params['account_id'] is None): 877 raise ValueError("Missing the required parameter `account_id` when calling `delete`") 878 879 880 collection_formats = {} 881 882 resource_path = '/v2.1/accounts/{accountId}'.replace('{format}', 'json') 883 path_params = {} 884 if 'account_id' in params: 885 path_params['accountId'] = params['account_id'] 886 887 query_params = {} 888 if 'redact_user_data' in params: 889 query_params['redact_user_data'] = params['redact_user_data'] 890 891 header_params = {} 892 893 form_params = [] 894 local_var_files = {} 895 896 body_params = None 897 # HTTP header `Accept` 898 header_params['Accept'] = self.api_client.\ 899 select_header_accept(['application/json']) 900 901 # Authentication setting 902 auth_settings = [] 903 904 return self.api_client.call_api(resource_path, 'DELETE', 905 path_params, 906 query_params, 907 header_params, 908 body=body_params, 909 post_params=form_params, 910 files=local_var_files, 911 response_type=None, 912 auth_settings=auth_settings, 913 callback=params.get('callback'), 914 _return_http_data_only=params.get('_return_http_data_only'), 915 _preload_content=params.get('_preload_content', True), 916 _request_timeout=params.get('_request_timeout'), 917 collection_formats=collection_formats)
Deletes the specified account.
This closes the specified account. You must be an account admin to close your account. Once closed, an account must be reopened by DocuSign.
This method makes a synchronous HTTP request by default. To make 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_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 redact_user_data:
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_account_signature(self, account_id, signature_id, **kwargs)
919 def delete_account_signature(self, account_id, signature_id, **kwargs): 920 """ 921 Close the specified signature by Id. 922 923 This method makes a synchronous HTTP request by default. To make an 924 asynchronous HTTP request, please define a `callback` function 925 to be invoked when receiving the response. 926 >>> def callback_function(response): 927 >>> pprint(response) 928 >>> 929 >>> thread = api.delete_account_signature(account_id, signature_id, callback=callback_function) 930 931 :param callback function: The callback function 932 for asynchronous request. (optional) 933 :param str account_id: The external account number (int) or account ID Guid. (required) 934 :param str signature_id: The ID of the signature being accessed. (required) 935 :return: None 936 If the method is called asynchronously, 937 returns the request thread. 938 """ 939 kwargs['_return_http_data_only'] = True 940 if kwargs.get('callback'): 941 return self.delete_account_signature_with_http_info(account_id, signature_id, **kwargs) 942 else: 943 (data) = self.delete_account_signature_with_http_info(account_id, signature_id, **kwargs) 944 return data
Close the specified signature by 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_account_signature(account_id, signature_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str signature_id: The ID of the signature being accessed. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_account_signature_with_http_info(self, account_id, signature_id, **kwargs)
946 def delete_account_signature_with_http_info(self, account_id, signature_id, **kwargs): 947 """ 948 Close the specified signature by Id. 949 950 This method makes a synchronous HTTP request by default. To make an 951 asynchronous HTTP request, please define a `callback` function 952 to be invoked when receiving the response. 953 >>> def callback_function(response): 954 >>> pprint(response) 955 >>> 956 >>> thread = api.delete_account_signature_with_http_info(account_id, signature_id, callback=callback_function) 957 958 :param callback function: The callback function 959 for asynchronous request. (optional) 960 :param str account_id: The external account number (int) or account ID Guid. (required) 961 :param str signature_id: The ID of the signature being accessed. (required) 962 :return: None 963 If the method is called asynchronously, 964 returns the request thread. 965 """ 966 967 all_params = ['account_id', 'signature_id'] 968 all_params.append('callback') 969 all_params.append('_return_http_data_only') 970 all_params.append('_preload_content') 971 all_params.append('_request_timeout') 972 973 params = locals() 974 for key, val in iteritems(params['kwargs']): 975 if key not in all_params: 976 raise TypeError( 977 "Got an unexpected keyword argument '%s'" 978 " to method delete_account_signature" % key 979 ) 980 params[key] = val 981 del params['kwargs'] 982 # verify the required parameter 'account_id' is set 983 if ('account_id' not in params) or (params['account_id'] is None): 984 raise ValueError("Missing the required parameter `account_id` when calling `delete_account_signature`") 985 # verify the required parameter 'signature_id' is set 986 if ('signature_id' not in params) or (params['signature_id'] is None): 987 raise ValueError("Missing the required parameter `signature_id` when calling `delete_account_signature`") 988 989 990 collection_formats = {} 991 992 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 993 path_params = {} 994 if 'account_id' in params: 995 path_params['accountId'] = params['account_id'] 996 if 'signature_id' in params: 997 path_params['signatureId'] = params['signature_id'] 998 999 query_params = {} 1000 1001 header_params = {} 1002 1003 form_params = [] 1004 local_var_files = {} 1005 1006 body_params = None 1007 # HTTP header `Accept` 1008 header_params['Accept'] = self.api_client.\ 1009 select_header_accept(['application/json']) 1010 1011 # Authentication setting 1012 auth_settings = [] 1013 1014 return self.api_client.call_api(resource_path, 'DELETE', 1015 path_params, 1016 query_params, 1017 header_params, 1018 body=body_params, 1019 post_params=form_params, 1020 files=local_var_files, 1021 response_type=None, 1022 auth_settings=auth_settings, 1023 callback=params.get('callback'), 1024 _return_http_data_only=params.get('_return_http_data_only'), 1025 _preload_content=params.get('_preload_content', True), 1026 _request_timeout=params.get('_request_timeout'), 1027 collection_formats=collection_formats)
Close the specified signature by 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_account_signature_with_http_info(account_id, signature_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str signature_id: The ID of the signature being accessed. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_account_signature_image(self, account_id, image_type, signature_id, **kwargs)
1029 def delete_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 1030 """ 1031 Deletes a signature, initials, or stamps image. 1032 1033 This method makes a synchronous HTTP request by default. To make an 1034 asynchronous HTTP request, please define a `callback` function 1035 to be invoked when receiving the response. 1036 >>> def callback_function(response): 1037 >>> pprint(response) 1038 >>> 1039 >>> thread = api.delete_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 1040 1041 :param callback function: The callback function 1042 for asynchronous request. (optional) 1043 :param str account_id: The external account number (int) or account ID Guid. (required) 1044 :param str image_type: One of **signature_image** or **initials_image**. (required) 1045 :param str signature_id: The ID of the signature being accessed. (required) 1046 :return: AccountSignature 1047 If the method is called asynchronously, 1048 returns the request thread. 1049 """ 1050 kwargs['_return_http_data_only'] = True 1051 if kwargs.get('callback'): 1052 return self.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 1053 else: 1054 (data) = self.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 1055 return data
Deletes a signature, initials, or stamps 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.delete_account_signature_image(account_id, image_type, signature_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str image_type: One of signature_image or initials_image. (required)
- str signature_id: The ID of the signature being accessed. (required)
Returns
AccountSignature If the method is called asynchronously, returns the request thread.
def
delete_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs)
1057 def delete_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 1058 """ 1059 Deletes a signature, initials, or stamps image. 1060 1061 This method makes a synchronous HTTP request by default. To make an 1062 asynchronous HTTP request, please define a `callback` function 1063 to be invoked when receiving the response. 1064 >>> def callback_function(response): 1065 >>> pprint(response) 1066 >>> 1067 >>> thread = api.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 1068 1069 :param callback function: The callback function 1070 for asynchronous request. (optional) 1071 :param str account_id: The external account number (int) or account ID Guid. (required) 1072 :param str image_type: One of **signature_image** or **initials_image**. (required) 1073 :param str signature_id: The ID of the signature being accessed. (required) 1074 :return: AccountSignature 1075 If the method is called asynchronously, 1076 returns the request thread. 1077 """ 1078 1079 all_params = ['account_id', 'image_type', 'signature_id'] 1080 all_params.append('callback') 1081 all_params.append('_return_http_data_only') 1082 all_params.append('_preload_content') 1083 all_params.append('_request_timeout') 1084 1085 params = locals() 1086 for key, val in iteritems(params['kwargs']): 1087 if key not in all_params: 1088 raise TypeError( 1089 "Got an unexpected keyword argument '%s'" 1090 " to method delete_account_signature_image" % key 1091 ) 1092 params[key] = val 1093 del params['kwargs'] 1094 # verify the required parameter 'account_id' is set 1095 if ('account_id' not in params) or (params['account_id'] is None): 1096 raise ValueError("Missing the required parameter `account_id` when calling `delete_account_signature_image`") 1097 # verify the required parameter 'image_type' is set 1098 if ('image_type' not in params) or (params['image_type'] is None): 1099 raise ValueError("Missing the required parameter `image_type` when calling `delete_account_signature_image`") 1100 # verify the required parameter 'signature_id' is set 1101 if ('signature_id' not in params) or (params['signature_id'] is None): 1102 raise ValueError("Missing the required parameter `signature_id` when calling `delete_account_signature_image`") 1103 1104 1105 collection_formats = {} 1106 1107 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 1108 path_params = {} 1109 if 'account_id' in params: 1110 path_params['accountId'] = params['account_id'] 1111 if 'image_type' in params: 1112 path_params['imageType'] = params['image_type'] 1113 if 'signature_id' in params: 1114 path_params['signatureId'] = params['signature_id'] 1115 1116 query_params = {} 1117 1118 header_params = {} 1119 1120 form_params = [] 1121 local_var_files = {} 1122 1123 body_params = None 1124 # HTTP header `Accept` 1125 header_params['Accept'] = self.api_client.\ 1126 select_header_accept(['application/json']) 1127 1128 # Authentication setting 1129 auth_settings = [] 1130 1131 return self.api_client.call_api(resource_path, 'DELETE', 1132 path_params, 1133 query_params, 1134 header_params, 1135 body=body_params, 1136 post_params=form_params, 1137 files=local_var_files, 1138 response_type='AccountSignature', 1139 auth_settings=auth_settings, 1140 callback=params.get('callback'), 1141 _return_http_data_only=params.get('_return_http_data_only'), 1142 _preload_content=params.get('_preload_content', True), 1143 _request_timeout=params.get('_request_timeout'), 1144 collection_formats=collection_formats)
Deletes a signature, initials, or stamps 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.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str image_type: One of signature_image or initials_image. (required)
- str signature_id: The ID of the signature being accessed. (required)
Returns
AccountSignature If the method is called asynchronously, returns the request thread.
def
delete_brand(self, account_id, brand_id, **kwargs)
1146 def delete_brand(self, account_id, brand_id, **kwargs): 1147 """ 1148 Removes a brand. 1149 This method deletes a brand from an account. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 1150 This method makes a synchronous HTTP request by default. To make an 1151 asynchronous HTTP request, please define a `callback` function 1152 to be invoked when receiving the response. 1153 >>> def callback_function(response): 1154 >>> pprint(response) 1155 >>> 1156 >>> thread = api.delete_brand(account_id, brand_id, callback=callback_function) 1157 1158 :param callback function: The callback function 1159 for asynchronous request. (optional) 1160 :param str account_id: The external account number (int) or account ID Guid. (required) 1161 :param str brand_id: The unique identifier of a brand. (required) 1162 :return: None 1163 If the method is called asynchronously, 1164 returns the request thread. 1165 """ 1166 kwargs['_return_http_data_only'] = True 1167 if kwargs.get('callback'): 1168 return self.delete_brand_with_http_info(account_id, brand_id, **kwargs) 1169 else: 1170 (data) = self.delete_brand_with_http_info(account_id, brand_id, **kwargs) 1171 return data
Removes a brand.
This method deletes a brand from an account. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be 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.delete_brand(account_id, brand_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str brand_id: The unique identifier of a brand. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_brand_with_http_info(self, account_id, brand_id, **kwargs)
1173 def delete_brand_with_http_info(self, account_id, brand_id, **kwargs): 1174 """ 1175 Removes a brand. 1176 This method deletes a brand from an account. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 1177 This method makes a synchronous HTTP request by default. To make an 1178 asynchronous HTTP request, please define a `callback` function 1179 to be invoked when receiving the response. 1180 >>> def callback_function(response): 1181 >>> pprint(response) 1182 >>> 1183 >>> thread = api.delete_brand_with_http_info(account_id, brand_id, callback=callback_function) 1184 1185 :param callback function: The callback function 1186 for asynchronous request. (optional) 1187 :param str account_id: The external account number (int) or account ID Guid. (required) 1188 :param str brand_id: The unique identifier of a brand. (required) 1189 :return: None 1190 If the method is called asynchronously, 1191 returns the request thread. 1192 """ 1193 1194 all_params = ['account_id', 'brand_id'] 1195 all_params.append('callback') 1196 all_params.append('_return_http_data_only') 1197 all_params.append('_preload_content') 1198 all_params.append('_request_timeout') 1199 1200 params = locals() 1201 for key, val in iteritems(params['kwargs']): 1202 if key not in all_params: 1203 raise TypeError( 1204 "Got an unexpected keyword argument '%s'" 1205 " to method delete_brand" % key 1206 ) 1207 params[key] = val 1208 del params['kwargs'] 1209 # verify the required parameter 'account_id' is set 1210 if ('account_id' not in params) or (params['account_id'] is None): 1211 raise ValueError("Missing the required parameter `account_id` when calling `delete_brand`") 1212 # verify the required parameter 'brand_id' is set 1213 if ('brand_id' not in params) or (params['brand_id'] is None): 1214 raise ValueError("Missing the required parameter `brand_id` when calling `delete_brand`") 1215 1216 1217 collection_formats = {} 1218 1219 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 1220 path_params = {} 1221 if 'account_id' in params: 1222 path_params['accountId'] = params['account_id'] 1223 if 'brand_id' in params: 1224 path_params['brandId'] = params['brand_id'] 1225 1226 query_params = {} 1227 1228 header_params = {} 1229 1230 form_params = [] 1231 local_var_files = {} 1232 1233 body_params = None 1234 # HTTP header `Accept` 1235 header_params['Accept'] = self.api_client.\ 1236 select_header_accept(['application/json']) 1237 1238 # Authentication setting 1239 auth_settings = [] 1240 1241 return self.api_client.call_api(resource_path, 'DELETE', 1242 path_params, 1243 query_params, 1244 header_params, 1245 body=body_params, 1246 post_params=form_params, 1247 files=local_var_files, 1248 response_type=None, 1249 auth_settings=auth_settings, 1250 callback=params.get('callback'), 1251 _return_http_data_only=params.get('_return_http_data_only'), 1252 _preload_content=params.get('_preload_content', True), 1253 _request_timeout=params.get('_request_timeout'), 1254 collection_formats=collection_formats)
Removes a brand.
This method deletes a brand from an account. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be 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.delete_brand_with_http_info(account_id, brand_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str brand_id: The unique identifier of a brand. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_brand_logo_by_type(self, account_id, brand_id, logo_type, **kwargs)
1256 def delete_brand_logo_by_type(self, account_id, brand_id, logo_type, **kwargs): 1257 """ 1258 Delete one branding logo. 1259 This method deletes a single logo from an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 1260 This method makes a synchronous HTTP request by default. To make an 1261 asynchronous HTTP request, please define a `callback` function 1262 to be invoked when receiving the response. 1263 >>> def callback_function(response): 1264 >>> pprint(response) 1265 >>> 1266 >>> thread = api.delete_brand_logo_by_type(account_id, brand_id, logo_type, callback=callback_function) 1267 1268 :param callback function: The callback function 1269 for asynchronous request. (optional) 1270 :param str account_id: The external account number (int) or account ID Guid. (required) 1271 :param str brand_id: The unique identifier of a brand. (required) 1272 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 1273 :return: None 1274 If the method is called asynchronously, 1275 returns the request thread. 1276 """ 1277 kwargs['_return_http_data_only'] = True 1278 if kwargs.get('callback'): 1279 return self.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 1280 else: 1281 (data) = self.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 1282 return data
Delete one branding logo.
This method deletes a single logo from an account brand. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be 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.delete_brand_logo_by_type(account_id, brand_id, logo_type, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str brand_id: The unique identifier of a brand. (required)
- str logo_type: One of Primary, Secondary or Email. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, **kwargs)
1284 def delete_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, **kwargs): 1285 """ 1286 Delete one branding logo. 1287 This method deletes a single logo from an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 1288 This method makes a synchronous HTTP request by default. To make an 1289 asynchronous HTTP request, please define a `callback` function 1290 to be invoked when receiving the response. 1291 >>> def callback_function(response): 1292 >>> pprint(response) 1293 >>> 1294 >>> thread = api.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, callback=callback_function) 1295 1296 :param callback function: The callback function 1297 for asynchronous request. (optional) 1298 :param str account_id: The external account number (int) or account ID Guid. (required) 1299 :param str brand_id: The unique identifier of a brand. (required) 1300 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 1301 :return: None 1302 If the method is called asynchronously, 1303 returns the request thread. 1304 """ 1305 1306 all_params = ['account_id', 'brand_id', 'logo_type'] 1307 all_params.append('callback') 1308 all_params.append('_return_http_data_only') 1309 all_params.append('_preload_content') 1310 all_params.append('_request_timeout') 1311 1312 params = locals() 1313 for key, val in iteritems(params['kwargs']): 1314 if key not in all_params: 1315 raise TypeError( 1316 "Got an unexpected keyword argument '%s'" 1317 " to method delete_brand_logo_by_type" % key 1318 ) 1319 params[key] = val 1320 del params['kwargs'] 1321 # verify the required parameter 'account_id' is set 1322 if ('account_id' not in params) or (params['account_id'] is None): 1323 raise ValueError("Missing the required parameter `account_id` when calling `delete_brand_logo_by_type`") 1324 # verify the required parameter 'brand_id' is set 1325 if ('brand_id' not in params) or (params['brand_id'] is None): 1326 raise ValueError("Missing the required parameter `brand_id` when calling `delete_brand_logo_by_type`") 1327 # verify the required parameter 'logo_type' is set 1328 if ('logo_type' not in params) or (params['logo_type'] is None): 1329 raise ValueError("Missing the required parameter `logo_type` when calling `delete_brand_logo_by_type`") 1330 1331 1332 collection_formats = {} 1333 1334 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 1335 path_params = {} 1336 if 'account_id' in params: 1337 path_params['accountId'] = params['account_id'] 1338 if 'brand_id' in params: 1339 path_params['brandId'] = params['brand_id'] 1340 if 'logo_type' in params: 1341 path_params['logoType'] = params['logo_type'] 1342 1343 query_params = {} 1344 1345 header_params = {} 1346 1347 form_params = [] 1348 local_var_files = {} 1349 1350 body_params = None 1351 # HTTP header `Accept` 1352 header_params['Accept'] = self.api_client.\ 1353 select_header_accept(['application/json']) 1354 1355 # Authentication setting 1356 auth_settings = [] 1357 1358 return self.api_client.call_api(resource_path, 'DELETE', 1359 path_params, 1360 query_params, 1361 header_params, 1362 body=body_params, 1363 post_params=form_params, 1364 files=local_var_files, 1365 response_type=None, 1366 auth_settings=auth_settings, 1367 callback=params.get('callback'), 1368 _return_http_data_only=params.get('_return_http_data_only'), 1369 _preload_content=params.get('_preload_content', True), 1370 _request_timeout=params.get('_request_timeout'), 1371 collection_formats=collection_formats)
Delete one branding logo.
This method deletes a single logo from an account brand. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be 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.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str brand_id: The unique identifier of a brand. (required)
- str logo_type: One of Primary, Secondary or Email. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_brands(self, account_id, **kwargs)
1373 def delete_brands(self, account_id, **kwargs): 1374 """ 1375 Deletes one or more brand profiles. 1376 Deletes one or more brand profiles from an account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`) must be set to **true** to use this call. 1377 This method makes a synchronous HTTP request by default. To make an 1378 asynchronous HTTP request, please define a `callback` function 1379 to be invoked when receiving the response. 1380 >>> def callback_function(response): 1381 >>> pprint(response) 1382 >>> 1383 >>> thread = api.delete_brands(account_id, callback=callback_function) 1384 1385 :param callback function: The callback function 1386 for asynchronous request. (optional) 1387 :param str account_id: The external account number (int) or account ID Guid. (required) 1388 :param BrandsRequest brands_request: 1389 :return: BrandsResponse 1390 If the method is called asynchronously, 1391 returns the request thread. 1392 """ 1393 kwargs['_return_http_data_only'] = True 1394 if kwargs.get('callback'): 1395 return self.delete_brands_with_http_info(account_id, **kwargs) 1396 else: 1397 (data) = self.delete_brands_with_http_info(account_id, **kwargs) 1398 return data
Deletes one or more brand profiles.
Deletes one or more brand profiles from an account. The Account Branding feature (accountSettings properties canSelfBrandSend and canSelfBrandSend) must be set to true to use this call.
This method makes a synchronous HTTP request by default. To make 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_brands(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)
- BrandsRequest brands_request:
Returns
BrandsResponse If the method is called asynchronously, returns the request thread.
def
delete_brands_with_http_info(self, account_id, **kwargs)
1400 def delete_brands_with_http_info(self, account_id, **kwargs): 1401 """ 1402 Deletes one or more brand profiles. 1403 Deletes one or more brand profiles from an account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`) must be set to **true** to use this call. 1404 This method makes a synchronous HTTP request by default. To make an 1405 asynchronous HTTP request, please define a `callback` function 1406 to be invoked when receiving the response. 1407 >>> def callback_function(response): 1408 >>> pprint(response) 1409 >>> 1410 >>> thread = api.delete_brands_with_http_info(account_id, callback=callback_function) 1411 1412 :param callback function: The callback function 1413 for asynchronous request. (optional) 1414 :param str account_id: The external account number (int) or account ID Guid. (required) 1415 :param BrandsRequest brands_request: 1416 :return: BrandsResponse 1417 If the method is called asynchronously, 1418 returns the request thread. 1419 """ 1420 1421 all_params = ['account_id', 'brands_request'] 1422 all_params.append('callback') 1423 all_params.append('_return_http_data_only') 1424 all_params.append('_preload_content') 1425 all_params.append('_request_timeout') 1426 1427 params = locals() 1428 for key, val in iteritems(params['kwargs']): 1429 if key not in all_params: 1430 raise TypeError( 1431 "Got an unexpected keyword argument '%s'" 1432 " to method delete_brands" % key 1433 ) 1434 params[key] = val 1435 del params['kwargs'] 1436 # verify the required parameter 'account_id' is set 1437 if ('account_id' not in params) or (params['account_id'] is None): 1438 raise ValueError("Missing the required parameter `account_id` when calling `delete_brands`") 1439 1440 1441 collection_formats = {} 1442 1443 resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json') 1444 path_params = {} 1445 if 'account_id' in params: 1446 path_params['accountId'] = params['account_id'] 1447 1448 query_params = {} 1449 1450 header_params = {} 1451 1452 form_params = [] 1453 local_var_files = {} 1454 1455 body_params = None 1456 if 'brands_request' in params: 1457 body_params = params['brands_request'] 1458 # HTTP header `Accept` 1459 header_params['Accept'] = self.api_client.\ 1460 select_header_accept(['application/json']) 1461 1462 # Authentication setting 1463 auth_settings = [] 1464 1465 return self.api_client.call_api(resource_path, 'DELETE', 1466 path_params, 1467 query_params, 1468 header_params, 1469 body=body_params, 1470 post_params=form_params, 1471 files=local_var_files, 1472 response_type='BrandsResponse', 1473 auth_settings=auth_settings, 1474 callback=params.get('callback'), 1475 _return_http_data_only=params.get('_return_http_data_only'), 1476 _preload_content=params.get('_preload_content', True), 1477 _request_timeout=params.get('_request_timeout'), 1478 collection_formats=collection_formats)
Deletes one or more brand profiles.
Deletes one or more brand profiles from an account. The Account Branding feature (accountSettings properties canSelfBrandSend and canSelfBrandSend) must be set to true to use this call.
This method makes a synchronous HTTP request by default. To make 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_brands_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)
- BrandsRequest brands_request:
Returns
BrandsResponse If the method is called asynchronously, returns the request thread.
def
delete_captive_recipient(self, account_id, recipient_part, **kwargs)
1480 def delete_captive_recipient(self, account_id, recipient_part, **kwargs): 1481 """ 1482 Deletes the signature for one or more captive recipient records. 1483 Deletes the signature for one or more captive recipient records; it is primarily used for testing. This provides a way to reset the signature associated with a client user ID so that a new signature can be created the next time the client user ID is used. 1484 This method makes a synchronous HTTP request by default. To make an 1485 asynchronous HTTP request, please define a `callback` function 1486 to be invoked when receiving the response. 1487 >>> def callback_function(response): 1488 >>> pprint(response) 1489 >>> 1490 >>> thread = api.delete_captive_recipient(account_id, recipient_part, callback=callback_function) 1491 1492 :param callback function: The callback function 1493 for asynchronous request. (optional) 1494 :param str account_id: The external account number (int) or account ID Guid. (required) 1495 :param str recipient_part: (required) 1496 :param CaptiveRecipientInformation captive_recipient_information: 1497 :return: CaptiveRecipientInformation 1498 If the method is called asynchronously, 1499 returns the request thread. 1500 """ 1501 kwargs['_return_http_data_only'] = True 1502 if kwargs.get('callback'): 1503 return self.delete_captive_recipient_with_http_info(account_id, recipient_part, **kwargs) 1504 else: 1505 (data) = self.delete_captive_recipient_with_http_info(account_id, recipient_part, **kwargs) 1506 return data
Deletes the signature for one or more captive recipient records.
Deletes the signature for one or more captive recipient records; it is primarily used for testing. This provides a way to reset the signature associated with a client user ID so that a new signature can be created the next time the client user ID is used.
This method makes a synchronous HTTP request by default. To make 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_captive_recipient(account_id, recipient_part, callback=callback_function)
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_part: (required)
- CaptiveRecipientInformation captive_recipient_information:
Returns
CaptiveRecipientInformation If the method is called asynchronously, returns the request thread.
def
delete_captive_recipient_with_http_info(self, account_id, recipient_part, **kwargs)
1508 def delete_captive_recipient_with_http_info(self, account_id, recipient_part, **kwargs): 1509 """ 1510 Deletes the signature for one or more captive recipient records. 1511 Deletes the signature for one or more captive recipient records; it is primarily used for testing. This provides a way to reset the signature associated with a client user ID so that a new signature can be created the next time the client user ID is used. 1512 This method makes a synchronous HTTP request by default. To make an 1513 asynchronous HTTP request, please define a `callback` function 1514 to be invoked when receiving the response. 1515 >>> def callback_function(response): 1516 >>> pprint(response) 1517 >>> 1518 >>> thread = api.delete_captive_recipient_with_http_info(account_id, recipient_part, callback=callback_function) 1519 1520 :param callback function: The callback function 1521 for asynchronous request. (optional) 1522 :param str account_id: The external account number (int) or account ID Guid. (required) 1523 :param str recipient_part: (required) 1524 :param CaptiveRecipientInformation captive_recipient_information: 1525 :return: CaptiveRecipientInformation 1526 If the method is called asynchronously, 1527 returns the request thread. 1528 """ 1529 1530 all_params = ['account_id', 'recipient_part', 'captive_recipient_information'] 1531 all_params.append('callback') 1532 all_params.append('_return_http_data_only') 1533 all_params.append('_preload_content') 1534 all_params.append('_request_timeout') 1535 1536 params = locals() 1537 for key, val in iteritems(params['kwargs']): 1538 if key not in all_params: 1539 raise TypeError( 1540 "Got an unexpected keyword argument '%s'" 1541 " to method delete_captive_recipient" % key 1542 ) 1543 params[key] = val 1544 del params['kwargs'] 1545 # verify the required parameter 'account_id' is set 1546 if ('account_id' not in params) or (params['account_id'] is None): 1547 raise ValueError("Missing the required parameter `account_id` when calling `delete_captive_recipient`") 1548 # verify the required parameter 'recipient_part' is set 1549 if ('recipient_part' not in params) or (params['recipient_part'] is None): 1550 raise ValueError("Missing the required parameter `recipient_part` when calling `delete_captive_recipient`") 1551 1552 1553 collection_formats = {} 1554 1555 resource_path = '/v2.1/accounts/{accountId}/captive_recipients/{recipientPart}'.replace('{format}', 'json') 1556 path_params = {} 1557 if 'account_id' in params: 1558 path_params['accountId'] = params['account_id'] 1559 if 'recipient_part' in params: 1560 path_params['recipientPart'] = params['recipient_part'] 1561 1562 query_params = {} 1563 1564 header_params = {} 1565 1566 form_params = [] 1567 local_var_files = {} 1568 1569 body_params = None 1570 if 'captive_recipient_information' in params: 1571 body_params = params['captive_recipient_information'] 1572 # HTTP header `Accept` 1573 header_params['Accept'] = self.api_client.\ 1574 select_header_accept(['application/json']) 1575 1576 # Authentication setting 1577 auth_settings = [] 1578 1579 return self.api_client.call_api(resource_path, 'DELETE', 1580 path_params, 1581 query_params, 1582 header_params, 1583 body=body_params, 1584 post_params=form_params, 1585 files=local_var_files, 1586 response_type='CaptiveRecipientInformation', 1587 auth_settings=auth_settings, 1588 callback=params.get('callback'), 1589 _return_http_data_only=params.get('_return_http_data_only'), 1590 _preload_content=params.get('_preload_content', True), 1591 _request_timeout=params.get('_request_timeout'), 1592 collection_formats=collection_formats)
Deletes the signature for one or more captive recipient records.
Deletes the signature for one or more captive recipient records; it is primarily used for testing. This provides a way to reset the signature associated with a client user ID so that a new signature can be created the next time the client user ID is used.
This method makes a synchronous HTTP request by default. To make 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_captive_recipient_with_http_info(account_id, recipient_part, callback=callback_function)
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_part: (required)
- CaptiveRecipientInformation captive_recipient_information:
Returns
CaptiveRecipientInformation If the method is called asynchronously, returns the request thread.
def
delete_custom_field(self, account_id, custom_field_id, **kwargs)
1594 def delete_custom_field(self, account_id, custom_field_id, **kwargs): 1595 """ 1596 Delete an existing account custom field. 1597 This method deletes an existing account custom field. 1598 This method makes a synchronous HTTP request by default. To make an 1599 asynchronous HTTP request, please define a `callback` function 1600 to be invoked when receiving the response. 1601 >>> def callback_function(response): 1602 >>> pprint(response) 1603 >>> 1604 >>> thread = api.delete_custom_field(account_id, custom_field_id, callback=callback_function) 1605 1606 :param callback function: The callback function 1607 for asynchronous request. (optional) 1608 :param str account_id: The external account number (int) or account ID Guid. (required) 1609 :param str custom_field_id: (required) 1610 :param str apply_to_templates: 1611 :return: None 1612 If the method is called asynchronously, 1613 returns the request thread. 1614 """ 1615 kwargs['_return_http_data_only'] = True 1616 if kwargs.get('callback'): 1617 return self.delete_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 1618 else: 1619 (data) = self.delete_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 1620 return data
Delete an existing account custom field.
This method deletes an existing account custom field.
This method makes a synchronous HTTP request by default. To make 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_field(account_id, custom_field_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str custom_field_id: (required)
- str apply_to_templates:
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs)
1622 def delete_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs): 1623 """ 1624 Delete an existing account custom field. 1625 This method deletes an existing account custom field. 1626 This method makes a synchronous HTTP request by default. To make an 1627 asynchronous HTTP request, please define a `callback` function 1628 to be invoked when receiving the response. 1629 >>> def callback_function(response): 1630 >>> pprint(response) 1631 >>> 1632 >>> thread = api.delete_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function) 1633 1634 :param callback function: The callback function 1635 for asynchronous request. (optional) 1636 :param str account_id: The external account number (int) or account ID Guid. (required) 1637 :param str custom_field_id: (required) 1638 :param str apply_to_templates: 1639 :return: None 1640 If the method is called asynchronously, 1641 returns the request thread. 1642 """ 1643 1644 all_params = ['account_id', 'custom_field_id', 'apply_to_templates'] 1645 all_params.append('callback') 1646 all_params.append('_return_http_data_only') 1647 all_params.append('_preload_content') 1648 all_params.append('_request_timeout') 1649 1650 params = locals() 1651 for key, val in iteritems(params['kwargs']): 1652 if key not in all_params: 1653 raise TypeError( 1654 "Got an unexpected keyword argument '%s'" 1655 " to method delete_custom_field" % key 1656 ) 1657 params[key] = val 1658 del params['kwargs'] 1659 # verify the required parameter 'account_id' is set 1660 if ('account_id' not in params) or (params['account_id'] is None): 1661 raise ValueError("Missing the required parameter `account_id` when calling `delete_custom_field`") 1662 # verify the required parameter 'custom_field_id' is set 1663 if ('custom_field_id' not in params) or (params['custom_field_id'] is None): 1664 raise ValueError("Missing the required parameter `custom_field_id` when calling `delete_custom_field`") 1665 1666 1667 collection_formats = {} 1668 1669 resource_path = '/v2.1/accounts/{accountId}/custom_fields/{customFieldId}'.replace('{format}', 'json') 1670 path_params = {} 1671 if 'account_id' in params: 1672 path_params['accountId'] = params['account_id'] 1673 if 'custom_field_id' in params: 1674 path_params['customFieldId'] = params['custom_field_id'] 1675 1676 query_params = {} 1677 if 'apply_to_templates' in params: 1678 query_params['apply_to_templates'] = params['apply_to_templates'] 1679 1680 header_params = {} 1681 1682 form_params = [] 1683 local_var_files = {} 1684 1685 body_params = None 1686 # HTTP header `Accept` 1687 header_params['Accept'] = self.api_client.\ 1688 select_header_accept(['application/json']) 1689 1690 # Authentication setting 1691 auth_settings = [] 1692 1693 return self.api_client.call_api(resource_path, 'DELETE', 1694 path_params, 1695 query_params, 1696 header_params, 1697 body=body_params, 1698 post_params=form_params, 1699 files=local_var_files, 1700 response_type=None, 1701 auth_settings=auth_settings, 1702 callback=params.get('callback'), 1703 _return_http_data_only=params.get('_return_http_data_only'), 1704 _preload_content=params.get('_preload_content', True), 1705 _request_timeout=params.get('_request_timeout'), 1706 collection_formats=collection_formats)
Delete an existing account custom field.
This method deletes an existing account custom field.
This method makes a synchronous HTTP request by default. To make 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_field_with_http_info(account_id, custom_field_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str custom_field_id: (required)
- str apply_to_templates:
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_e_note_configuration(self, account_id, **kwargs)
1708 def delete_e_note_configuration(self, account_id, **kwargs): 1709 """ 1710 Deletes configuration information for the eNote eOriginal integration. 1711 1712 This method makes a synchronous HTTP request by default. To make an 1713 asynchronous HTTP request, please define a `callback` function 1714 to be invoked when receiving the response. 1715 >>> def callback_function(response): 1716 >>> pprint(response) 1717 >>> 1718 >>> thread = api.delete_e_note_configuration(account_id, callback=callback_function) 1719 1720 :param callback function: The callback function 1721 for asynchronous request. (optional) 1722 :param str account_id: The external account number (int) or account ID Guid. (required) 1723 :return: None 1724 If the method is called asynchronously, 1725 returns the request thread. 1726 """ 1727 kwargs['_return_http_data_only'] = True 1728 if kwargs.get('callback'): 1729 return self.delete_e_note_configuration_with_http_info(account_id, **kwargs) 1730 else: 1731 (data) = self.delete_e_note_configuration_with_http_info(account_id, **kwargs) 1732 return data
Deletes configuration information for the eNote eOriginal integration.
This method makes a synchronous HTTP request by default. To make 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_e_note_configuration(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)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_e_note_configuration_with_http_info(self, account_id, **kwargs)
1734 def delete_e_note_configuration_with_http_info(self, account_id, **kwargs): 1735 """ 1736 Deletes configuration information for the eNote eOriginal integration. 1737 1738 This method makes a synchronous HTTP request by default. To make an 1739 asynchronous HTTP request, please define a `callback` function 1740 to be invoked when receiving the response. 1741 >>> def callback_function(response): 1742 >>> pprint(response) 1743 >>> 1744 >>> thread = api.delete_e_note_configuration_with_http_info(account_id, callback=callback_function) 1745 1746 :param callback function: The callback function 1747 for asynchronous request. (optional) 1748 :param str account_id: The external account number (int) or account ID Guid. (required) 1749 :return: None 1750 If the method is called asynchronously, 1751 returns the request thread. 1752 """ 1753 1754 all_params = ['account_id'] 1755 all_params.append('callback') 1756 all_params.append('_return_http_data_only') 1757 all_params.append('_preload_content') 1758 all_params.append('_request_timeout') 1759 1760 params = locals() 1761 for key, val in iteritems(params['kwargs']): 1762 if key not in all_params: 1763 raise TypeError( 1764 "Got an unexpected keyword argument '%s'" 1765 " to method delete_e_note_configuration" % key 1766 ) 1767 params[key] = val 1768 del params['kwargs'] 1769 # verify the required parameter 'account_id' is set 1770 if ('account_id' not in params) or (params['account_id'] is None): 1771 raise ValueError("Missing the required parameter `account_id` when calling `delete_e_note_configuration`") 1772 1773 1774 collection_formats = {} 1775 1776 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 1777 path_params = {} 1778 if 'account_id' in params: 1779 path_params['accountId'] = params['account_id'] 1780 1781 query_params = {} 1782 1783 header_params = {} 1784 1785 form_params = [] 1786 local_var_files = {} 1787 1788 body_params = None 1789 # HTTP header `Accept` 1790 header_params['Accept'] = self.api_client.\ 1791 select_header_accept(['application/json']) 1792 1793 # Authentication setting 1794 auth_settings = [] 1795 1796 return self.api_client.call_api(resource_path, 'DELETE', 1797 path_params, 1798 query_params, 1799 header_params, 1800 body=body_params, 1801 post_params=form_params, 1802 files=local_var_files, 1803 response_type=None, 1804 auth_settings=auth_settings, 1805 callback=params.get('callback'), 1806 _return_http_data_only=params.get('_return_http_data_only'), 1807 _preload_content=params.get('_preload_content', True), 1808 _request_timeout=params.get('_request_timeout'), 1809 collection_formats=collection_formats)
Deletes configuration information for the eNote eOriginal integration.
This method makes a synchronous HTTP request by default. To make 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_e_note_configuration_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)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_permission_profile(self, account_id, permission_profile_id, **kwargs)
1811 def delete_permission_profile(self, account_id, permission_profile_id, **kwargs): 1812 """ 1813 Deletes a permissions profile within the specified account. 1814 This method deletes a permission profile from an account. To delete a permission profile, it must not have any users associated with it. When you use this method to delete a permission profile, you can reassign the users associated with it to a new permission profile at the same time by using the `move_users_to` query parameter. ### Related topics - [How to delete a permission profile](/docs/esign-rest-api/how-to/permission-profile-deleting/) 1815 This method makes a synchronous HTTP request by default. To make an 1816 asynchronous HTTP request, please define a `callback` function 1817 to be invoked when receiving the response. 1818 >>> def callback_function(response): 1819 >>> pprint(response) 1820 >>> 1821 >>> thread = api.delete_permission_profile(account_id, permission_profile_id, callback=callback_function) 1822 1823 :param callback function: The callback function 1824 for asynchronous request. (optional) 1825 :param str account_id: The external account number (int) or account ID Guid. (required) 1826 :param str permission_profile_id: (required) 1827 :param str move_users_to: 1828 :return: None 1829 If the method is called asynchronously, 1830 returns the request thread. 1831 """ 1832 kwargs['_return_http_data_only'] = True 1833 if kwargs.get('callback'): 1834 return self.delete_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 1835 else: 1836 (data) = self.delete_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 1837 return data
Deletes a permissions profile within the specified account.
This method deletes a permission profile from an account. To delete a permission profile, it must not have any users associated with it. When you use this method to delete a permission profile, you can reassign the users associated with it to a new permission profile at the same time by using the move_users_to query parameter. ### Related topics - How to delete a permission profile
This method makes a synchronous HTTP request by default. To make 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_permission_profile(account_id, permission_profile_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str permission_profile_id: (required)
- str move_users_to:
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs)
1839 def delete_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 1840 """ 1841 Deletes a permissions profile within the specified account. 1842 This method deletes a permission profile from an account. To delete a permission profile, it must not have any users associated with it. When you use this method to delete a permission profile, you can reassign the users associated with it to a new permission profile at the same time by using the `move_users_to` query parameter. ### Related topics - [How to delete a permission profile](/docs/esign-rest-api/how-to/permission-profile-deleting/) 1843 This method makes a synchronous HTTP request by default. To make an 1844 asynchronous HTTP request, please define a `callback` function 1845 to be invoked when receiving the response. 1846 >>> def callback_function(response): 1847 >>> pprint(response) 1848 >>> 1849 >>> thread = api.delete_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 1850 1851 :param callback function: The callback function 1852 for asynchronous request. (optional) 1853 :param str account_id: The external account number (int) or account ID Guid. (required) 1854 :param str permission_profile_id: (required) 1855 :param str move_users_to: 1856 :return: None 1857 If the method is called asynchronously, 1858 returns the request thread. 1859 """ 1860 1861 all_params = ['account_id', 'permission_profile_id', 'move_users_to'] 1862 all_params.append('callback') 1863 all_params.append('_return_http_data_only') 1864 all_params.append('_preload_content') 1865 all_params.append('_request_timeout') 1866 1867 params = locals() 1868 for key, val in iteritems(params['kwargs']): 1869 if key not in all_params: 1870 raise TypeError( 1871 "Got an unexpected keyword argument '%s'" 1872 " to method delete_permission_profile" % key 1873 ) 1874 params[key] = val 1875 del params['kwargs'] 1876 # verify the required parameter 'account_id' is set 1877 if ('account_id' not in params) or (params['account_id'] is None): 1878 raise ValueError("Missing the required parameter `account_id` when calling `delete_permission_profile`") 1879 # verify the required parameter 'permission_profile_id' is set 1880 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 1881 raise ValueError("Missing the required parameter `permission_profile_id` when calling `delete_permission_profile`") 1882 1883 1884 collection_formats = {} 1885 1886 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 1887 path_params = {} 1888 if 'account_id' in params: 1889 path_params['accountId'] = params['account_id'] 1890 if 'permission_profile_id' in params: 1891 path_params['permissionProfileId'] = params['permission_profile_id'] 1892 1893 query_params = {} 1894 if 'move_users_to' in params: 1895 query_params['move_users_to'] = params['move_users_to'] 1896 1897 header_params = {} 1898 1899 form_params = [] 1900 local_var_files = {} 1901 1902 body_params = None 1903 # HTTP header `Accept` 1904 header_params['Accept'] = self.api_client.\ 1905 select_header_accept(['application/json']) 1906 1907 # Authentication setting 1908 auth_settings = [] 1909 1910 return self.api_client.call_api(resource_path, 'DELETE', 1911 path_params, 1912 query_params, 1913 header_params, 1914 body=body_params, 1915 post_params=form_params, 1916 files=local_var_files, 1917 response_type=None, 1918 auth_settings=auth_settings, 1919 callback=params.get('callback'), 1920 _return_http_data_only=params.get('_return_http_data_only'), 1921 _preload_content=params.get('_preload_content', True), 1922 _request_timeout=params.get('_request_timeout'), 1923 collection_formats=collection_formats)
Deletes a permissions profile within the specified account.
This method deletes a permission profile from an account. To delete a permission profile, it must not have any users associated with it. When you use this method to delete a permission profile, you can reassign the users associated with it to a new permission profile at the same time by using the move_users_to query parameter. ### Related topics - How to delete a permission profile
This method makes a synchronous HTTP request by default. To make 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_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str permission_profile_id: (required)
- str move_users_to:
Returns
None If the method is called asynchronously, returns the request thread.
def
get_account_identity_verification(self, account_id, **kwargs)
2152 def get_account_identity_verification(self, account_id, **kwargs): 2153 """ 2154 Get the list of identity verification options for an account 2155 This method returns a list of Identity Verification workflows that are available to an account. **Note:** To use this method, you must either be an account administrator or a sender. ### Related topics - [How to require ID Verification (IDV) for a recipient](/docs/esign-rest-api/how-to/id-verification/) 2156 This method makes a synchronous HTTP request by default. To make an 2157 asynchronous HTTP request, please define a `callback` function 2158 to be invoked when receiving the response. 2159 >>> def callback_function(response): 2160 >>> pprint(response) 2161 >>> 2162 >>> thread = api.get_account_identity_verification(account_id, callback=callback_function) 2163 2164 :param callback function: The callback function 2165 for asynchronous request. (optional) 2166 :param str account_id: The external account number (int) or account ID Guid. (required) 2167 :param str identity_verification_workflow_status: 2168 :return: AccountIdentityVerificationResponse 2169 If the method is called asynchronously, 2170 returns the request thread. 2171 """ 2172 kwargs['_return_http_data_only'] = True 2173 if kwargs.get('callback'): 2174 return self.get_account_identity_verification_with_http_info(account_id, **kwargs) 2175 else: 2176 (data) = self.get_account_identity_verification_with_http_info(account_id, **kwargs) 2177 return data
Get the list of identity verification options for an account
This method returns a list of Identity Verification workflows that are available to an account. Note: To use this method, you must either be an account administrator or a sender. ### Related topics - How to require ID Verification (IDV) 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_account_identity_verification(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 identity_verification_workflow_status:
Returns
AccountIdentityVerificationResponse If the method is called asynchronously, returns the request thread.
def
get_account_identity_verification_with_http_info(self, account_id, **kwargs)
2179 def get_account_identity_verification_with_http_info(self, account_id, **kwargs): 2180 """ 2181 Get the list of identity verification options for an account 2182 This method returns a list of Identity Verification workflows that are available to an account. **Note:** To use this method, you must either be an account administrator or a sender. ### Related topics - [How to require ID Verification (IDV) for a recipient](/docs/esign-rest-api/how-to/id-verification/) 2183 This method makes a synchronous HTTP request by default. To make an 2184 asynchronous HTTP request, please define a `callback` function 2185 to be invoked when receiving the response. 2186 >>> def callback_function(response): 2187 >>> pprint(response) 2188 >>> 2189 >>> thread = api.get_account_identity_verification_with_http_info(account_id, callback=callback_function) 2190 2191 :param callback function: The callback function 2192 for asynchronous request. (optional) 2193 :param str account_id: The external account number (int) or account ID Guid. (required) 2194 :param str identity_verification_workflow_status: 2195 :return: AccountIdentityVerificationResponse 2196 If the method is called asynchronously, 2197 returns the request thread. 2198 """ 2199 2200 all_params = ['account_id', 'identity_verification_workflow_status'] 2201 all_params.append('callback') 2202 all_params.append('_return_http_data_only') 2203 all_params.append('_preload_content') 2204 all_params.append('_request_timeout') 2205 2206 params = locals() 2207 for key, val in iteritems(params['kwargs']): 2208 if key not in all_params: 2209 raise TypeError( 2210 "Got an unexpected keyword argument '%s'" 2211 " to method get_account_identity_verification" % key 2212 ) 2213 params[key] = val 2214 del params['kwargs'] 2215 # verify the required parameter 'account_id' is set 2216 if ('account_id' not in params) or (params['account_id'] is None): 2217 raise ValueError("Missing the required parameter `account_id` when calling `get_account_identity_verification`") 2218 2219 2220 collection_formats = {} 2221 2222 resource_path = '/v2.1/accounts/{accountId}/identity_verification'.replace('{format}', 'json') 2223 path_params = {} 2224 if 'account_id' in params: 2225 path_params['accountId'] = params['account_id'] 2226 2227 query_params = {} 2228 if 'identity_verification_workflow_status' in params: 2229 query_params['identity_verification_workflow_status'] = params['identity_verification_workflow_status'] 2230 2231 header_params = {} 2232 2233 form_params = [] 2234 local_var_files = {} 2235 2236 body_params = None 2237 # HTTP header `Accept` 2238 header_params['Accept'] = self.api_client.\ 2239 select_header_accept(['application/json']) 2240 2241 # Authentication setting 2242 auth_settings = [] 2243 2244 return self.api_client.call_api(resource_path, 'GET', 2245 path_params, 2246 query_params, 2247 header_params, 2248 body=body_params, 2249 post_params=form_params, 2250 files=local_var_files, 2251 response_type='AccountIdentityVerificationResponse', 2252 auth_settings=auth_settings, 2253 callback=params.get('callback'), 2254 _return_http_data_only=params.get('_return_http_data_only'), 2255 _preload_content=params.get('_preload_content', True), 2256 _request_timeout=params.get('_request_timeout'), 2257 collection_formats=collection_formats)
Get the list of identity verification options for an account
This method returns a list of Identity Verification workflows that are available to an account. Note: To use this method, you must either be an account administrator or a sender. ### Related topics - How to require ID Verification (IDV) 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_account_identity_verification_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 identity_verification_workflow_status:
Returns
AccountIdentityVerificationResponse If the method is called asynchronously, returns the request thread.
def
get_account_information(self, account_id, **kwargs)
2259 def get_account_information(self, account_id, **kwargs): 2260 """ 2261 Retrieves the account information for the specified account. 2262 Retrieves the account information for the specified account. **Response** The `canUpgrade` property contains is a Boolean that indicates whether the account can be upgraded through the API. 2263 This method makes a synchronous HTTP request by default. To make an 2264 asynchronous HTTP request, please define a `callback` function 2265 to be invoked when receiving the response. 2266 >>> def callback_function(response): 2267 >>> pprint(response) 2268 >>> 2269 >>> thread = api.get_account_information(account_id, callback=callback_function) 2270 2271 :param callback function: The callback function 2272 for asynchronous request. (optional) 2273 :param str account_id: The external account number (int) or account ID Guid. (required) 2274 :param str include_account_settings: When set to **true**, includes the account settings for the account in the response. 2275 :return: AccountInformation 2276 If the method is called asynchronously, 2277 returns the request thread. 2278 """ 2279 kwargs['_return_http_data_only'] = True 2280 if kwargs.get('callback'): 2281 return self.get_account_information_with_http_info(account_id, **kwargs) 2282 else: 2283 (data) = self.get_account_information_with_http_info(account_id, **kwargs) 2284 return data
Retrieves the account information for the specified account.
Retrieves the account information for the specified account. Response The canUpgrade property contains is a Boolean that indicates whether the account can be upgraded through the 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.get_account_information(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 include_account_settings: When set to true, includes the account settings for the account in the response.
Returns
AccountInformation If the method is called asynchronously, returns the request thread.
def
get_account_information_with_http_info(self, account_id, **kwargs)
2286 def get_account_information_with_http_info(self, account_id, **kwargs): 2287 """ 2288 Retrieves the account information for the specified account. 2289 Retrieves the account information for the specified account. **Response** The `canUpgrade` property contains is a Boolean that indicates whether the account can be upgraded through the API. 2290 This method makes a synchronous HTTP request by default. To make an 2291 asynchronous HTTP request, please define a `callback` function 2292 to be invoked when receiving the response. 2293 >>> def callback_function(response): 2294 >>> pprint(response) 2295 >>> 2296 >>> thread = api.get_account_information_with_http_info(account_id, callback=callback_function) 2297 2298 :param callback function: The callback function 2299 for asynchronous request. (optional) 2300 :param str account_id: The external account number (int) or account ID Guid. (required) 2301 :param str include_account_settings: When set to **true**, includes the account settings for the account in the response. 2302 :return: AccountInformation 2303 If the method is called asynchronously, 2304 returns the request thread. 2305 """ 2306 2307 all_params = ['account_id', 'include_account_settings'] 2308 all_params.append('callback') 2309 all_params.append('_return_http_data_only') 2310 all_params.append('_preload_content') 2311 all_params.append('_request_timeout') 2312 2313 params = locals() 2314 for key, val in iteritems(params['kwargs']): 2315 if key not in all_params: 2316 raise TypeError( 2317 "Got an unexpected keyword argument '%s'" 2318 " to method get_account_information" % key 2319 ) 2320 params[key] = val 2321 del params['kwargs'] 2322 # verify the required parameter 'account_id' is set 2323 if ('account_id' not in params) or (params['account_id'] is None): 2324 raise ValueError("Missing the required parameter `account_id` when calling `get_account_information`") 2325 2326 2327 collection_formats = {} 2328 2329 resource_path = '/v2.1/accounts/{accountId}'.replace('{format}', 'json') 2330 path_params = {} 2331 if 'account_id' in params: 2332 path_params['accountId'] = params['account_id'] 2333 2334 query_params = {} 2335 if 'include_account_settings' in params: 2336 query_params['include_account_settings'] = params['include_account_settings'] 2337 2338 header_params = {} 2339 2340 form_params = [] 2341 local_var_files = {} 2342 2343 body_params = None 2344 # HTTP header `Accept` 2345 header_params['Accept'] = self.api_client.\ 2346 select_header_accept(['application/json']) 2347 2348 # Authentication setting 2349 auth_settings = [] 2350 2351 return self.api_client.call_api(resource_path, 'GET', 2352 path_params, 2353 query_params, 2354 header_params, 2355 body=body_params, 2356 post_params=form_params, 2357 files=local_var_files, 2358 response_type='AccountInformation', 2359 auth_settings=auth_settings, 2360 callback=params.get('callback'), 2361 _return_http_data_only=params.get('_return_http_data_only'), 2362 _preload_content=params.get('_preload_content', True), 2363 _request_timeout=params.get('_request_timeout'), 2364 collection_formats=collection_formats)
Retrieves the account information for the specified account.
Retrieves the account information for the specified account. Response The canUpgrade property contains is a Boolean that indicates whether the account can be upgraded through the 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.get_account_information_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 include_account_settings: When set to true, includes the account settings for the account in the response.
Returns
AccountInformation If the method is called asynchronously, returns the request thread.
def
get_account_signature(self, account_id, signature_id, **kwargs)
2366 def get_account_signature(self, account_id, signature_id, **kwargs): 2367 """ 2368 Returns information about a single signature by specifed signatureId. 2369 2370 This method makes a synchronous HTTP request by default. To make an 2371 asynchronous HTTP request, please define a `callback` function 2372 to be invoked when receiving the response. 2373 >>> def callback_function(response): 2374 >>> pprint(response) 2375 >>> 2376 >>> thread = api.get_account_signature(account_id, signature_id, callback=callback_function) 2377 2378 :param callback function: The callback function 2379 for asynchronous request. (optional) 2380 :param str account_id: The external account number (int) or account ID Guid. (required) 2381 :param str signature_id: The ID of the signature being accessed. (required) 2382 :return: AccountSignature 2383 If the method is called asynchronously, 2384 returns the request thread. 2385 """ 2386 kwargs['_return_http_data_only'] = True 2387 if kwargs.get('callback'): 2388 return self.get_account_signature_with_http_info(account_id, signature_id, **kwargs) 2389 else: 2390 (data) = self.get_account_signature_with_http_info(account_id, signature_id, **kwargs) 2391 return data
Returns information about a single signature by specifed signatureId.
This method makes a synchronous HTTP request by default. To make 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_account_signature(account_id, signature_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str signature_id: The ID of the signature being accessed. (required)
Returns
AccountSignature If the method is called asynchronously, returns the request thread.
def
get_account_signature_with_http_info(self, account_id, signature_id, **kwargs)
2393 def get_account_signature_with_http_info(self, account_id, signature_id, **kwargs): 2394 """ 2395 Returns information about a single signature by specifed signatureId. 2396 2397 This method makes a synchronous HTTP request by default. To make an 2398 asynchronous HTTP request, please define a `callback` function 2399 to be invoked when receiving the response. 2400 >>> def callback_function(response): 2401 >>> pprint(response) 2402 >>> 2403 >>> thread = api.get_account_signature_with_http_info(account_id, signature_id, callback=callback_function) 2404 2405 :param callback function: The callback function 2406 for asynchronous request. (optional) 2407 :param str account_id: The external account number (int) or account ID Guid. (required) 2408 :param str signature_id: The ID of the signature being accessed. (required) 2409 :return: AccountSignature 2410 If the method is called asynchronously, 2411 returns the request thread. 2412 """ 2413 2414 all_params = ['account_id', 'signature_id'] 2415 all_params.append('callback') 2416 all_params.append('_return_http_data_only') 2417 all_params.append('_preload_content') 2418 all_params.append('_request_timeout') 2419 2420 params = locals() 2421 for key, val in iteritems(params['kwargs']): 2422 if key not in all_params: 2423 raise TypeError( 2424 "Got an unexpected keyword argument '%s'" 2425 " to method get_account_signature" % key 2426 ) 2427 params[key] = val 2428 del params['kwargs'] 2429 # verify the required parameter 'account_id' is set 2430 if ('account_id' not in params) or (params['account_id'] is None): 2431 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signature`") 2432 # verify the required parameter 'signature_id' is set 2433 if ('signature_id' not in params) or (params['signature_id'] is None): 2434 raise ValueError("Missing the required parameter `signature_id` when calling `get_account_signature`") 2435 2436 2437 collection_formats = {} 2438 2439 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 2440 path_params = {} 2441 if 'account_id' in params: 2442 path_params['accountId'] = params['account_id'] 2443 if 'signature_id' in params: 2444 path_params['signatureId'] = params['signature_id'] 2445 2446 query_params = {} 2447 2448 header_params = {} 2449 2450 form_params = [] 2451 local_var_files = {} 2452 2453 body_params = None 2454 # HTTP header `Accept` 2455 header_params['Accept'] = self.api_client.\ 2456 select_header_accept(['application/json']) 2457 2458 # Authentication setting 2459 auth_settings = [] 2460 2461 return self.api_client.call_api(resource_path, 'GET', 2462 path_params, 2463 query_params, 2464 header_params, 2465 body=body_params, 2466 post_params=form_params, 2467 files=local_var_files, 2468 response_type='AccountSignature', 2469 auth_settings=auth_settings, 2470 callback=params.get('callback'), 2471 _return_http_data_only=params.get('_return_http_data_only'), 2472 _preload_content=params.get('_preload_content', True), 2473 _request_timeout=params.get('_request_timeout'), 2474 collection_formats=collection_formats)
Returns information about a single signature by specifed signatureId.
This method makes a synchronous HTTP request by default. To make 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_account_signature_with_http_info(account_id, signature_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str signature_id: The ID of the signature being accessed. (required)
Returns
AccountSignature If the method is called asynchronously, returns the request thread.
def
get_account_signature_image(self, account_id, image_type, signature_id, **kwargs)
2476 def get_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 2477 """ 2478 Returns a signature, initials, or stamps image. 2479 2480 This method makes a synchronous HTTP request by default. To make an 2481 asynchronous HTTP request, please define a `callback` function 2482 to be invoked when receiving the response. 2483 >>> def callback_function(response): 2484 >>> pprint(response) 2485 >>> 2486 >>> thread = api.get_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 2487 2488 :param callback function: The callback function 2489 for asynchronous request. (optional) 2490 :param str account_id: The external account number (int) or account ID Guid. (required) 2491 :param str image_type: One of **signature_image** or **initials_image**. (required) 2492 :param str signature_id: The ID of the signature being accessed. (required) 2493 :param str include_chrome: 2494 :return: file 2495 If the method is called asynchronously, 2496 returns the request thread. 2497 """ 2498 kwargs['_return_http_data_only'] = True 2499 if kwargs.get('callback'): 2500 return self.get_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 2501 else: 2502 (data) = self.get_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 2503 return data
Returns a signature, initials, or stamps 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_account_signature_image(account_id, image_type, signature_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str image_type: One of signature_image or initials_image. (required)
- str signature_id: The ID of the signature being accessed. (required)
- str include_chrome:
Returns
file If the method is called asynchronously, returns the request thread.
def
get_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs)
2505 def get_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 2506 """ 2507 Returns a signature, initials, or stamps image. 2508 2509 This method makes a synchronous HTTP request by default. To make an 2510 asynchronous HTTP request, please define a `callback` function 2511 to be invoked when receiving the response. 2512 >>> def callback_function(response): 2513 >>> pprint(response) 2514 >>> 2515 >>> thread = api.get_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 2516 2517 :param callback function: The callback function 2518 for asynchronous request. (optional) 2519 :param str account_id: The external account number (int) or account ID Guid. (required) 2520 :param str image_type: One of **signature_image** or **initials_image**. (required) 2521 :param str signature_id: The ID of the signature being accessed. (required) 2522 :param str include_chrome: 2523 :return: file 2524 If the method is called asynchronously, 2525 returns the request thread. 2526 """ 2527 2528 all_params = ['account_id', 'image_type', 'signature_id', 'include_chrome'] 2529 all_params.append('callback') 2530 all_params.append('_return_http_data_only') 2531 all_params.append('_preload_content') 2532 all_params.append('_request_timeout') 2533 2534 params = locals() 2535 for key, val in iteritems(params['kwargs']): 2536 if key not in all_params: 2537 raise TypeError( 2538 "Got an unexpected keyword argument '%s'" 2539 " to method get_account_signature_image" % key 2540 ) 2541 params[key] = val 2542 del params['kwargs'] 2543 # verify the required parameter 'account_id' is set 2544 if ('account_id' not in params) or (params['account_id'] is None): 2545 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signature_image`") 2546 # verify the required parameter 'image_type' is set 2547 if ('image_type' not in params) or (params['image_type'] is None): 2548 raise ValueError("Missing the required parameter `image_type` when calling `get_account_signature_image`") 2549 # verify the required parameter 'signature_id' is set 2550 if ('signature_id' not in params) or (params['signature_id'] is None): 2551 raise ValueError("Missing the required parameter `signature_id` when calling `get_account_signature_image`") 2552 2553 2554 collection_formats = {} 2555 2556 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 2557 path_params = {} 2558 if 'account_id' in params: 2559 path_params['accountId'] = params['account_id'] 2560 if 'image_type' in params: 2561 path_params['imageType'] = params['image_type'] 2562 if 'signature_id' in params: 2563 path_params['signatureId'] = params['signature_id'] 2564 2565 query_params = {} 2566 if 'include_chrome' in params: 2567 query_params['include_chrome'] = params['include_chrome'] 2568 2569 header_params = {} 2570 2571 form_params = [] 2572 local_var_files = {} 2573 2574 body_params = None 2575 # HTTP header `Accept` 2576 header_params['Accept'] = self.api_client.\ 2577 select_header_accept(['image/gif']) 2578 2579 # Authentication setting 2580 auth_settings = [] 2581 2582 return self.api_client.call_api(resource_path, 'GET', 2583 path_params, 2584 query_params, 2585 header_params, 2586 body=body_params, 2587 post_params=form_params, 2588 files=local_var_files, 2589 response_type='file', 2590 auth_settings=auth_settings, 2591 callback=params.get('callback'), 2592 _return_http_data_only=params.get('_return_http_data_only'), 2593 _preload_content=params.get('_preload_content', True), 2594 _request_timeout=params.get('_request_timeout'), 2595 collection_formats=collection_formats)
Returns a signature, initials, or stamps 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_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str image_type: One of signature_image or initials_image. (required)
- str signature_id: The ID of the signature being accessed. (required)
- str include_chrome:
Returns
file If the method is called asynchronously, returns the request thread.
def
get_account_signatures(self, account_id, **kwargs)
2597 def get_account_signatures(self, account_id, **kwargs): 2598 """ 2599 Returns the managed signature definitions for the account 2600 2601 This method makes a synchronous HTTP request by default. To make an 2602 asynchronous HTTP request, please define a `callback` function 2603 to be invoked when receiving the response. 2604 >>> def callback_function(response): 2605 >>> pprint(response) 2606 >>> 2607 >>> thread = api.get_account_signatures(account_id, callback=callback_function) 2608 2609 :param callback function: The callback function 2610 for asynchronous request. (optional) 2611 :param str account_id: The external account number (int) or account ID Guid. (required) 2612 :param str stamp_format: 2613 :param str stamp_name: 2614 :param str stamp_type: 2615 :return: AccountSignaturesInformation 2616 If the method is called asynchronously, 2617 returns the request thread. 2618 """ 2619 kwargs['_return_http_data_only'] = True 2620 if kwargs.get('callback'): 2621 return self.get_account_signatures_with_http_info(account_id, **kwargs) 2622 else: 2623 (data) = self.get_account_signatures_with_http_info(account_id, **kwargs) 2624 return data
Returns the managed signature definitions for 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_account_signatures(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 stamp_format:
- str stamp_name:
- str stamp_type:
Returns
AccountSignaturesInformation If the method is called asynchronously, returns the request thread.
def
get_account_signatures_with_http_info(self, account_id, **kwargs)
2626 def get_account_signatures_with_http_info(self, account_id, **kwargs): 2627 """ 2628 Returns the managed signature definitions for the account 2629 2630 This method makes a synchronous HTTP request by default. To make an 2631 asynchronous HTTP request, please define a `callback` function 2632 to be invoked when receiving the response. 2633 >>> def callback_function(response): 2634 >>> pprint(response) 2635 >>> 2636 >>> thread = api.get_account_signatures_with_http_info(account_id, callback=callback_function) 2637 2638 :param callback function: The callback function 2639 for asynchronous request. (optional) 2640 :param str account_id: The external account number (int) or account ID Guid. (required) 2641 :param str stamp_format: 2642 :param str stamp_name: 2643 :param str stamp_type: 2644 :return: AccountSignaturesInformation 2645 If the method is called asynchronously, 2646 returns the request thread. 2647 """ 2648 2649 all_params = ['account_id', 'stamp_format', 'stamp_name', 'stamp_type'] 2650 all_params.append('callback') 2651 all_params.append('_return_http_data_only') 2652 all_params.append('_preload_content') 2653 all_params.append('_request_timeout') 2654 2655 params = locals() 2656 for key, val in iteritems(params['kwargs']): 2657 if key not in all_params: 2658 raise TypeError( 2659 "Got an unexpected keyword argument '%s'" 2660 " to method get_account_signatures" % key 2661 ) 2662 params[key] = val 2663 del params['kwargs'] 2664 # verify the required parameter 'account_id' is set 2665 if ('account_id' not in params) or (params['account_id'] is None): 2666 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signatures`") 2667 2668 2669 collection_formats = {} 2670 2671 resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json') 2672 path_params = {} 2673 if 'account_id' in params: 2674 path_params['accountId'] = params['account_id'] 2675 2676 query_params = {} 2677 if 'stamp_format' in params: 2678 query_params['stamp_format'] = params['stamp_format'] 2679 if 'stamp_name' in params: 2680 query_params['stamp_name'] = params['stamp_name'] 2681 if 'stamp_type' in params: 2682 query_params['stamp_type'] = params['stamp_type'] 2683 2684 header_params = {} 2685 2686 form_params = [] 2687 local_var_files = {} 2688 2689 body_params = None 2690 # HTTP header `Accept` 2691 header_params['Accept'] = self.api_client.\ 2692 select_header_accept(['application/json']) 2693 2694 # Authentication setting 2695 auth_settings = [] 2696 2697 return self.api_client.call_api(resource_path, 'GET', 2698 path_params, 2699 query_params, 2700 header_params, 2701 body=body_params, 2702 post_params=form_params, 2703 files=local_var_files, 2704 response_type='AccountSignaturesInformation', 2705 auth_settings=auth_settings, 2706 callback=params.get('callback'), 2707 _return_http_data_only=params.get('_return_http_data_only'), 2708 _preload_content=params.get('_preload_content', True), 2709 _request_timeout=params.get('_request_timeout'), 2710 collection_formats=collection_formats)
Returns the managed signature definitions for 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_account_signatures_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 stamp_format:
- str stamp_name:
- str stamp_type:
Returns
AccountSignaturesInformation If the method is called asynchronously, returns the request thread.
def
get_account_tab_settings(self, account_id, **kwargs)
2712 def get_account_tab_settings(self, account_id, **kwargs): 2713 """ 2714 Returns tab settings list for specified account 2715 This method returns information about the tab types and tab functionality that is currently enabled for an account. 2716 This method makes a synchronous HTTP request by default. To make an 2717 asynchronous HTTP request, please define a `callback` function 2718 to be invoked when receiving the response. 2719 >>> def callback_function(response): 2720 >>> pprint(response) 2721 >>> 2722 >>> thread = api.get_account_tab_settings(account_id, callback=callback_function) 2723 2724 :param callback function: The callback function 2725 for asynchronous request. (optional) 2726 :param str account_id: The external account number (int) or account ID Guid. (required) 2727 :return: TabAccountSettings 2728 If the method is called asynchronously, 2729 returns the request thread. 2730 """ 2731 kwargs['_return_http_data_only'] = True 2732 if kwargs.get('callback'): 2733 return self.get_account_tab_settings_with_http_info(account_id, **kwargs) 2734 else: 2735 (data) = self.get_account_tab_settings_with_http_info(account_id, **kwargs) 2736 return data
Returns tab settings list for specified account
This method returns information about the tab types and tab functionality that is currently enabled for an 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_account_tab_settings(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)
Returns
TabAccountSettings If the method is called asynchronously, returns the request thread.
def
get_account_tab_settings_with_http_info(self, account_id, **kwargs)
2738 def get_account_tab_settings_with_http_info(self, account_id, **kwargs): 2739 """ 2740 Returns tab settings list for specified account 2741 This method returns information about the tab types and tab functionality that is currently enabled for an account. 2742 This method makes a synchronous HTTP request by default. To make an 2743 asynchronous HTTP request, please define a `callback` function 2744 to be invoked when receiving the response. 2745 >>> def callback_function(response): 2746 >>> pprint(response) 2747 >>> 2748 >>> thread = api.get_account_tab_settings_with_http_info(account_id, callback=callback_function) 2749 2750 :param callback function: The callback function 2751 for asynchronous request. (optional) 2752 :param str account_id: The external account number (int) or account ID Guid. (required) 2753 :return: TabAccountSettings 2754 If the method is called asynchronously, 2755 returns the request thread. 2756 """ 2757 2758 all_params = ['account_id'] 2759 all_params.append('callback') 2760 all_params.append('_return_http_data_only') 2761 all_params.append('_preload_content') 2762 all_params.append('_request_timeout') 2763 2764 params = locals() 2765 for key, val in iteritems(params['kwargs']): 2766 if key not in all_params: 2767 raise TypeError( 2768 "Got an unexpected keyword argument '%s'" 2769 " to method get_account_tab_settings" % key 2770 ) 2771 params[key] = val 2772 del params['kwargs'] 2773 # verify the required parameter 'account_id' is set 2774 if ('account_id' not in params) or (params['account_id'] is None): 2775 raise ValueError("Missing the required parameter `account_id` when calling `get_account_tab_settings`") 2776 2777 2778 collection_formats = {} 2779 2780 resource_path = '/v2.1/accounts/{accountId}/settings/tabs'.replace('{format}', 'json') 2781 path_params = {} 2782 if 'account_id' in params: 2783 path_params['accountId'] = params['account_id'] 2784 2785 query_params = {} 2786 2787 header_params = {} 2788 2789 form_params = [] 2790 local_var_files = {} 2791 2792 body_params = None 2793 # HTTP header `Accept` 2794 header_params['Accept'] = self.api_client.\ 2795 select_header_accept(['application/json']) 2796 2797 # Authentication setting 2798 auth_settings = [] 2799 2800 return self.api_client.call_api(resource_path, 'GET', 2801 path_params, 2802 query_params, 2803 header_params, 2804 body=body_params, 2805 post_params=form_params, 2806 files=local_var_files, 2807 response_type='TabAccountSettings', 2808 auth_settings=auth_settings, 2809 callback=params.get('callback'), 2810 _return_http_data_only=params.get('_return_http_data_only'), 2811 _preload_content=params.get('_preload_content', True), 2812 _request_timeout=params.get('_request_timeout'), 2813 collection_formats=collection_formats)
Returns tab settings list for specified account
This method returns information about the tab types and tab functionality that is currently enabled for an 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_account_tab_settings_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)
Returns
TabAccountSettings If the method is called asynchronously, returns the request thread.
def
get_all_payment_gateway_accounts(self, account_id, **kwargs)
2951 def get_all_payment_gateway_accounts(self, account_id, **kwargs): 2952 """ 2953 Get all payment gateway account for the provided accountId 2954 This method returns a list of payment gateway accounts and basic information about them. 2955 This method makes a synchronous HTTP request by default. To make an 2956 asynchronous HTTP request, please define a `callback` function 2957 to be invoked when receiving the response. 2958 >>> def callback_function(response): 2959 >>> pprint(response) 2960 >>> 2961 >>> thread = api.get_all_payment_gateway_accounts(account_id, callback=callback_function) 2962 2963 :param callback function: The callback function 2964 for asynchronous request. (optional) 2965 :param str account_id: The external account number (int) or account ID Guid. (required) 2966 :return: PaymentGatewayAccountsInfo 2967 If the method is called asynchronously, 2968 returns the request thread. 2969 """ 2970 kwargs['_return_http_data_only'] = True 2971 if kwargs.get('callback'): 2972 return self.get_all_payment_gateway_accounts_with_http_info(account_id, **kwargs) 2973 else: 2974 (data) = self.get_all_payment_gateway_accounts_with_http_info(account_id, **kwargs) 2975 return data
Get all payment gateway account for the provided accountId
This method returns a list of payment gateway accounts and basic information about them.
This method makes a synchronous HTTP request by default. To make 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_all_payment_gateway_accounts(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)
Returns
PaymentGatewayAccountsInfo If the method is called asynchronously, returns the request thread.
def
get_all_payment_gateway_accounts_with_http_info(self, account_id, **kwargs)
2977 def get_all_payment_gateway_accounts_with_http_info(self, account_id, **kwargs): 2978 """ 2979 Get all payment gateway account for the provided accountId 2980 This method returns a list of payment gateway accounts and basic information about them. 2981 This method makes a synchronous HTTP request by default. To make an 2982 asynchronous HTTP request, please define a `callback` function 2983 to be invoked when receiving the response. 2984 >>> def callback_function(response): 2985 >>> pprint(response) 2986 >>> 2987 >>> thread = api.get_all_payment_gateway_accounts_with_http_info(account_id, callback=callback_function) 2988 2989 :param callback function: The callback function 2990 for asynchronous request. (optional) 2991 :param str account_id: The external account number (int) or account ID Guid. (required) 2992 :return: PaymentGatewayAccountsInfo 2993 If the method is called asynchronously, 2994 returns the request thread. 2995 """ 2996 2997 all_params = ['account_id'] 2998 all_params.append('callback') 2999 all_params.append('_return_http_data_only') 3000 all_params.append('_preload_content') 3001 all_params.append('_request_timeout') 3002 3003 params = locals() 3004 for key, val in iteritems(params['kwargs']): 3005 if key not in all_params: 3006 raise TypeError( 3007 "Got an unexpected keyword argument '%s'" 3008 " to method get_all_payment_gateway_accounts" % key 3009 ) 3010 params[key] = val 3011 del params['kwargs'] 3012 # verify the required parameter 'account_id' is set 3013 if ('account_id' not in params) or (params['account_id'] is None): 3014 raise ValueError("Missing the required parameter `account_id` when calling `get_all_payment_gateway_accounts`") 3015 3016 3017 collection_formats = {} 3018 3019 resource_path = '/v2.1/accounts/{accountId}/payment_gateway_accounts'.replace('{format}', 'json') 3020 path_params = {} 3021 if 'account_id' in params: 3022 path_params['accountId'] = params['account_id'] 3023 3024 query_params = {} 3025 3026 header_params = {} 3027 3028 form_params = [] 3029 local_var_files = {} 3030 3031 body_params = None 3032 # HTTP header `Accept` 3033 header_params['Accept'] = self.api_client.\ 3034 select_header_accept(['application/json']) 3035 3036 # Authentication setting 3037 auth_settings = [] 3038 3039 return self.api_client.call_api(resource_path, 'GET', 3040 path_params, 3041 query_params, 3042 header_params, 3043 body=body_params, 3044 post_params=form_params, 3045 files=local_var_files, 3046 response_type='PaymentGatewayAccountsInfo', 3047 auth_settings=auth_settings, 3048 callback=params.get('callback'), 3049 _return_http_data_only=params.get('_return_http_data_only'), 3050 _preload_content=params.get('_preload_content', True), 3051 _request_timeout=params.get('_request_timeout'), 3052 collection_formats=collection_formats)
Get all payment gateway account for the provided accountId
This method returns a list of payment gateway accounts and basic information about them.
This method makes a synchronous HTTP request by default. To make 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_all_payment_gateway_accounts_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)
Returns
PaymentGatewayAccountsInfo If the method is called asynchronously, returns the request thread.
def
get_billing_charges(self, account_id, **kwargs)
3054 def get_billing_charges(self, account_id, **kwargs): 3055 """ 3056 Gets list of recurring and usage charges for the account. 3057 Retrieves the list of recurring and usage charges for the account. This can be used to determine the charge structure and usage of charge plan items. Privileges required: account administrator 3058 This method makes a synchronous HTTP request by default. To make an 3059 asynchronous HTTP request, please define a `callback` function 3060 to be invoked when receiving the response. 3061 >>> def callback_function(response): 3062 >>> pprint(response) 3063 >>> 3064 >>> thread = api.get_billing_charges(account_id, callback=callback_function) 3065 3066 :param callback function: The callback function 3067 for asynchronous request. (optional) 3068 :param str account_id: The external account number (int) or account ID Guid. (required) 3069 :param str include_charges: Specifies which billing charges to return. Valid values are: * envelopes * seats 3070 :return: BillingChargeResponse 3071 If the method is called asynchronously, 3072 returns the request thread. 3073 """ 3074 kwargs['_return_http_data_only'] = True 3075 if kwargs.get('callback'): 3076 return self.get_billing_charges_with_http_info(account_id, **kwargs) 3077 else: 3078 (data) = self.get_billing_charges_with_http_info(account_id, **kwargs) 3079 return data
Gets list of recurring and usage charges for the account.
Retrieves the list of recurring and usage charges for the account. This can be used to determine the charge structure and usage of charge plan items. Privileges required: account administrator
This method makes a synchronous HTTP request by default. To make 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_billing_charges(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 include_charges: Specifies which billing charges to return. Valid values are: * envelopes * seats
Returns
BillingChargeResponse If the method is called asynchronously, returns the request thread.
def
get_billing_charges_with_http_info(self, account_id, **kwargs)
3081 def get_billing_charges_with_http_info(self, account_id, **kwargs): 3082 """ 3083 Gets list of recurring and usage charges for the account. 3084 Retrieves the list of recurring and usage charges for the account. This can be used to determine the charge structure and usage of charge plan items. Privileges required: account administrator 3085 This method makes a synchronous HTTP request by default. To make an 3086 asynchronous HTTP request, please define a `callback` function 3087 to be invoked when receiving the response. 3088 >>> def callback_function(response): 3089 >>> pprint(response) 3090 >>> 3091 >>> thread = api.get_billing_charges_with_http_info(account_id, callback=callback_function) 3092 3093 :param callback function: The callback function 3094 for asynchronous request. (optional) 3095 :param str account_id: The external account number (int) or account ID Guid. (required) 3096 :param str include_charges: Specifies which billing charges to return. Valid values are: * envelopes * seats 3097 :return: BillingChargeResponse 3098 If the method is called asynchronously, 3099 returns the request thread. 3100 """ 3101 3102 all_params = ['account_id', 'include_charges'] 3103 all_params.append('callback') 3104 all_params.append('_return_http_data_only') 3105 all_params.append('_preload_content') 3106 all_params.append('_request_timeout') 3107 3108 params = locals() 3109 for key, val in iteritems(params['kwargs']): 3110 if key not in all_params: 3111 raise TypeError( 3112 "Got an unexpected keyword argument '%s'" 3113 " to method get_billing_charges" % key 3114 ) 3115 params[key] = val 3116 del params['kwargs'] 3117 # verify the required parameter 'account_id' is set 3118 if ('account_id' not in params) or (params['account_id'] is None): 3119 raise ValueError("Missing the required parameter `account_id` when calling `get_billing_charges`") 3120 3121 3122 collection_formats = {} 3123 3124 resource_path = '/v2.1/accounts/{accountId}/billing_charges'.replace('{format}', 'json') 3125 path_params = {} 3126 if 'account_id' in params: 3127 path_params['accountId'] = params['account_id'] 3128 3129 query_params = {} 3130 if 'include_charges' in params: 3131 query_params['include_charges'] = params['include_charges'] 3132 3133 header_params = {} 3134 3135 form_params = [] 3136 local_var_files = {} 3137 3138 body_params = None 3139 # HTTP header `Accept` 3140 header_params['Accept'] = self.api_client.\ 3141 select_header_accept(['application/json']) 3142 3143 # Authentication setting 3144 auth_settings = [] 3145 3146 return self.api_client.call_api(resource_path, 'GET', 3147 path_params, 3148 query_params, 3149 header_params, 3150 body=body_params, 3151 post_params=form_params, 3152 files=local_var_files, 3153 response_type='BillingChargeResponse', 3154 auth_settings=auth_settings, 3155 callback=params.get('callback'), 3156 _return_http_data_only=params.get('_return_http_data_only'), 3157 _preload_content=params.get('_preload_content', True), 3158 _request_timeout=params.get('_request_timeout'), 3159 collection_formats=collection_formats)
Gets list of recurring and usage charges for the account.
Retrieves the list of recurring and usage charges for the account. This can be used to determine the charge structure and usage of charge plan items. Privileges required: account administrator
This method makes a synchronous HTTP request by default. To make 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_billing_charges_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 include_charges: Specifies which billing charges to return. Valid values are: * envelopes * seats
Returns
BillingChargeResponse If the method is called asynchronously, returns the request thread.
def
get_brand(self, account_id, brand_id, **kwargs)
3161 def get_brand(self, account_id, brand_id, **kwargs): 3162 """ 3163 Get information for a specific brand. 3164 This method returns details about an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 3165 This method makes a synchronous HTTP request by default. To make an 3166 asynchronous HTTP request, please define a `callback` function 3167 to be invoked when receiving the response. 3168 >>> def callback_function(response): 3169 >>> pprint(response) 3170 >>> 3171 >>> thread = api.get_brand(account_id, brand_id, callback=callback_function) 3172 3173 :param callback function: The callback function 3174 for asynchronous request. (optional) 3175 :param str account_id: The external account number (int) or account ID Guid. (required) 3176 :param str brand_id: The unique identifier of a brand. (required) 3177 :param str include_external_references: 3178 :param str include_logos: 3179 :return: Brand 3180 If the method is called asynchronously, 3181 returns the request thread. 3182 """ 3183 kwargs['_return_http_data_only'] = True 3184 if kwargs.get('callback'): 3185 return self.get_brand_with_http_info(account_id, brand_id, **kwargs) 3186 else: 3187 (data) = self.get_brand_with_http_info(account_id, brand_id, **kwargs) 3188 return data
Get information for a specific brand.
This method returns details about an account brand. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be 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_brand(account_id, brand_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str brand_id: The unique identifier of a brand. (required)
- str include_external_references:
- str include_logos:
Returns
Brand If the method is called asynchronously, returns the request thread.
def
get_brand_with_http_info(self, account_id, brand_id, **kwargs)
3190 def get_brand_with_http_info(self, account_id, brand_id, **kwargs): 3191 """ 3192 Get information for a specific brand. 3193 This method returns details about an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 3194 This method makes a synchronous HTTP request by default. To make an 3195 asynchronous HTTP request, please define a `callback` function 3196 to be invoked when receiving the response. 3197 >>> def callback_function(response): 3198 >>> pprint(response) 3199 >>> 3200 >>> thread = api.get_brand_with_http_info(account_id, brand_id, callback=callback_function) 3201 3202 :param callback function: The callback function 3203 for asynchronous request. (optional) 3204 :param str account_id: The external account number (int) or account ID Guid. (required) 3205 :param str brand_id: The unique identifier of a brand. (required) 3206 :param str include_external_references: 3207 :param str include_logos: 3208 :return: Brand 3209 If the method is called asynchronously, 3210 returns the request thread. 3211 """ 3212 3213 all_params = ['account_id', 'brand_id', 'include_external_references', 'include_logos'] 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 get_brand" % 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 `get_brand`") 3231 # verify the required parameter 'brand_id' is set 3232 if ('brand_id' not in params) or (params['brand_id'] is None): 3233 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand`") 3234 3235 3236 collection_formats = {} 3237 3238 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 3239 path_params = {} 3240 if 'account_id' in params: 3241 path_params['accountId'] = params['account_id'] 3242 if 'brand_id' in params: 3243 path_params['brandId'] = params['brand_id'] 3244 3245 query_params = {} 3246 if 'include_external_references' in params: 3247 query_params['include_external_references'] = params['include_external_references'] 3248 if 'include_logos' in params: 3249 query_params['include_logos'] = params['include_logos'] 3250 3251 header_params = {} 3252 3253 form_params = [] 3254 local_var_files = {} 3255 3256 body_params = None 3257 # HTTP header `Accept` 3258 header_params['Accept'] = self.api_client.\ 3259 select_header_accept(['application/json']) 3260 3261 # Authentication setting 3262 auth_settings = [] 3263 3264 return self.api_client.call_api(resource_path, 'GET', 3265 path_params, 3266 query_params, 3267 header_params, 3268 body=body_params, 3269 post_params=form_params, 3270 files=local_var_files, 3271 response_type='Brand', 3272 auth_settings=auth_settings, 3273 callback=params.get('callback'), 3274 _return_http_data_only=params.get('_return_http_data_only'), 3275 _preload_content=params.get('_preload_content', True), 3276 _request_timeout=params.get('_request_timeout'), 3277 collection_formats=collection_formats)
Get information for a specific brand.
This method returns details about an account brand. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be 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_brand_with_http_info(account_id, brand_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str brand_id: The unique identifier of a brand. (required)
- str include_external_references:
- str include_logos:
Returns
Brand If the method is called asynchronously, returns the request thread.
def
get_brand_export_file(self, account_id, brand_id, **kwargs)
3279 def get_brand_export_file(self, account_id, brand_id, **kwargs): 3280 """ 3281 Export a specific brand. 3282 This method exports information about a brand to an XML file. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 3283 This method makes a synchronous HTTP request by default. To make an 3284 asynchronous HTTP request, please define a `callback` function 3285 to be invoked when receiving the response. 3286 >>> def callback_function(response): 3287 >>> pprint(response) 3288 >>> 3289 >>> thread = api.get_brand_export_file(account_id, brand_id, callback=callback_function) 3290 3291 :param callback function: The callback function 3292 for asynchronous request. (optional) 3293 :param str account_id: The external account number (int) or account ID Guid. (required) 3294 :param str brand_id: The unique identifier of a brand. (required) 3295 :return: None 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.get_brand_export_file_with_http_info(account_id, brand_id, **kwargs) 3302 else: 3303 (data) = self.get_brand_export_file_with_http_info(account_id, brand_id, **kwargs) 3304 return data
Export a specific brand.
This method exports information about a brand to an XML file. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be 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_brand_export_file(account_id, brand_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str brand_id: The unique identifier of a brand. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
get_brand_export_file_with_http_info(self, account_id, brand_id, **kwargs)
3306 def get_brand_export_file_with_http_info(self, account_id, brand_id, **kwargs): 3307 """ 3308 Export a specific brand. 3309 This method exports information about a brand to an XML file. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 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.get_brand_export_file_with_http_info(account_id, brand_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 brand_id: The unique identifier of a brand. (required) 3322 :return: None 3323 If the method is called asynchronously, 3324 returns the request thread. 3325 """ 3326 3327 all_params = ['account_id', 'brand_id'] 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 get_brand_export_file" % 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 `get_brand_export_file`") 3345 # verify the required parameter 'brand_id' is set 3346 if ('brand_id' not in params) or (params['brand_id'] is None): 3347 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_export_file`") 3348 3349 3350 collection_formats = {} 3351 3352 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/file'.replace('{format}', 'json') 3353 path_params = {} 3354 if 'account_id' in params: 3355 path_params['accountId'] = params['account_id'] 3356 if 'brand_id' in params: 3357 path_params['brandId'] = params['brand_id'] 3358 3359 query_params = {} 3360 3361 header_params = {} 3362 3363 form_params = [] 3364 local_var_files = {} 3365 3366 body_params = None 3367 # HTTP header `Accept` 3368 header_params['Accept'] = self.api_client.\ 3369 select_header_accept(['application/json']) 3370 3371 # Authentication setting 3372 auth_settings = [] 3373 3374 return self.api_client.call_api(resource_path, 'GET', 3375 path_params, 3376 query_params, 3377 header_params, 3378 body=body_params, 3379 post_params=form_params, 3380 files=local_var_files, 3381 response_type=None, 3382 auth_settings=auth_settings, 3383 callback=params.get('callback'), 3384 _return_http_data_only=params.get('_return_http_data_only'), 3385 _preload_content=params.get('_preload_content', True), 3386 _request_timeout=params.get('_request_timeout'), 3387 collection_formats=collection_formats)
Export a specific brand.
This method exports information about a brand to an XML file. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be 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_brand_export_file_with_http_info(account_id, brand_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str brand_id: The unique identifier of a brand. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
get_brand_logo_by_type(self, account_id, brand_id, logo_type, **kwargs)
3389 def get_brand_logo_by_type(self, account_id, brand_id, logo_type, **kwargs): 3390 """ 3391 Obtains the specified image for a brand. 3392 This method returns a specific logo that is used in a brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 3393 This method makes a synchronous HTTP request by default. To make an 3394 asynchronous HTTP request, please define a `callback` function 3395 to be invoked when receiving the response. 3396 >>> def callback_function(response): 3397 >>> pprint(response) 3398 >>> 3399 >>> thread = api.get_brand_logo_by_type(account_id, brand_id, logo_type, callback=callback_function) 3400 3401 :param callback function: The callback function 3402 for asynchronous request. (optional) 3403 :param str account_id: The external account number (int) or account ID Guid. (required) 3404 :param str brand_id: The unique identifier of a brand. (required) 3405 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 3406 :return: file 3407 If the method is called asynchronously, 3408 returns the request thread. 3409 """ 3410 kwargs['_return_http_data_only'] = True 3411 if kwargs.get('callback'): 3412 return self.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 3413 else: 3414 (data) = self.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 3415 return data
Obtains the specified image for a brand.
This method returns a specific logo that is used in a brand. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be 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_brand_logo_by_type(account_id, brand_id, logo_type, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str brand_id: The unique identifier of a brand. (required)
- str logo_type: One of Primary, Secondary or Email. (required)
Returns
file If the method is called asynchronously, returns the request thread.
def
get_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, **kwargs)
3417 def get_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, **kwargs): 3418 """ 3419 Obtains the specified image for a brand. 3420 This method returns a specific logo that is used in a brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 3421 This method makes a synchronous HTTP request by default. To make an 3422 asynchronous HTTP request, please define a `callback` function 3423 to be invoked when receiving the response. 3424 >>> def callback_function(response): 3425 >>> pprint(response) 3426 >>> 3427 >>> thread = api.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, callback=callback_function) 3428 3429 :param callback function: The callback function 3430 for asynchronous request. (optional) 3431 :param str account_id: The external account number (int) or account ID Guid. (required) 3432 :param str brand_id: The unique identifier of a brand. (required) 3433 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 3434 :return: file 3435 If the method is called asynchronously, 3436 returns the request thread. 3437 """ 3438 3439 all_params = ['account_id', 'brand_id', 'logo_type'] 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 get_brand_logo_by_type" % 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 `get_brand_logo_by_type`") 3457 # verify the required parameter 'brand_id' is set 3458 if ('brand_id' not in params) or (params['brand_id'] is None): 3459 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_logo_by_type`") 3460 # verify the required parameter 'logo_type' is set 3461 if ('logo_type' not in params) or (params['logo_type'] is None): 3462 raise ValueError("Missing the required parameter `logo_type` when calling `get_brand_logo_by_type`") 3463 3464 3465 collection_formats = {} 3466 3467 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 3468 path_params = {} 3469 if 'account_id' in params: 3470 path_params['accountId'] = params['account_id'] 3471 if 'brand_id' in params: 3472 path_params['brandId'] = params['brand_id'] 3473 if 'logo_type' in params: 3474 path_params['logoType'] = params['logo_type'] 3475 3476 query_params = {} 3477 3478 header_params = {} 3479 3480 form_params = [] 3481 local_var_files = {} 3482 3483 body_params = None 3484 # HTTP header `Accept` 3485 header_params['Accept'] = self.api_client.\ 3486 select_header_accept(['image/png']) 3487 3488 # Authentication setting 3489 auth_settings = [] 3490 3491 return self.api_client.call_api(resource_path, 'GET', 3492 path_params, 3493 query_params, 3494 header_params, 3495 body=body_params, 3496 post_params=form_params, 3497 files=local_var_files, 3498 response_type='file', 3499 auth_settings=auth_settings, 3500 callback=params.get('callback'), 3501 _return_http_data_only=params.get('_return_http_data_only'), 3502 _preload_content=params.get('_preload_content', True), 3503 _request_timeout=params.get('_request_timeout'), 3504 collection_formats=collection_formats)
Obtains the specified image for a brand.
This method returns a specific logo that is used in a brand. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be 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_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str brand_id: The unique identifier of a brand. (required)
- str logo_type: One of Primary, Secondary or Email. (required)
Returns
file If the method is called asynchronously, returns the request thread.
def
get_brand_resources(self, account_id, brand_id, **kwargs)
3506 def get_brand_resources(self, account_id, brand_id, **kwargs): 3507 """ 3508 Returns the specified account's list of branding resources (metadata). 3509 This method returns metadata about the branding resources that are associated with an account. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 3510 This method makes a synchronous HTTP request by default. To make an 3511 asynchronous HTTP request, please define a `callback` function 3512 to be invoked when receiving the response. 3513 >>> def callback_function(response): 3514 >>> pprint(response) 3515 >>> 3516 >>> thread = api.get_brand_resources(account_id, brand_id, callback=callback_function) 3517 3518 :param callback function: The callback function 3519 for asynchronous request. (optional) 3520 :param str account_id: The external account number (int) or account ID Guid. (required) 3521 :param str brand_id: The unique identifier of a brand. (required) 3522 :return: BrandResourcesList 3523 If the method is called asynchronously, 3524 returns the request thread. 3525 """ 3526 kwargs['_return_http_data_only'] = True 3527 if kwargs.get('callback'): 3528 return self.get_brand_resources_with_http_info(account_id, brand_id, **kwargs) 3529 else: 3530 (data) = self.get_brand_resources_with_http_info(account_id, brand_id, **kwargs) 3531 return data
Returns the specified account's list of branding resources (metadata).
This method returns metadata about the branding resources that are associated with an account. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be 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_brand_resources(account_id, brand_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str brand_id: The unique identifier of a brand. (required)
Returns
BrandResourcesList If the method is called asynchronously, returns the request thread.
def
get_brand_resources_with_http_info(self, account_id, brand_id, **kwargs)
3533 def get_brand_resources_with_http_info(self, account_id, brand_id, **kwargs): 3534 """ 3535 Returns the specified account's list of branding resources (metadata). 3536 This method returns metadata about the branding resources that are associated with an account. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 3537 This method makes a synchronous HTTP request by default. To make an 3538 asynchronous HTTP request, please define a `callback` function 3539 to be invoked when receiving the response. 3540 >>> def callback_function(response): 3541 >>> pprint(response) 3542 >>> 3543 >>> thread = api.get_brand_resources_with_http_info(account_id, brand_id, callback=callback_function) 3544 3545 :param callback function: The callback function 3546 for asynchronous request. (optional) 3547 :param str account_id: The external account number (int) or account ID Guid. (required) 3548 :param str brand_id: The unique identifier of a brand. (required) 3549 :return: BrandResourcesList 3550 If the method is called asynchronously, 3551 returns the request thread. 3552 """ 3553 3554 all_params = ['account_id', 'brand_id'] 3555 all_params.append('callback') 3556 all_params.append('_return_http_data_only') 3557 all_params.append('_preload_content') 3558 all_params.append('_request_timeout') 3559 3560 params = locals() 3561 for key, val in iteritems(params['kwargs']): 3562 if key not in all_params: 3563 raise TypeError( 3564 "Got an unexpected keyword argument '%s'" 3565 " to method get_brand_resources" % key 3566 ) 3567 params[key] = val 3568 del params['kwargs'] 3569 # verify the required parameter 'account_id' is set 3570 if ('account_id' not in params) or (params['account_id'] is None): 3571 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_resources`") 3572 # verify the required parameter 'brand_id' is set 3573 if ('brand_id' not in params) or (params['brand_id'] is None): 3574 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_resources`") 3575 3576 3577 collection_formats = {} 3578 3579 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources'.replace('{format}', 'json') 3580 path_params = {} 3581 if 'account_id' in params: 3582 path_params['accountId'] = params['account_id'] 3583 if 'brand_id' in params: 3584 path_params['brandId'] = params['brand_id'] 3585 3586 query_params = {} 3587 3588 header_params = {} 3589 3590 form_params = [] 3591 local_var_files = {} 3592 3593 body_params = None 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, 'GET', 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='BrandResourcesList', 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)
Returns the specified account's list of branding resources (metadata).
This method returns metadata about the branding resources that are associated with an account. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be 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_brand_resources_with_http_info(account_id, brand_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str brand_id: The unique identifier of a brand. (required)
Returns
BrandResourcesList If the method is called asynchronously, returns the request thread.
def
get_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, **kwargs)
3616 def get_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, **kwargs): 3617 """ 3618 Returns the specified branding resource file. 3619 This method returns a specific branding resource file. A brand uses a set of brand resource files to control the sending, signing, email message, and captive (embedded) signing experiences. You can modify the default email messages and formats in these files and upload them to your brand to customize the user experience. **Important:** When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 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.get_brand_resources_by_content_type(account_id, brand_id, resource_content_type, 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 brand_id: The unique identifier of a brand. (required) 3632 :param str resource_content_type: (required) 3633 :param str langcode: 3634 :param str return_master: 3635 :return: None 3636 If the method is called asynchronously, 3637 returns the request thread. 3638 """ 3639 kwargs['_return_http_data_only'] = True 3640 if kwargs.get('callback'): 3641 return self.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, **kwargs) 3642 else: 3643 (data) = self.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, **kwargs) 3644 return data
Returns the specified branding resource file.
This method returns a specific branding resource file. A brand uses a set of brand resource files to control the sending, signing, email message, and captive (embedded) signing experiences. You can modify the default email messages and formats in these files and upload them to your brand to customize the user experience. Important: When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be 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_brand_resources_by_content_type(account_id, brand_id, resource_content_type, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str brand_id: The unique identifier of a brand. (required)
- str resource_content_type: (required)
- str langcode:
- str return_master:
Returns
None If the method is called asynchronously, returns the request thread.
def
get_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, **kwargs)
3646 def get_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, **kwargs): 3647 """ 3648 Returns the specified branding resource file. 3649 This method returns a specific branding resource file. A brand uses a set of brand resource files to control the sending, signing, email message, and captive (embedded) signing experiences. You can modify the default email messages and formats in these files and upload them to your brand to customize the user experience. **Important:** When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 3650 This method makes a synchronous HTTP request by default. To make an 3651 asynchronous HTTP request, please define a `callback` function 3652 to be invoked when receiving the response. 3653 >>> def callback_function(response): 3654 >>> pprint(response) 3655 >>> 3656 >>> thread = api.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, callback=callback_function) 3657 3658 :param callback function: The callback function 3659 for asynchronous request. (optional) 3660 :param str account_id: The external account number (int) or account ID Guid. (required) 3661 :param str brand_id: The unique identifier of a brand. (required) 3662 :param str resource_content_type: (required) 3663 :param str langcode: 3664 :param str return_master: 3665 :return: None 3666 If the method is called asynchronously, 3667 returns the request thread. 3668 """ 3669 3670 all_params = ['account_id', 'brand_id', 'resource_content_type', 'langcode', 'return_master'] 3671 all_params.append('callback') 3672 all_params.append('_return_http_data_only') 3673 all_params.append('_preload_content') 3674 all_params.append('_request_timeout') 3675 3676 params = locals() 3677 for key, val in iteritems(params['kwargs']): 3678 if key not in all_params: 3679 raise TypeError( 3680 "Got an unexpected keyword argument '%s'" 3681 " to method get_brand_resources_by_content_type" % key 3682 ) 3683 params[key] = val 3684 del params['kwargs'] 3685 # verify the required parameter 'account_id' is set 3686 if ('account_id' not in params) or (params['account_id'] is None): 3687 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_resources_by_content_type`") 3688 # verify the required parameter 'brand_id' is set 3689 if ('brand_id' not in params) or (params['brand_id'] is None): 3690 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_resources_by_content_type`") 3691 # verify the required parameter 'resource_content_type' is set 3692 if ('resource_content_type' not in params) or (params['resource_content_type'] is None): 3693 raise ValueError("Missing the required parameter `resource_content_type` when calling `get_brand_resources_by_content_type`") 3694 3695 3696 collection_formats = {} 3697 3698 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources/{resourceContentType}'.replace('{format}', 'json') 3699 path_params = {} 3700 if 'account_id' in params: 3701 path_params['accountId'] = params['account_id'] 3702 if 'brand_id' in params: 3703 path_params['brandId'] = params['brand_id'] 3704 if 'resource_content_type' in params: 3705 path_params['resourceContentType'] = params['resource_content_type'] 3706 3707 query_params = {} 3708 if 'langcode' in params: 3709 query_params['langcode'] = params['langcode'] 3710 if 'return_master' in params: 3711 query_params['return_master'] = params['return_master'] 3712 3713 header_params = {} 3714 3715 form_params = [] 3716 local_var_files = {} 3717 3718 body_params = None 3719 # HTTP header `Accept` 3720 header_params['Accept'] = self.api_client.\ 3721 select_header_accept(['application/json']) 3722 3723 # Authentication setting 3724 auth_settings = [] 3725 3726 return self.api_client.call_api(resource_path, 'GET', 3727 path_params, 3728 query_params, 3729 header_params, 3730 body=body_params, 3731 post_params=form_params, 3732 files=local_var_files, 3733 response_type=None, 3734 auth_settings=auth_settings, 3735 callback=params.get('callback'), 3736 _return_http_data_only=params.get('_return_http_data_only'), 3737 _preload_content=params.get('_preload_content', True), 3738 _request_timeout=params.get('_request_timeout'), 3739 collection_formats=collection_formats)
Returns the specified branding resource file.
This method returns a specific branding resource file. A brand uses a set of brand resource files to control the sending, signing, email message, and captive (embedded) signing experiences. You can modify the default email messages and formats in these files and upload them to your brand to customize the user experience. Important: When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be 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_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str brand_id: The unique identifier of a brand. (required)
- str resource_content_type: (required)
- str langcode:
- str return_master:
Returns
None If the method is called asynchronously, returns the request thread.
def
get_consumer_disclosure(self, account_id, lang_code, **kwargs)
3741 def get_consumer_disclosure(self, account_id, lang_code, **kwargs): 3742 """ 3743 Gets the Electronic Record and Signature Disclosure. 3744 Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, for the requested envelope recipient. This might be different than the current account disclosure depending on account settings, such as branding, and when the account disclosure was last updated. An optional query string can be included to return the language for the disclosure. 3745 This method makes a synchronous HTTP request by default. To make an 3746 asynchronous HTTP request, please define a `callback` function 3747 to be invoked when receiving the response. 3748 >>> def callback_function(response): 3749 >>> pprint(response) 3750 >>> 3751 >>> thread = api.get_consumer_disclosure(account_id, lang_code, callback=callback_function) 3752 3753 :param callback function: The callback function 3754 for asynchronous request. (optional) 3755 :param str account_id: The external account number (int) or account ID Guid. (required) 3756 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 3757 :return: ConsumerDisclosure 3758 If the method is called asynchronously, 3759 returns the request thread. 3760 """ 3761 kwargs['_return_http_data_only'] = True 3762 if kwargs.get('callback'): 3763 return self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 3764 else: 3765 (data) = self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 3766 return data
Gets the Electronic Record and Signature Disclosure.
Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, for the requested envelope recipient. This might be different than the current account disclosure depending on account settings, such as branding, and when the account disclosure was last updated. An optional query string can be included to return 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(account_id, lang_code, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are: Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required)
Returns
ConsumerDisclosure If the method is called asynchronously, returns the request thread.
def
get_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs)
3768 def get_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs): 3769 """ 3770 Gets the Electronic Record and Signature Disclosure. 3771 Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, for the requested envelope recipient. This might be different than the current account disclosure depending on account settings, such as branding, and when the account disclosure was last updated. An optional query string can be included to return the language for the disclosure. 3772 This method makes a synchronous HTTP request by default. To make an 3773 asynchronous HTTP request, please define a `callback` function 3774 to be invoked when receiving the response. 3775 >>> def callback_function(response): 3776 >>> pprint(response) 3777 >>> 3778 >>> thread = api.get_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function) 3779 3780 :param callback function: The callback function 3781 for asynchronous request. (optional) 3782 :param str account_id: The external account number (int) or account ID Guid. (required) 3783 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 3784 :return: ConsumerDisclosure 3785 If the method is called asynchronously, 3786 returns the request thread. 3787 """ 3788 3789 all_params = ['account_id', 'lang_code'] 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 get_consumer_disclosure" % 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 `get_consumer_disclosure`") 3807 # verify the required parameter 'lang_code' is set 3808 if ('lang_code' not in params) or (params['lang_code'] is None): 3809 raise ValueError("Missing the required parameter `lang_code` when calling `get_consumer_disclosure`") 3810 3811 3812 collection_formats = {} 3813 3814 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 3815 path_params = {} 3816 if 'account_id' in params: 3817 path_params['accountId'] = params['account_id'] 3818 if 'lang_code' in params: 3819 path_params['langCode'] = params['lang_code'] 3820 3821 query_params = {} 3822 3823 header_params = {} 3824 3825 form_params = [] 3826 local_var_files = {} 3827 3828 body_params = None 3829 # HTTP header `Accept` 3830 header_params['Accept'] = self.api_client.\ 3831 select_header_accept(['application/json']) 3832 3833 # Authentication setting 3834 auth_settings = [] 3835 3836 return self.api_client.call_api(resource_path, 'GET', 3837 path_params, 3838 query_params, 3839 header_params, 3840 body=body_params, 3841 post_params=form_params, 3842 files=local_var_files, 3843 response_type='ConsumerDisclosure', 3844 auth_settings=auth_settings, 3845 callback=params.get('callback'), 3846 _return_http_data_only=params.get('_return_http_data_only'), 3847 _preload_content=params.get('_preload_content', True), 3848 _request_timeout=params.get('_request_timeout'), 3849 collection_formats=collection_formats)
Gets the Electronic Record and Signature Disclosure.
Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, for the requested envelope recipient. This might be different than the current account disclosure depending on account settings, such as branding, and when the account disclosure was last updated. An optional query string can be included to return 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_with_http_info(account_id, lang_code, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are: Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required)
Returns
ConsumerDisclosure If the method is called asynchronously, returns the request thread.
def
get_consumer_disclosure_default(self, account_id, **kwargs)
3851 def get_consumer_disclosure_default(self, account_id, **kwargs): 3852 """ 3853 Gets the Electronic Record and Signature Disclosure for the account. 3854 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. 3855 This method makes a synchronous HTTP request by default. To make an 3856 asynchronous HTTP request, please define a `callback` function 3857 to be invoked when receiving the response. 3858 >>> def callback_function(response): 3859 >>> pprint(response) 3860 >>> 3861 >>> thread = api.get_consumer_disclosure_default(account_id, callback=callback_function) 3862 3863 :param callback function: The callback function 3864 for asynchronous request. (optional) 3865 :param str account_id: The external account number (int) or account ID Guid. (required) 3866 :param str lang_code: Specifies 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. 3867 :return: ConsumerDisclosure 3868 If the method is called asynchronously, 3869 returns the request thread. 3870 """ 3871 kwargs['_return_http_data_only'] = True 3872 if kwargs.get('callback'): 3873 return self.get_consumer_disclosure_default_with_http_info(account_id, **kwargs) 3874 else: 3875 (data) = self.get_consumer_disclosure_default_with_http_info(account_id, **kwargs) 3876 return data
Gets the Electronic Record and Signature Disclosure for 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, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str lang_code: Specifies 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
browserto 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_with_http_info(self, account_id, **kwargs)
3878 def get_consumer_disclosure_default_with_http_info(self, account_id, **kwargs): 3879 """ 3880 Gets the Electronic Record and Signature Disclosure for the account. 3881 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. 3882 This method makes a synchronous HTTP request by default. To make an 3883 asynchronous HTTP request, please define a `callback` function 3884 to be invoked when receiving the response. 3885 >>> def callback_function(response): 3886 >>> pprint(response) 3887 >>> 3888 >>> thread = api.get_consumer_disclosure_default_with_http_info(account_id, callback=callback_function) 3889 3890 :param callback function: The callback function 3891 for asynchronous request. (optional) 3892 :param str account_id: The external account number (int) or account ID Guid. (required) 3893 :param str lang_code: Specifies 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. 3894 :return: ConsumerDisclosure 3895 If the method is called asynchronously, 3896 returns the request thread. 3897 """ 3898 3899 all_params = ['account_id', 'lang_code'] 3900 all_params.append('callback') 3901 all_params.append('_return_http_data_only') 3902 all_params.append('_preload_content') 3903 all_params.append('_request_timeout') 3904 3905 params = locals() 3906 for key, val in iteritems(params['kwargs']): 3907 if key not in all_params: 3908 raise TypeError( 3909 "Got an unexpected keyword argument '%s'" 3910 " to method get_consumer_disclosure_default" % key 3911 ) 3912 params[key] = val 3913 del params['kwargs'] 3914 # verify the required parameter 'account_id' is set 3915 if ('account_id' not in params) or (params['account_id'] is None): 3916 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure_default`") 3917 3918 3919 collection_formats = {} 3920 3921 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure'.replace('{format}', 'json') 3922 path_params = {} 3923 if 'account_id' in params: 3924 path_params['accountId'] = params['account_id'] 3925 3926 query_params = {} 3927 if 'lang_code' in params: 3928 query_params['langCode'] = params['lang_code'] 3929 3930 header_params = {} 3931 3932 form_params = [] 3933 local_var_files = {} 3934 3935 body_params = None 3936 # HTTP header `Accept` 3937 header_params['Accept'] = self.api_client.\ 3938 select_header_accept(['application/json']) 3939 3940 # Authentication setting 3941 auth_settings = [] 3942 3943 return self.api_client.call_api(resource_path, 'GET', 3944 path_params, 3945 query_params, 3946 header_params, 3947 body=body_params, 3948 post_params=form_params, 3949 files=local_var_files, 3950 response_type='ConsumerDisclosure', 3951 auth_settings=auth_settings, 3952 callback=params.get('callback'), 3953 _return_http_data_only=params.get('_return_http_data_only'), 3954 _preload_content=params.get('_preload_content', True), 3955 _request_timeout=params.get('_request_timeout'), 3956 collection_formats=collection_formats)
Gets the Electronic Record and Signature Disclosure for 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, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str lang_code: Specifies 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
browserto 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_e_note_configuration(self, account_id, **kwargs)
3958 def get_e_note_configuration(self, account_id, **kwargs): 3959 """ 3960 Returns the configuration information for the eNote eOriginal integration. 3961 3962 This method makes a synchronous HTTP request by default. To make an 3963 asynchronous HTTP request, please define a `callback` function 3964 to be invoked when receiving the response. 3965 >>> def callback_function(response): 3966 >>> pprint(response) 3967 >>> 3968 >>> thread = api.get_e_note_configuration(account_id, callback=callback_function) 3969 3970 :param callback function: The callback function 3971 for asynchronous request. (optional) 3972 :param str account_id: The external account number (int) or account ID Guid. (required) 3973 :return: ENoteConfiguration 3974 If the method is called asynchronously, 3975 returns the request thread. 3976 """ 3977 kwargs['_return_http_data_only'] = True 3978 if kwargs.get('callback'): 3979 return self.get_e_note_configuration_with_http_info(account_id, **kwargs) 3980 else: 3981 (data) = self.get_e_note_configuration_with_http_info(account_id, **kwargs) 3982 return data
Returns the configuration information for the eNote eOriginal integration.
This method makes a synchronous HTTP request by default. To make 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_e_note_configuration(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)
Returns
ENoteConfiguration If the method is called asynchronously, returns the request thread.
def
get_e_note_configuration_with_http_info(self, account_id, **kwargs)
3984 def get_e_note_configuration_with_http_info(self, account_id, **kwargs): 3985 """ 3986 Returns the configuration information for the eNote eOriginal integration. 3987 3988 This method makes a synchronous HTTP request by default. To make an 3989 asynchronous HTTP request, please define a `callback` function 3990 to be invoked when receiving the response. 3991 >>> def callback_function(response): 3992 >>> pprint(response) 3993 >>> 3994 >>> thread = api.get_e_note_configuration_with_http_info(account_id, callback=callback_function) 3995 3996 :param callback function: The callback function 3997 for asynchronous request. (optional) 3998 :param str account_id: The external account number (int) or account ID Guid. (required) 3999 :return: ENoteConfiguration 4000 If the method is called asynchronously, 4001 returns the request thread. 4002 """ 4003 4004 all_params = ['account_id'] 4005 all_params.append('callback') 4006 all_params.append('_return_http_data_only') 4007 all_params.append('_preload_content') 4008 all_params.append('_request_timeout') 4009 4010 params = locals() 4011 for key, val in iteritems(params['kwargs']): 4012 if key not in all_params: 4013 raise TypeError( 4014 "Got an unexpected keyword argument '%s'" 4015 " to method get_e_note_configuration" % key 4016 ) 4017 params[key] = val 4018 del params['kwargs'] 4019 # verify the required parameter 'account_id' is set 4020 if ('account_id' not in params) or (params['account_id'] is None): 4021 raise ValueError("Missing the required parameter `account_id` when calling `get_e_note_configuration`") 4022 4023 4024 collection_formats = {} 4025 4026 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 4027 path_params = {} 4028 if 'account_id' in params: 4029 path_params['accountId'] = params['account_id'] 4030 4031 query_params = {} 4032 4033 header_params = {} 4034 4035 form_params = [] 4036 local_var_files = {} 4037 4038 body_params = None 4039 # HTTP header `Accept` 4040 header_params['Accept'] = self.api_client.\ 4041 select_header_accept(['application/json']) 4042 4043 # Authentication setting 4044 auth_settings = [] 4045 4046 return self.api_client.call_api(resource_path, 'GET', 4047 path_params, 4048 query_params, 4049 header_params, 4050 body=body_params, 4051 post_params=form_params, 4052 files=local_var_files, 4053 response_type='ENoteConfiguration', 4054 auth_settings=auth_settings, 4055 callback=params.get('callback'), 4056 _return_http_data_only=params.get('_return_http_data_only'), 4057 _preload_content=params.get('_preload_content', True), 4058 _request_timeout=params.get('_request_timeout'), 4059 collection_formats=collection_formats)
Returns the configuration information for the eNote eOriginal integration.
This method makes a synchronous HTTP request by default. To make 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_e_note_configuration_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)
Returns
ENoteConfiguration If the method is called asynchronously, returns the request thread.
def
get_envelope_purge_configuration(self, account_id, **kwargs)
4061 def get_envelope_purge_configuration(self, account_id, **kwargs): 4062 """ 4063 Select envelope purge configuration. 4064 An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method retrieves the current envelope purge configuration for your account. **Note:** To use this method, you must be an account administrator. 4065 This method makes a synchronous HTTP request by default. To make an 4066 asynchronous HTTP request, please define a `callback` function 4067 to be invoked when receiving the response. 4068 >>> def callback_function(response): 4069 >>> pprint(response) 4070 >>> 4071 >>> thread = api.get_envelope_purge_configuration(account_id, callback=callback_function) 4072 4073 :param callback function: The callback function 4074 for asynchronous request. (optional) 4075 :param str account_id: The external account number (int) or account ID Guid. (required) 4076 :return: EnvelopePurgeConfiguration 4077 If the method is called asynchronously, 4078 returns the request thread. 4079 """ 4080 kwargs['_return_http_data_only'] = True 4081 if kwargs.get('callback'): 4082 return self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs) 4083 else: 4084 (data) = self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs) 4085 return data
Select envelope purge configuration.
An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (retentionDays). This method retrieves the current envelope purge configuration for your account. Note: To use this method, you must be an account administrator.
This method makes a synchronous HTTP request by default. To make 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_purge_configuration(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)
Returns
EnvelopePurgeConfiguration If the method is called asynchronously, returns the request thread.
def
get_envelope_purge_configuration_with_http_info(self, account_id, **kwargs)
4087 def get_envelope_purge_configuration_with_http_info(self, account_id, **kwargs): 4088 """ 4089 Select envelope purge configuration. 4090 An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method retrieves the current envelope purge configuration for your account. **Note:** To use this method, you must be an account administrator. 4091 This method makes a synchronous HTTP request by default. To make an 4092 asynchronous HTTP request, please define a `callback` function 4093 to be invoked when receiving the response. 4094 >>> def callback_function(response): 4095 >>> pprint(response) 4096 >>> 4097 >>> thread = api.get_envelope_purge_configuration_with_http_info(account_id, callback=callback_function) 4098 4099 :param callback function: The callback function 4100 for asynchronous request. (optional) 4101 :param str account_id: The external account number (int) or account ID Guid. (required) 4102 :return: EnvelopePurgeConfiguration 4103 If the method is called asynchronously, 4104 returns the request thread. 4105 """ 4106 4107 all_params = ['account_id'] 4108 all_params.append('callback') 4109 all_params.append('_return_http_data_only') 4110 all_params.append('_preload_content') 4111 all_params.append('_request_timeout') 4112 4113 params = locals() 4114 for key, val in iteritems(params['kwargs']): 4115 if key not in all_params: 4116 raise TypeError( 4117 "Got an unexpected keyword argument '%s'" 4118 " to method get_envelope_purge_configuration" % key 4119 ) 4120 params[key] = val 4121 del params['kwargs'] 4122 # verify the required parameter 'account_id' is set 4123 if ('account_id' not in params) or (params['account_id'] is None): 4124 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_purge_configuration`") 4125 4126 4127 collection_formats = {} 4128 4129 resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json') 4130 path_params = {} 4131 if 'account_id' in params: 4132 path_params['accountId'] = params['account_id'] 4133 4134 query_params = {} 4135 4136 header_params = {} 4137 4138 form_params = [] 4139 local_var_files = {} 4140 4141 body_params = None 4142 # HTTP header `Accept` 4143 header_params['Accept'] = self.api_client.\ 4144 select_header_accept(['application/json']) 4145 4146 # Authentication setting 4147 auth_settings = [] 4148 4149 return self.api_client.call_api(resource_path, 'GET', 4150 path_params, 4151 query_params, 4152 header_params, 4153 body=body_params, 4154 post_params=form_params, 4155 files=local_var_files, 4156 response_type='EnvelopePurgeConfiguration', 4157 auth_settings=auth_settings, 4158 callback=params.get('callback'), 4159 _return_http_data_only=params.get('_return_http_data_only'), 4160 _preload_content=params.get('_preload_content', True), 4161 _request_timeout=params.get('_request_timeout'), 4162 collection_formats=collection_formats)
Select envelope purge configuration.
An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (retentionDays). This method retrieves the current envelope purge configuration for your account. Note: To use this method, you must be an account administrator.
This method makes a synchronous HTTP request by default. To make 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_purge_configuration_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)
Returns
EnvelopePurgeConfiguration If the method is called asynchronously, returns the request thread.
def
get_favorite_templates(self, account_id, **kwargs)
4164 def get_favorite_templates(self, account_id, **kwargs): 4165 """ 4166 Retrieves the list of favorited templates for this caller 4167 4168 This method makes a synchronous HTTP request by default. To make an 4169 asynchronous HTTP request, please define a `callback` function 4170 to be invoked when receiving the response. 4171 >>> def callback_function(response): 4172 >>> pprint(response) 4173 >>> 4174 >>> thread = api.get_favorite_templates(account_id, callback=callback_function) 4175 4176 :param callback function: The callback function 4177 for asynchronous request. (optional) 4178 :param str account_id: The external account number (int) or account ID Guid. (required) 4179 :return: FavoriteTemplatesInfo 4180 If the method is called asynchronously, 4181 returns the request thread. 4182 """ 4183 kwargs['_return_http_data_only'] = True 4184 if kwargs.get('callback'): 4185 return self.get_favorite_templates_with_http_info(account_id, **kwargs) 4186 else: 4187 (data) = self.get_favorite_templates_with_http_info(account_id, **kwargs) 4188 return data
Retrieves the list of favorited templates for this caller
This method makes a synchronous HTTP request by default. To make 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_favorite_templates(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)
Returns
FavoriteTemplatesInfo If the method is called asynchronously, returns the request thread.
def
get_favorite_templates_with_http_info(self, account_id, **kwargs)
4190 def get_favorite_templates_with_http_info(self, account_id, **kwargs): 4191 """ 4192 Retrieves the list of favorited templates for this caller 4193 4194 This method makes a synchronous HTTP request by default. To make an 4195 asynchronous HTTP request, please define a `callback` function 4196 to be invoked when receiving the response. 4197 >>> def callback_function(response): 4198 >>> pprint(response) 4199 >>> 4200 >>> thread = api.get_favorite_templates_with_http_info(account_id, callback=callback_function) 4201 4202 :param callback function: The callback function 4203 for asynchronous request. (optional) 4204 :param str account_id: The external account number (int) or account ID Guid. (required) 4205 :return: FavoriteTemplatesInfo 4206 If the method is called asynchronously, 4207 returns the request thread. 4208 """ 4209 4210 all_params = ['account_id'] 4211 all_params.append('callback') 4212 all_params.append('_return_http_data_only') 4213 all_params.append('_preload_content') 4214 all_params.append('_request_timeout') 4215 4216 params = locals() 4217 for key, val in iteritems(params['kwargs']): 4218 if key not in all_params: 4219 raise TypeError( 4220 "Got an unexpected keyword argument '%s'" 4221 " to method get_favorite_templates" % key 4222 ) 4223 params[key] = val 4224 del params['kwargs'] 4225 # verify the required parameter 'account_id' is set 4226 if ('account_id' not in params) or (params['account_id'] is None): 4227 raise ValueError("Missing the required parameter `account_id` when calling `get_favorite_templates`") 4228 4229 4230 collection_formats = {} 4231 4232 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 4233 path_params = {} 4234 if 'account_id' in params: 4235 path_params['accountId'] = params['account_id'] 4236 4237 query_params = {} 4238 4239 header_params = {} 4240 4241 form_params = [] 4242 local_var_files = {} 4243 4244 body_params = None 4245 # HTTP header `Accept` 4246 header_params['Accept'] = self.api_client.\ 4247 select_header_accept(['application/json']) 4248 4249 # Authentication setting 4250 auth_settings = [] 4251 4252 return self.api_client.call_api(resource_path, 'GET', 4253 path_params, 4254 query_params, 4255 header_params, 4256 body=body_params, 4257 post_params=form_params, 4258 files=local_var_files, 4259 response_type='FavoriteTemplatesInfo', 4260 auth_settings=auth_settings, 4261 callback=params.get('callback'), 4262 _return_http_data_only=params.get('_return_http_data_only'), 4263 _preload_content=params.get('_preload_content', True), 4264 _request_timeout=params.get('_request_timeout'), 4265 collection_formats=collection_formats)
Retrieves the list of favorited templates for this caller
This method makes a synchronous HTTP request by default. To make 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_favorite_templates_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)
Returns
FavoriteTemplatesInfo If the method is called asynchronously, returns the request thread.
def
get_notification_defaults(self, account_id, **kwargs)
4267 def get_notification_defaults(self, account_id, **kwargs): 4268 """ 4269 Returns default user level settings for a specified account 4270 This method returns the default settings for the email notifications that signers and senders receive about envelopes. 4271 This method makes a synchronous HTTP request by default. To make an 4272 asynchronous HTTP request, please define a `callback` function 4273 to be invoked when receiving the response. 4274 >>> def callback_function(response): 4275 >>> pprint(response) 4276 >>> 4277 >>> thread = api.get_notification_defaults(account_id, callback=callback_function) 4278 4279 :param callback function: The callback function 4280 for asynchronous request. (optional) 4281 :param str account_id: The external account number (int) or account ID Guid. (required) 4282 :return: NotificationDefaults 4283 If the method is called asynchronously, 4284 returns the request thread. 4285 """ 4286 kwargs['_return_http_data_only'] = True 4287 if kwargs.get('callback'): 4288 return self.get_notification_defaults_with_http_info(account_id, **kwargs) 4289 else: 4290 (data) = self.get_notification_defaults_with_http_info(account_id, **kwargs) 4291 return data
Returns default user level settings for a specified account
This method returns the default settings for the email notifications that signers and senders receive about 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.get_notification_defaults(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)
Returns
NotificationDefaults If the method is called asynchronously, returns the request thread.
def
get_notification_defaults_with_http_info(self, account_id, **kwargs)
4293 def get_notification_defaults_with_http_info(self, account_id, **kwargs): 4294 """ 4295 Returns default user level settings for a specified account 4296 This method returns the default settings for the email notifications that signers and senders receive about envelopes. 4297 This method makes a synchronous HTTP request by default. To make an 4298 asynchronous HTTP request, please define a `callback` function 4299 to be invoked when receiving the response. 4300 >>> def callback_function(response): 4301 >>> pprint(response) 4302 >>> 4303 >>> thread = api.get_notification_defaults_with_http_info(account_id, callback=callback_function) 4304 4305 :param callback function: The callback function 4306 for asynchronous request. (optional) 4307 :param str account_id: The external account number (int) or account ID Guid. (required) 4308 :return: NotificationDefaults 4309 If the method is called asynchronously, 4310 returns the request thread. 4311 """ 4312 4313 all_params = ['account_id'] 4314 all_params.append('callback') 4315 all_params.append('_return_http_data_only') 4316 all_params.append('_preload_content') 4317 all_params.append('_request_timeout') 4318 4319 params = locals() 4320 for key, val in iteritems(params['kwargs']): 4321 if key not in all_params: 4322 raise TypeError( 4323 "Got an unexpected keyword argument '%s'" 4324 " to method get_notification_defaults" % key 4325 ) 4326 params[key] = val 4327 del params['kwargs'] 4328 # verify the required parameter 'account_id' is set 4329 if ('account_id' not in params) or (params['account_id'] is None): 4330 raise ValueError("Missing the required parameter `account_id` when calling `get_notification_defaults`") 4331 4332 4333 collection_formats = {} 4334 4335 resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json') 4336 path_params = {} 4337 if 'account_id' in params: 4338 path_params['accountId'] = params['account_id'] 4339 4340 query_params = {} 4341 4342 header_params = {} 4343 4344 form_params = [] 4345 local_var_files = {} 4346 4347 body_params = None 4348 # HTTP header `Accept` 4349 header_params['Accept'] = self.api_client.\ 4350 select_header_accept(['application/json']) 4351 4352 # Authentication setting 4353 auth_settings = [] 4354 4355 return self.api_client.call_api(resource_path, 'GET', 4356 path_params, 4357 query_params, 4358 header_params, 4359 body=body_params, 4360 post_params=form_params, 4361 files=local_var_files, 4362 response_type='NotificationDefaults', 4363 auth_settings=auth_settings, 4364 callback=params.get('callback'), 4365 _return_http_data_only=params.get('_return_http_data_only'), 4366 _preload_content=params.get('_preload_content', True), 4367 _request_timeout=params.get('_request_timeout'), 4368 collection_formats=collection_formats)
Returns default user level settings for a specified account
This method returns the default settings for the email notifications that signers and senders receive about 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.get_notification_defaults_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)
Returns
NotificationDefaults If the method is called asynchronously, returns the request thread.
def
get_password_rules(self, account_id, **kwargs)
4370 def get_password_rules(self, account_id, **kwargs): 4371 """ 4372 Get the password rules 4373 This method retrieves the password rules for an account. 4374 This method makes a synchronous HTTP request by default. To make an 4375 asynchronous HTTP request, please define a `callback` function 4376 to be invoked when receiving the response. 4377 >>> def callback_function(response): 4378 >>> pprint(response) 4379 >>> 4380 >>> thread = api.get_password_rules(account_id, callback=callback_function) 4381 4382 :param callback function: The callback function 4383 for asynchronous request. (optional) 4384 :param str account_id: The external account number (int) or account ID Guid. (required) 4385 :return: AccountPasswordRules 4386 If the method is called asynchronously, 4387 returns the request thread. 4388 """ 4389 kwargs['_return_http_data_only'] = True 4390 if kwargs.get('callback'): 4391 return self.get_password_rules_with_http_info(account_id, **kwargs) 4392 else: 4393 (data) = self.get_password_rules_with_http_info(account_id, **kwargs) 4394 return data
Get the password rules
This method retrieves the password rules for an 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_password_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)
Returns
AccountPasswordRules If the method is called asynchronously, returns the request thread.
def
get_password_rules_with_http_info(self, account_id, **kwargs)
4396 def get_password_rules_with_http_info(self, account_id, **kwargs): 4397 """ 4398 Get the password rules 4399 This method retrieves the password rules for an account. 4400 This method makes a synchronous HTTP request by default. To make an 4401 asynchronous HTTP request, please define a `callback` function 4402 to be invoked when receiving the response. 4403 >>> def callback_function(response): 4404 >>> pprint(response) 4405 >>> 4406 >>> thread = api.get_password_rules_with_http_info(account_id, callback=callback_function) 4407 4408 :param callback function: The callback function 4409 for asynchronous request. (optional) 4410 :param str account_id: The external account number (int) or account ID Guid. (required) 4411 :return: AccountPasswordRules 4412 If the method is called asynchronously, 4413 returns the request thread. 4414 """ 4415 4416 all_params = ['account_id'] 4417 all_params.append('callback') 4418 all_params.append('_return_http_data_only') 4419 all_params.append('_preload_content') 4420 all_params.append('_request_timeout') 4421 4422 params = locals() 4423 for key, val in iteritems(params['kwargs']): 4424 if key not in all_params: 4425 raise TypeError( 4426 "Got an unexpected keyword argument '%s'" 4427 " to method get_password_rules" % key 4428 ) 4429 params[key] = val 4430 del params['kwargs'] 4431 # verify the required parameter 'account_id' is set 4432 if ('account_id' not in params) or (params['account_id'] is None): 4433 raise ValueError("Missing the required parameter `account_id` when calling `get_password_rules`") 4434 4435 4436 collection_formats = {} 4437 4438 resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json') 4439 path_params = {} 4440 if 'account_id' in params: 4441 path_params['accountId'] = params['account_id'] 4442 4443 query_params = {} 4444 4445 header_params = {} 4446 4447 form_params = [] 4448 local_var_files = {} 4449 4450 body_params = None 4451 # HTTP header `Accept` 4452 header_params['Accept'] = self.api_client.\ 4453 select_header_accept(['application/json']) 4454 4455 # Authentication setting 4456 auth_settings = [] 4457 4458 return self.api_client.call_api(resource_path, 'GET', 4459 path_params, 4460 query_params, 4461 header_params, 4462 body=body_params, 4463 post_params=form_params, 4464 files=local_var_files, 4465 response_type='AccountPasswordRules', 4466 auth_settings=auth_settings, 4467 callback=params.get('callback'), 4468 _return_http_data_only=params.get('_return_http_data_only'), 4469 _preload_content=params.get('_preload_content', True), 4470 _request_timeout=params.get('_request_timeout'), 4471 collection_formats=collection_formats)
Get the password rules
This method retrieves the password rules for an 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_password_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)
Returns
AccountPasswordRules If the method is called asynchronously, returns the request thread.
def
get_password_rules_0(self, **kwargs)
4473 def get_password_rules_0(self, **kwargs): 4474 """ 4475 Get membership account password rules 4476 4477 This method makes a synchronous HTTP request by default. To make an 4478 asynchronous HTTP request, please define a `callback` function 4479 to be invoked when receiving the response. 4480 >>> def callback_function(response): 4481 >>> pprint(response) 4482 >>> 4483 >>> thread = api.get_password_rules_0(callback=callback_function) 4484 4485 :param callback function: The callback function 4486 for asynchronous request. (optional) 4487 :return: UserPasswordRules 4488 If the method is called asynchronously, 4489 returns the request thread. 4490 """ 4491 kwargs['_return_http_data_only'] = True 4492 if kwargs.get('callback'): 4493 return self.get_password_rules_0_with_http_info(**kwargs) 4494 else: 4495 (data) = self.get_password_rules_0_with_http_info(**kwargs) 4496 return data
Get membership account password rules
This method makes a synchronous HTTP request by default. To make 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_password_rules_0(callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
Returns
UserPasswordRules If the method is called asynchronously, returns the request thread.
def
get_password_rules_0_with_http_info(self, **kwargs)
4498 def get_password_rules_0_with_http_info(self, **kwargs): 4499 """ 4500 Get membership account password rules 4501 4502 This method makes a synchronous HTTP request by default. To make an 4503 asynchronous HTTP request, please define a `callback` function 4504 to be invoked when receiving the response. 4505 >>> def callback_function(response): 4506 >>> pprint(response) 4507 >>> 4508 >>> thread = api.get_password_rules_0_with_http_info(callback=callback_function) 4509 4510 :param callback function: The callback function 4511 for asynchronous request. (optional) 4512 :return: UserPasswordRules 4513 If the method is called asynchronously, 4514 returns the request thread. 4515 """ 4516 4517 all_params = [] 4518 all_params.append('callback') 4519 all_params.append('_return_http_data_only') 4520 all_params.append('_preload_content') 4521 all_params.append('_request_timeout') 4522 4523 params = locals() 4524 for key, val in iteritems(params['kwargs']): 4525 if key not in all_params: 4526 raise TypeError( 4527 "Got an unexpected keyword argument '%s'" 4528 " to method get_password_rules_0" % key 4529 ) 4530 params[key] = val 4531 del params['kwargs'] 4532 4533 collection_formats = {} 4534 4535 resource_path = '/v2.1/current_user/password_rules'.replace('{format}', 'json') 4536 path_params = {} 4537 4538 query_params = {} 4539 4540 header_params = {} 4541 4542 form_params = [] 4543 local_var_files = {} 4544 4545 body_params = None 4546 # HTTP header `Accept` 4547 header_params['Accept'] = self.api_client.\ 4548 select_header_accept(['application/json']) 4549 4550 # Authentication setting 4551 auth_settings = [] 4552 4553 return self.api_client.call_api(resource_path, 'GET', 4554 path_params, 4555 query_params, 4556 header_params, 4557 body=body_params, 4558 post_params=form_params, 4559 files=local_var_files, 4560 response_type='UserPasswordRules', 4561 auth_settings=auth_settings, 4562 callback=params.get('callback'), 4563 _return_http_data_only=params.get('_return_http_data_only'), 4564 _preload_content=params.get('_preload_content', True), 4565 _request_timeout=params.get('_request_timeout'), 4566 collection_formats=collection_formats)
Get membership account password rules
This method makes a synchronous HTTP request by default. To make 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_password_rules_0_with_http_info(callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
Returns
UserPasswordRules If the method is called asynchronously, returns the request thread.
def
get_permission_profile(self, account_id, permission_profile_id, **kwargs)
4568 def get_permission_profile(self, account_id, permission_profile_id, **kwargs): 4569 """ 4570 Returns a permissions profile in the specified account. 4571 This method returns information about a specific permission profile that is associated with an account. ### Related topics - [How to set a permission profile](/docs/esign-rest-api/how-to/permission-profile-setting/) 4572 This method makes a synchronous HTTP request by default. To make an 4573 asynchronous HTTP request, please define a `callback` function 4574 to be invoked when receiving the response. 4575 >>> def callback_function(response): 4576 >>> pprint(response) 4577 >>> 4578 >>> thread = api.get_permission_profile(account_id, permission_profile_id, callback=callback_function) 4579 4580 :param callback function: The callback function 4581 for asynchronous request. (optional) 4582 :param str account_id: The external account number (int) or account ID Guid. (required) 4583 :param str permission_profile_id: (required) 4584 :param str include: 4585 :return: PermissionProfile 4586 If the method is called asynchronously, 4587 returns the request thread. 4588 """ 4589 kwargs['_return_http_data_only'] = True 4590 if kwargs.get('callback'): 4591 return self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 4592 else: 4593 (data) = self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 4594 return data
Returns a permissions profile in the specified account.
This method returns information about a specific permission profile that is associated with an account. ### Related topics - How to set a permission profile
This method makes a synchronous HTTP request by default. To make 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_permission_profile(account_id, permission_profile_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str permission_profile_id: (required)
- str include:
Returns
PermissionProfile If the method is called asynchronously, returns the request thread.
def
get_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs)
4596 def get_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 4597 """ 4598 Returns a permissions profile in the specified account. 4599 This method returns information about a specific permission profile that is associated with an account. ### Related topics - [How to set a permission profile](/docs/esign-rest-api/how-to/permission-profile-setting/) 4600 This method makes a synchronous HTTP request by default. To make an 4601 asynchronous HTTP request, please define a `callback` function 4602 to be invoked when receiving the response. 4603 >>> def callback_function(response): 4604 >>> pprint(response) 4605 >>> 4606 >>> thread = api.get_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 4607 4608 :param callback function: The callback function 4609 for asynchronous request. (optional) 4610 :param str account_id: The external account number (int) or account ID Guid. (required) 4611 :param str permission_profile_id: (required) 4612 :param str include: 4613 :return: PermissionProfile 4614 If the method is called asynchronously, 4615 returns the request thread. 4616 """ 4617 4618 all_params = ['account_id', 'permission_profile_id', 'include'] 4619 all_params.append('callback') 4620 all_params.append('_return_http_data_only') 4621 all_params.append('_preload_content') 4622 all_params.append('_request_timeout') 4623 4624 params = locals() 4625 for key, val in iteritems(params['kwargs']): 4626 if key not in all_params: 4627 raise TypeError( 4628 "Got an unexpected keyword argument '%s'" 4629 " to method get_permission_profile" % key 4630 ) 4631 params[key] = val 4632 del params['kwargs'] 4633 # verify the required parameter 'account_id' is set 4634 if ('account_id' not in params) or (params['account_id'] is None): 4635 raise ValueError("Missing the required parameter `account_id` when calling `get_permission_profile`") 4636 # verify the required parameter 'permission_profile_id' is set 4637 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 4638 raise ValueError("Missing the required parameter `permission_profile_id` when calling `get_permission_profile`") 4639 4640 4641 collection_formats = {} 4642 4643 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 4644 path_params = {} 4645 if 'account_id' in params: 4646 path_params['accountId'] = params['account_id'] 4647 if 'permission_profile_id' in params: 4648 path_params['permissionProfileId'] = params['permission_profile_id'] 4649 4650 query_params = {} 4651 if 'include' in params: 4652 query_params['include'] = params['include'] 4653 4654 header_params = {} 4655 4656 form_params = [] 4657 local_var_files = {} 4658 4659 body_params = None 4660 # HTTP header `Accept` 4661 header_params['Accept'] = self.api_client.\ 4662 select_header_accept(['application/json']) 4663 4664 # Authentication setting 4665 auth_settings = [] 4666 4667 return self.api_client.call_api(resource_path, 'GET', 4668 path_params, 4669 query_params, 4670 header_params, 4671 body=body_params, 4672 post_params=form_params, 4673 files=local_var_files, 4674 response_type='PermissionProfile', 4675 auth_settings=auth_settings, 4676 callback=params.get('callback'), 4677 _return_http_data_only=params.get('_return_http_data_only'), 4678 _preload_content=params.get('_preload_content', True), 4679 _request_timeout=params.get('_request_timeout'), 4680 collection_formats=collection_formats)
Returns a permissions profile in the specified account.
This method returns information about a specific permission profile that is associated with an account. ### Related topics - How to set a permission profile
This method makes a synchronous HTTP request by default. To make 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_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str permission_profile_id: (required)
- str include:
Returns
PermissionProfile If the method is called asynchronously, returns the request thread.
def
get_provisioning(self, **kwargs)
4818 def get_provisioning(self, **kwargs): 4819 """ 4820 Retrieves the account provisioning information for the account. 4821 Retrieves the account provisioning information for the account. 4822 This method makes a synchronous HTTP request by default. To make an 4823 asynchronous HTTP request, please define a `callback` function 4824 to be invoked when receiving the response. 4825 >>> def callback_function(response): 4826 >>> pprint(response) 4827 >>> 4828 >>> thread = api.get_provisioning(callback=callback_function) 4829 4830 :param callback function: The callback function 4831 for asynchronous request. (optional) 4832 :return: ProvisioningInformation 4833 If the method is called asynchronously, 4834 returns the request thread. 4835 """ 4836 kwargs['_return_http_data_only'] = True 4837 if kwargs.get('callback'): 4838 return self.get_provisioning_with_http_info(**kwargs) 4839 else: 4840 (data) = self.get_provisioning_with_http_info(**kwargs) 4841 return data
Retrieves the account provisioning information for the account.
Retrieves the account provisioning information for 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_provisioning(callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
Returns
ProvisioningInformation If the method is called asynchronously, returns the request thread.
def
get_provisioning_with_http_info(self, **kwargs)
4843 def get_provisioning_with_http_info(self, **kwargs): 4844 """ 4845 Retrieves the account provisioning information for the account. 4846 Retrieves the account provisioning information for the account. 4847 This method makes a synchronous HTTP request by default. To make an 4848 asynchronous HTTP request, please define a `callback` function 4849 to be invoked when receiving the response. 4850 >>> def callback_function(response): 4851 >>> pprint(response) 4852 >>> 4853 >>> thread = api.get_provisioning_with_http_info(callback=callback_function) 4854 4855 :param callback function: The callback function 4856 for asynchronous request. (optional) 4857 :return: ProvisioningInformation 4858 If the method is called asynchronously, 4859 returns the request thread. 4860 """ 4861 4862 all_params = [] 4863 all_params.append('callback') 4864 all_params.append('_return_http_data_only') 4865 all_params.append('_preload_content') 4866 all_params.append('_request_timeout') 4867 4868 params = locals() 4869 for key, val in iteritems(params['kwargs']): 4870 if key not in all_params: 4871 raise TypeError( 4872 "Got an unexpected keyword argument '%s'" 4873 " to method get_provisioning" % key 4874 ) 4875 params[key] = val 4876 del params['kwargs'] 4877 4878 collection_formats = {} 4879 4880 resource_path = '/v2.1/accounts/provisioning'.replace('{format}', 'json') 4881 path_params = {} 4882 4883 query_params = {} 4884 4885 header_params = {} 4886 4887 form_params = [] 4888 local_var_files = {} 4889 4890 body_params = None 4891 # HTTP header `Accept` 4892 header_params['Accept'] = self.api_client.\ 4893 select_header_accept(['application/json']) 4894 4895 # Authentication setting 4896 auth_settings = [] 4897 4898 return self.api_client.call_api(resource_path, 'GET', 4899 path_params, 4900 query_params, 4901 header_params, 4902 body=body_params, 4903 post_params=form_params, 4904 files=local_var_files, 4905 response_type='ProvisioningInformation', 4906 auth_settings=auth_settings, 4907 callback=params.get('callback'), 4908 _return_http_data_only=params.get('_return_http_data_only'), 4909 _preload_content=params.get('_preload_content', True), 4910 _request_timeout=params.get('_request_timeout'), 4911 collection_formats=collection_formats)
Retrieves the account provisioning information for the account.
Retrieves the account provisioning information for 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_provisioning_with_http_info(callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
Returns
ProvisioningInformation If the method is called asynchronously, returns the request thread.
def
get_supported_languages(self, account_id, **kwargs)
4913 def get_supported_languages(self, account_id, **kwargs): 4914 """ 4915 Gets list of supported languages for recipient language setting. 4916 Retrieves a list of supported languages that you can set for an individual recipient when creating an envelope, as well as their simple type enumeration values. These are the languages that you can set for the standard email format and signing view for each recipient. For example, in the recipient's email notification, this setting affects elements such as the standard introductory text describing the request to sign. It also determines the language used for buttons and tabs in both the email notification and the signing experience. **Note:** Setting a language for a recipient affects only the DocuSign standard text. Any custom text that you enter for the `emailBody` and `emailSubject` of the notification is not translated, and appears exactly as you enter it. For more information, see [Set Recipient Language and Specify Custom Email Messages](https://support.docusign.com/en/guides/ndse-user-guide-recipient-language). 4917 This method makes a synchronous HTTP request by default. To make an 4918 asynchronous HTTP request, please define a `callback` function 4919 to be invoked when receiving the response. 4920 >>> def callback_function(response): 4921 >>> pprint(response) 4922 >>> 4923 >>> thread = api.get_supported_languages(account_id, callback=callback_function) 4924 4925 :param callback function: The callback function 4926 for asynchronous request. (optional) 4927 :param str account_id: The external account number (int) or account ID Guid. (required) 4928 :return: SupportedLanguages 4929 If the method is called asynchronously, 4930 returns the request thread. 4931 """ 4932 kwargs['_return_http_data_only'] = True 4933 if kwargs.get('callback'): 4934 return self.get_supported_languages_with_http_info(account_id, **kwargs) 4935 else: 4936 (data) = self.get_supported_languages_with_http_info(account_id, **kwargs) 4937 return data
Gets list of supported languages for recipient language setting.
Retrieves a list of supported languages that you can set for an individual recipient when creating an envelope, as well as their simple type enumeration values. These are the languages that you can set for the standard email format and signing view for each recipient. For example, in the recipient's email notification, this setting affects elements such as the standard introductory text describing the request to sign. It also determines the language used for buttons and tabs in both the email notification and the signing experience. Note: Setting a language for a recipient affects only the DocuSign standard text. Any custom text that you enter for the emailBody and emailSubject of the notification is not translated, and appears exactly as you enter it. For more information, see Set Recipient Language and Specify Custom 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.get_supported_languages(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)
Returns
SupportedLanguages If the method is called asynchronously, returns the request thread.
def
get_supported_languages_with_http_info(self, account_id, **kwargs)
4939 def get_supported_languages_with_http_info(self, account_id, **kwargs): 4940 """ 4941 Gets list of supported languages for recipient language setting. 4942 Retrieves a list of supported languages that you can set for an individual recipient when creating an envelope, as well as their simple type enumeration values. These are the languages that you can set for the standard email format and signing view for each recipient. For example, in the recipient's email notification, this setting affects elements such as the standard introductory text describing the request to sign. It also determines the language used for buttons and tabs in both the email notification and the signing experience. **Note:** Setting a language for a recipient affects only the DocuSign standard text. Any custom text that you enter for the `emailBody` and `emailSubject` of the notification is not translated, and appears exactly as you enter it. For more information, see [Set Recipient Language and Specify Custom Email Messages](https://support.docusign.com/en/guides/ndse-user-guide-recipient-language). 4943 This method makes a synchronous HTTP request by default. To make an 4944 asynchronous HTTP request, please define a `callback` function 4945 to be invoked when receiving the response. 4946 >>> def callback_function(response): 4947 >>> pprint(response) 4948 >>> 4949 >>> thread = api.get_supported_languages_with_http_info(account_id, callback=callback_function) 4950 4951 :param callback function: The callback function 4952 for asynchronous request. (optional) 4953 :param str account_id: The external account number (int) or account ID Guid. (required) 4954 :return: SupportedLanguages 4955 If the method is called asynchronously, 4956 returns the request thread. 4957 """ 4958 4959 all_params = ['account_id'] 4960 all_params.append('callback') 4961 all_params.append('_return_http_data_only') 4962 all_params.append('_preload_content') 4963 all_params.append('_request_timeout') 4964 4965 params = locals() 4966 for key, val in iteritems(params['kwargs']): 4967 if key not in all_params: 4968 raise TypeError( 4969 "Got an unexpected keyword argument '%s'" 4970 " to method get_supported_languages" % key 4971 ) 4972 params[key] = val 4973 del params['kwargs'] 4974 # verify the required parameter 'account_id' is set 4975 if ('account_id' not in params) or (params['account_id'] is None): 4976 raise ValueError("Missing the required parameter `account_id` when calling `get_supported_languages`") 4977 4978 4979 collection_formats = {} 4980 4981 resource_path = '/v2.1/accounts/{accountId}/supported_languages'.replace('{format}', 'json') 4982 path_params = {} 4983 if 'account_id' in params: 4984 path_params['accountId'] = params['account_id'] 4985 4986 query_params = {} 4987 4988 header_params = {} 4989 4990 form_params = [] 4991 local_var_files = {} 4992 4993 body_params = None 4994 # HTTP header `Accept` 4995 header_params['Accept'] = self.api_client.\ 4996 select_header_accept(['application/json']) 4997 4998 # Authentication setting 4999 auth_settings = [] 5000 5001 return self.api_client.call_api(resource_path, 'GET', 5002 path_params, 5003 query_params, 5004 header_params, 5005 body=body_params, 5006 post_params=form_params, 5007 files=local_var_files, 5008 response_type='SupportedLanguages', 5009 auth_settings=auth_settings, 5010 callback=params.get('callback'), 5011 _return_http_data_only=params.get('_return_http_data_only'), 5012 _preload_content=params.get('_preload_content', True), 5013 _request_timeout=params.get('_request_timeout'), 5014 collection_formats=collection_formats)
Gets list of supported languages for recipient language setting.
Retrieves a list of supported languages that you can set for an individual recipient when creating an envelope, as well as their simple type enumeration values. These are the languages that you can set for the standard email format and signing view for each recipient. For example, in the recipient's email notification, this setting affects elements such as the standard introductory text describing the request to sign. It also determines the language used for buttons and tabs in both the email notification and the signing experience. Note: Setting a language for a recipient affects only the DocuSign standard text. Any custom text that you enter for the emailBody and emailSubject of the notification is not translated, and appears exactly as you enter it. For more information, see Set Recipient Language and Specify Custom 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.get_supported_languages_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)
Returns
SupportedLanguages If the method is called asynchronously, returns the request thread.
def
get_watermark(self, account_id, **kwargs)
5131 def get_watermark(self, account_id, **kwargs): 5132 """ 5133 Get watermark information. 5134 5135 This method makes a synchronous HTTP request by default. To make an 5136 asynchronous HTTP request, please define a `callback` function 5137 to be invoked when receiving the response. 5138 >>> def callback_function(response): 5139 >>> pprint(response) 5140 >>> 5141 >>> thread = api.get_watermark(account_id, callback=callback_function) 5142 5143 :param callback function: The callback function 5144 for asynchronous request. (optional) 5145 :param str account_id: The external account number (int) or account ID Guid. (required) 5146 :return: Watermark 5147 If the method is called asynchronously, 5148 returns the request thread. 5149 """ 5150 kwargs['_return_http_data_only'] = True 5151 if kwargs.get('callback'): 5152 return self.get_watermark_with_http_info(account_id, **kwargs) 5153 else: 5154 (data) = self.get_watermark_with_http_info(account_id, **kwargs) 5155 return data
Get watermark information.
This method makes a synchronous HTTP request by default. To make 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_watermark(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)
Returns
Watermark If the method is called asynchronously, returns the request thread.
def
get_watermark_with_http_info(self, account_id, **kwargs)
5157 def get_watermark_with_http_info(self, account_id, **kwargs): 5158 """ 5159 Get watermark information. 5160 5161 This method makes a synchronous HTTP request by default. To make an 5162 asynchronous HTTP request, please define a `callback` function 5163 to be invoked when receiving the response. 5164 >>> def callback_function(response): 5165 >>> pprint(response) 5166 >>> 5167 >>> thread = api.get_watermark_with_http_info(account_id, callback=callback_function) 5168 5169 :param callback function: The callback function 5170 for asynchronous request. (optional) 5171 :param str account_id: The external account number (int) or account ID Guid. (required) 5172 :return: Watermark 5173 If the method is called asynchronously, 5174 returns the request thread. 5175 """ 5176 5177 all_params = ['account_id'] 5178 all_params.append('callback') 5179 all_params.append('_return_http_data_only') 5180 all_params.append('_preload_content') 5181 all_params.append('_request_timeout') 5182 5183 params = locals() 5184 for key, val in iteritems(params['kwargs']): 5185 if key not in all_params: 5186 raise TypeError( 5187 "Got an unexpected keyword argument '%s'" 5188 " to method get_watermark" % key 5189 ) 5190 params[key] = val 5191 del params['kwargs'] 5192 # verify the required parameter 'account_id' is set 5193 if ('account_id' not in params) or (params['account_id'] is None): 5194 raise ValueError("Missing the required parameter `account_id` when calling `get_watermark`") 5195 5196 5197 collection_formats = {} 5198 5199 resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json') 5200 path_params = {} 5201 if 'account_id' in params: 5202 path_params['accountId'] = params['account_id'] 5203 5204 query_params = {} 5205 5206 header_params = {} 5207 5208 form_params = [] 5209 local_var_files = {} 5210 5211 body_params = None 5212 # HTTP header `Accept` 5213 header_params['Accept'] = self.api_client.\ 5214 select_header_accept(['application/json']) 5215 5216 # Authentication setting 5217 auth_settings = [] 5218 5219 return self.api_client.call_api(resource_path, 'GET', 5220 path_params, 5221 query_params, 5222 header_params, 5223 body=body_params, 5224 post_params=form_params, 5225 files=local_var_files, 5226 response_type='Watermark', 5227 auth_settings=auth_settings, 5228 callback=params.get('callback'), 5229 _return_http_data_only=params.get('_return_http_data_only'), 5230 _preload_content=params.get('_preload_content', True), 5231 _request_timeout=params.get('_request_timeout'), 5232 collection_formats=collection_formats)
Get watermark information.
This method makes a synchronous HTTP request by default. To make 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_watermark_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)
Returns
Watermark If the method is called asynchronously, returns the request thread.
def
get_watermark_preview(self, account_id, **kwargs)
5234 def get_watermark_preview(self, account_id, **kwargs): 5235 """ 5236 Get watermark preview. 5237 5238 This method makes a synchronous HTTP request by default. To make an 5239 asynchronous HTTP request, please define a `callback` function 5240 to be invoked when receiving the response. 5241 >>> def callback_function(response): 5242 >>> pprint(response) 5243 >>> 5244 >>> thread = api.get_watermark_preview(account_id, callback=callback_function) 5245 5246 :param callback function: The callback function 5247 for asynchronous request. (optional) 5248 :param str account_id: The external account number (int) or account ID Guid. (required) 5249 :param Watermark watermark: 5250 :return: Watermark 5251 If the method is called asynchronously, 5252 returns the request thread. 5253 """ 5254 kwargs['_return_http_data_only'] = True 5255 if kwargs.get('callback'): 5256 return self.get_watermark_preview_with_http_info(account_id, **kwargs) 5257 else: 5258 (data) = self.get_watermark_preview_with_http_info(account_id, **kwargs) 5259 return data
Get watermark preview.
This method makes a synchronous HTTP request by default. To make 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_watermark_preview(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)
- Watermark watermark:
Returns
Watermark If the method is called asynchronously, returns the request thread.
def
get_watermark_preview_with_http_info(self, account_id, **kwargs)
5261 def get_watermark_preview_with_http_info(self, account_id, **kwargs): 5262 """ 5263 Get watermark preview. 5264 5265 This method makes a synchronous HTTP request by default. To make an 5266 asynchronous HTTP request, please define a `callback` function 5267 to be invoked when receiving the response. 5268 >>> def callback_function(response): 5269 >>> pprint(response) 5270 >>> 5271 >>> thread = api.get_watermark_preview_with_http_info(account_id, callback=callback_function) 5272 5273 :param callback function: The callback function 5274 for asynchronous request. (optional) 5275 :param str account_id: The external account number (int) or account ID Guid. (required) 5276 :param Watermark watermark: 5277 :return: Watermark 5278 If the method is called asynchronously, 5279 returns the request thread. 5280 """ 5281 5282 all_params = ['account_id', 'watermark'] 5283 all_params.append('callback') 5284 all_params.append('_return_http_data_only') 5285 all_params.append('_preload_content') 5286 all_params.append('_request_timeout') 5287 5288 params = locals() 5289 for key, val in iteritems(params['kwargs']): 5290 if key not in all_params: 5291 raise TypeError( 5292 "Got an unexpected keyword argument '%s'" 5293 " to method get_watermark_preview" % key 5294 ) 5295 params[key] = val 5296 del params['kwargs'] 5297 # verify the required parameter 'account_id' is set 5298 if ('account_id' not in params) or (params['account_id'] is None): 5299 raise ValueError("Missing the required parameter `account_id` when calling `get_watermark_preview`") 5300 5301 5302 collection_formats = {} 5303 5304 resource_path = '/v2.1/accounts/{accountId}/watermark/preview'.replace('{format}', 'json') 5305 path_params = {} 5306 if 'account_id' in params: 5307 path_params['accountId'] = params['account_id'] 5308 5309 query_params = {} 5310 5311 header_params = {} 5312 5313 form_params = [] 5314 local_var_files = {} 5315 5316 body_params = None 5317 if 'watermark' in params: 5318 body_params = params['watermark'] 5319 # HTTP header `Accept` 5320 header_params['Accept'] = self.api_client.\ 5321 select_header_accept(['application/json']) 5322 5323 # Authentication setting 5324 auth_settings = [] 5325 5326 return self.api_client.call_api(resource_path, 'PUT', 5327 path_params, 5328 query_params, 5329 header_params, 5330 body=body_params, 5331 post_params=form_params, 5332 files=local_var_files, 5333 response_type='Watermark', 5334 auth_settings=auth_settings, 5335 callback=params.get('callback'), 5336 _return_http_data_only=params.get('_return_http_data_only'), 5337 _preload_content=params.get('_preload_content', True), 5338 _request_timeout=params.get('_request_timeout'), 5339 collection_formats=collection_formats)
Get watermark preview.
This method makes a synchronous HTTP request by default. To make 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_watermark_preview_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)
- Watermark watermark:
Returns
Watermark If the method is called asynchronously, returns the request thread.
def
list_brands(self, account_id, **kwargs)
5341 def list_brands(self, account_id, **kwargs): 5342 """ 5343 Gets a list of brand profiles. 5344 Retrieves the list of brand profiles associated with the account and the default brand profiles. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`) must be set to **true** for the account to use this call. 5345 This method makes a synchronous HTTP request by default. To make an 5346 asynchronous HTTP request, please define a `callback` function 5347 to be invoked when receiving the response. 5348 >>> def callback_function(response): 5349 >>> pprint(response) 5350 >>> 5351 >>> thread = api.list_brands(account_id, callback=callback_function) 5352 5353 :param callback function: The callback function 5354 for asynchronous request. (optional) 5355 :param str account_id: The external account number (int) or account ID Guid. (required) 5356 :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set. 5357 :param str include_logos: When set to **true**, returns the logos associated with the brand. 5358 :return: BrandsResponse 5359 If the method is called asynchronously, 5360 returns the request thread. 5361 """ 5362 kwargs['_return_http_data_only'] = True 5363 if kwargs.get('callback'): 5364 return self.list_brands_with_http_info(account_id, **kwargs) 5365 else: 5366 (data) = self.list_brands_with_http_info(account_id, **kwargs) 5367 return data
Gets a list of brand profiles.
Retrieves the list of brand profiles associated with the account and the default brand profiles. The Account Branding feature (accountSettings properties canSelfBrandSend and canSelfBrandSend) must be set to true for the account to use this call.
This method makes a synchronous HTTP request by default. To make 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_brands(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 exclude_distributor_brand: When set to true, excludes distributor brand information from the response set.
- str include_logos: When set to true, returns the logos associated with the brand.
Returns
BrandsResponse If the method is called asynchronously, returns the request thread.
def
list_brands_with_http_info(self, account_id, **kwargs)
5369 def list_brands_with_http_info(self, account_id, **kwargs): 5370 """ 5371 Gets a list of brand profiles. 5372 Retrieves the list of brand profiles associated with the account and the default brand profiles. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`) must be set to **true** for the account to use this call. 5373 This method makes a synchronous HTTP request by default. To make an 5374 asynchronous HTTP request, please define a `callback` function 5375 to be invoked when receiving the response. 5376 >>> def callback_function(response): 5377 >>> pprint(response) 5378 >>> 5379 >>> thread = api.list_brands_with_http_info(account_id, callback=callback_function) 5380 5381 :param callback function: The callback function 5382 for asynchronous request. (optional) 5383 :param str account_id: The external account number (int) or account ID Guid. (required) 5384 :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set. 5385 :param str include_logos: When set to **true**, returns the logos associated with the brand. 5386 :return: BrandsResponse 5387 If the method is called asynchronously, 5388 returns the request thread. 5389 """ 5390 5391 all_params = ['account_id', 'exclude_distributor_brand', 'include_logos'] 5392 all_params.append('callback') 5393 all_params.append('_return_http_data_only') 5394 all_params.append('_preload_content') 5395 all_params.append('_request_timeout') 5396 5397 params = locals() 5398 for key, val in iteritems(params['kwargs']): 5399 if key not in all_params: 5400 raise TypeError( 5401 "Got an unexpected keyword argument '%s'" 5402 " to method list_brands" % key 5403 ) 5404 params[key] = val 5405 del params['kwargs'] 5406 # verify the required parameter 'account_id' is set 5407 if ('account_id' not in params) or (params['account_id'] is None): 5408 raise ValueError("Missing the required parameter `account_id` when calling `list_brands`") 5409 5410 5411 collection_formats = {} 5412 5413 resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json') 5414 path_params = {} 5415 if 'account_id' in params: 5416 path_params['accountId'] = params['account_id'] 5417 5418 query_params = {} 5419 if 'exclude_distributor_brand' in params: 5420 query_params['exclude_distributor_brand'] = params['exclude_distributor_brand'] 5421 if 'include_logos' in params: 5422 query_params['include_logos'] = params['include_logos'] 5423 5424 header_params = {} 5425 5426 form_params = [] 5427 local_var_files = {} 5428 5429 body_params = None 5430 # HTTP header `Accept` 5431 header_params['Accept'] = self.api_client.\ 5432 select_header_accept(['application/json']) 5433 5434 # Authentication setting 5435 auth_settings = [] 5436 5437 return self.api_client.call_api(resource_path, 'GET', 5438 path_params, 5439 query_params, 5440 header_params, 5441 body=body_params, 5442 post_params=form_params, 5443 files=local_var_files, 5444 response_type='BrandsResponse', 5445 auth_settings=auth_settings, 5446 callback=params.get('callback'), 5447 _return_http_data_only=params.get('_return_http_data_only'), 5448 _preload_content=params.get('_preload_content', True), 5449 _request_timeout=params.get('_request_timeout'), 5450 collection_formats=collection_formats)
Gets a list of brand profiles.
Retrieves the list of brand profiles associated with the account and the default brand profiles. The Account Branding feature (accountSettings properties canSelfBrandSend and canSelfBrandSend) must be set to true for the account to use this call.
This method makes a synchronous HTTP request by default. To make 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_brands_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 exclude_distributor_brand: When set to true, excludes distributor brand information from the response set.
- str include_logos: When set to true, returns the logos associated with the brand.
Returns
BrandsResponse If the method is called asynchronously, returns the request thread.
def
list_custom_fields(self, account_id, **kwargs)
5452 def list_custom_fields(self, account_id, **kwargs): 5453 """ 5454 Gets a list of custom fields associated with the account. 5455 Retrieves a list of envelope custom fields associated with the account. 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. The list custom field lets the sender select the value of the field from a list you provide. 5456 This method makes a synchronous HTTP request by default. To make an 5457 asynchronous HTTP request, please define a `callback` function 5458 to be invoked when receiving the response. 5459 >>> def callback_function(response): 5460 >>> pprint(response) 5461 >>> 5462 >>> thread = api.list_custom_fields(account_id, callback=callback_function) 5463 5464 :param callback function: The callback function 5465 for asynchronous request. (optional) 5466 :param str account_id: The external account number (int) or account ID Guid. (required) 5467 :return: CustomFields 5468 If the method is called asynchronously, 5469 returns the request thread. 5470 """ 5471 kwargs['_return_http_data_only'] = True 5472 if kwargs.get('callback'): 5473 return self.list_custom_fields_with_http_info(account_id, **kwargs) 5474 else: 5475 (data) = self.list_custom_fields_with_http_info(account_id, **kwargs) 5476 return data
Gets a list of custom fields associated with the account.
Retrieves a list of envelope custom fields associated with the account. 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. The list custom field lets the sender select the value of the field from a list you provide.
This method makes a synchronous HTTP request by default. To make 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, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
CustomFields If the method is called asynchronously, returns the request thread.
def
list_custom_fields_with_http_info(self, account_id, **kwargs)
5478 def list_custom_fields_with_http_info(self, account_id, **kwargs): 5479 """ 5480 Gets a list of custom fields associated with the account. 5481 Retrieves a list of envelope custom fields associated with the account. 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. The list custom field lets the sender select the value of the field from a list you provide. 5482 This method makes a synchronous HTTP request by default. To make an 5483 asynchronous HTTP request, please define a `callback` function 5484 to be invoked when receiving the response. 5485 >>> def callback_function(response): 5486 >>> pprint(response) 5487 >>> 5488 >>> thread = api.list_custom_fields_with_http_info(account_id, callback=callback_function) 5489 5490 :param callback function: The callback function 5491 for asynchronous request. (optional) 5492 :param str account_id: The external account number (int) or account ID Guid. (required) 5493 :return: CustomFields 5494 If the method is called asynchronously, 5495 returns the request thread. 5496 """ 5497 5498 all_params = ['account_id'] 5499 all_params.append('callback') 5500 all_params.append('_return_http_data_only') 5501 all_params.append('_preload_content') 5502 all_params.append('_request_timeout') 5503 5504 params = locals() 5505 for key, val in iteritems(params['kwargs']): 5506 if key not in all_params: 5507 raise TypeError( 5508 "Got an unexpected keyword argument '%s'" 5509 " to method list_custom_fields" % key 5510 ) 5511 params[key] = val 5512 del params['kwargs'] 5513 # verify the required parameter 'account_id' is set 5514 if ('account_id' not in params) or (params['account_id'] is None): 5515 raise ValueError("Missing the required parameter `account_id` when calling `list_custom_fields`") 5516 5517 5518 collection_formats = {} 5519 5520 resource_path = '/v2.1/accounts/{accountId}/custom_fields'.replace('{format}', 'json') 5521 path_params = {} 5522 if 'account_id' in params: 5523 path_params['accountId'] = params['account_id'] 5524 5525 query_params = {} 5526 5527 header_params = {} 5528 5529 form_params = [] 5530 local_var_files = {} 5531 5532 body_params = None 5533 # HTTP header `Accept` 5534 header_params['Accept'] = self.api_client.\ 5535 select_header_accept(['application/json']) 5536 5537 # Authentication setting 5538 auth_settings = [] 5539 5540 return self.api_client.call_api(resource_path, 'GET', 5541 path_params, 5542 query_params, 5543 header_params, 5544 body=body_params, 5545 post_params=form_params, 5546 files=local_var_files, 5547 response_type='CustomFields', 5548 auth_settings=auth_settings, 5549 callback=params.get('callback'), 5550 _return_http_data_only=params.get('_return_http_data_only'), 5551 _preload_content=params.get('_preload_content', True), 5552 _request_timeout=params.get('_request_timeout'), 5553 collection_formats=collection_formats)
Gets a list of custom fields associated with the account.
Retrieves a list of envelope custom fields associated with the account. 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. The list custom field lets the sender select the value of the field from a list you provide.
This method makes a synchronous HTTP request by default. To make 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, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
CustomFields If the method is called asynchronously, returns the request thread.
def
list_permissions(self, account_id, **kwargs)
5555 def list_permissions(self, account_id, **kwargs): 5556 """ 5557 Gets a list of permission profiles. 5558 Retrieves a list of Permission Profiles. Permission Profiles are a standard set of user permissions that you can apply to individual users or users in a Group. This makes it easier to manage user permissions for a large number of users, without having to change permissions on a user-by-user basis. Currently, Permission Profiles can only be created and modified in the DocuSign console. 5559 This method makes a synchronous HTTP request by default. To make an 5560 asynchronous HTTP request, please define a `callback` function 5561 to be invoked when receiving the response. 5562 >>> def callback_function(response): 5563 >>> pprint(response) 5564 >>> 5565 >>> thread = api.list_permissions(account_id, callback=callback_function) 5566 5567 :param callback function: The callback function 5568 for asynchronous request. (optional) 5569 :param str account_id: The external account number (int) or account ID Guid. (required) 5570 :param str include: 5571 :return: PermissionProfileInformation 5572 If the method is called asynchronously, 5573 returns the request thread. 5574 """ 5575 kwargs['_return_http_data_only'] = True 5576 if kwargs.get('callback'): 5577 return self.list_permissions_with_http_info(account_id, **kwargs) 5578 else: 5579 (data) = self.list_permissions_with_http_info(account_id, **kwargs) 5580 return data
Gets a list of permission profiles.
Retrieves a list of Permission Profiles. Permission Profiles are a standard set of user permissions that you can apply to individual users or users in a Group. This makes it easier to manage user permissions for a large number of users, without having to change permissions on a user-by-user basis. Currently, Permission Profiles can only be created and modified in the DocuSign console.
This method makes a synchronous HTTP request by default. To make 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_permissions(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 include:
Returns
PermissionProfileInformation If the method is called asynchronously, returns the request thread.
def
list_permissions_with_http_info(self, account_id, **kwargs)
5582 def list_permissions_with_http_info(self, account_id, **kwargs): 5583 """ 5584 Gets a list of permission profiles. 5585 Retrieves a list of Permission Profiles. Permission Profiles are a standard set of user permissions that you can apply to individual users or users in a Group. This makes it easier to manage user permissions for a large number of users, without having to change permissions on a user-by-user basis. Currently, Permission Profiles can only be created and modified in the DocuSign console. 5586 This method makes a synchronous HTTP request by default. To make an 5587 asynchronous HTTP request, please define a `callback` function 5588 to be invoked when receiving the response. 5589 >>> def callback_function(response): 5590 >>> pprint(response) 5591 >>> 5592 >>> thread = api.list_permissions_with_http_info(account_id, callback=callback_function) 5593 5594 :param callback function: The callback function 5595 for asynchronous request. (optional) 5596 :param str account_id: The external account number (int) or account ID Guid. (required) 5597 :param str include: 5598 :return: PermissionProfileInformation 5599 If the method is called asynchronously, 5600 returns the request thread. 5601 """ 5602 5603 all_params = ['account_id', 'include'] 5604 all_params.append('callback') 5605 all_params.append('_return_http_data_only') 5606 all_params.append('_preload_content') 5607 all_params.append('_request_timeout') 5608 5609 params = locals() 5610 for key, val in iteritems(params['kwargs']): 5611 if key not in all_params: 5612 raise TypeError( 5613 "Got an unexpected keyword argument '%s'" 5614 " to method list_permissions" % key 5615 ) 5616 params[key] = val 5617 del params['kwargs'] 5618 # verify the required parameter 'account_id' is set 5619 if ('account_id' not in params) or (params['account_id'] is None): 5620 raise ValueError("Missing the required parameter `account_id` when calling `list_permissions`") 5621 5622 5623 collection_formats = {} 5624 5625 resource_path = '/v2.1/accounts/{accountId}/permission_profiles'.replace('{format}', 'json') 5626 path_params = {} 5627 if 'account_id' in params: 5628 path_params['accountId'] = params['account_id'] 5629 5630 query_params = {} 5631 if 'include' in params: 5632 query_params['include'] = params['include'] 5633 5634 header_params = {} 5635 5636 form_params = [] 5637 local_var_files = {} 5638 5639 body_params = None 5640 # HTTP header `Accept` 5641 header_params['Accept'] = self.api_client.\ 5642 select_header_accept(['application/json']) 5643 5644 # Authentication setting 5645 auth_settings = [] 5646 5647 return self.api_client.call_api(resource_path, 'GET', 5648 path_params, 5649 query_params, 5650 header_params, 5651 body=body_params, 5652 post_params=form_params, 5653 files=local_var_files, 5654 response_type='PermissionProfileInformation', 5655 auth_settings=auth_settings, 5656 callback=params.get('callback'), 5657 _return_http_data_only=params.get('_return_http_data_only'), 5658 _preload_content=params.get('_preload_content', True), 5659 _request_timeout=params.get('_request_timeout'), 5660 collection_formats=collection_formats)
Gets a list of permission profiles.
Retrieves a list of Permission Profiles. Permission Profiles are a standard set of user permissions that you can apply to individual users or users in a Group. This makes it easier to manage user permissions for a large number of users, without having to change permissions on a user-by-user basis. Currently, Permission Profiles can only be created and modified in the DocuSign console.
This method makes a synchronous HTTP request by default. To make 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_permissions_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 include:
Returns
PermissionProfileInformation If the method is called asynchronously, returns the request thread.
def
list_recipient_names_by_email(self, account_id, **kwargs)
5662 def list_recipient_names_by_email(self, account_id, **kwargs): 5663 """ 5664 Gets recipient names associated with an email address. 5665 Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string. 5666 This method makes a synchronous HTTP request by default. To make an 5667 asynchronous HTTP request, please define a `callback` function 5668 to be invoked when receiving the response. 5669 >>> def callback_function(response): 5670 >>> pprint(response) 5671 >>> 5672 >>> thread = api.list_recipient_names_by_email(account_id, callback=callback_function) 5673 5674 :param callback function: The callback function 5675 for asynchronous request. (optional) 5676 :param str account_id: The external account number (int) or account ID Guid. (required) 5677 :param str email: The email address for the user 5678 :return: RecipientNamesResponse 5679 If the method is called asynchronously, 5680 returns the request thread. 5681 """ 5682 kwargs['_return_http_data_only'] = True 5683 if kwargs.get('callback'): 5684 return self.list_recipient_names_by_email_with_http_info(account_id, **kwargs) 5685 else: 5686 (data) = self.list_recipient_names_by_email_with_http_info(account_id, **kwargs) 5687 return data
Gets recipient names associated with an email address.
Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string.
This method makes a synchronous HTTP request by default. To make 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_recipient_names_by_email(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 email: The email address for the user
Returns
RecipientNamesResponse If the method is called asynchronously, returns the request thread.
def
list_recipient_names_by_email_with_http_info(self, account_id, **kwargs)
5689 def list_recipient_names_by_email_with_http_info(self, account_id, **kwargs): 5690 """ 5691 Gets recipient names associated with an email address. 5692 Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string. 5693 This method makes a synchronous HTTP request by default. To make an 5694 asynchronous HTTP request, please define a `callback` function 5695 to be invoked when receiving the response. 5696 >>> def callback_function(response): 5697 >>> pprint(response) 5698 >>> 5699 >>> thread = api.list_recipient_names_by_email_with_http_info(account_id, callback=callback_function) 5700 5701 :param callback function: The callback function 5702 for asynchronous request. (optional) 5703 :param str account_id: The external account number (int) or account ID Guid. (required) 5704 :param str email: The email address for the user 5705 :return: RecipientNamesResponse 5706 If the method is called asynchronously, 5707 returns the request thread. 5708 """ 5709 5710 all_params = ['account_id', 'email'] 5711 all_params.append('callback') 5712 all_params.append('_return_http_data_only') 5713 all_params.append('_preload_content') 5714 all_params.append('_request_timeout') 5715 5716 params = locals() 5717 for key, val in iteritems(params['kwargs']): 5718 if key not in all_params: 5719 raise TypeError( 5720 "Got an unexpected keyword argument '%s'" 5721 " to method list_recipient_names_by_email" % key 5722 ) 5723 params[key] = val 5724 del params['kwargs'] 5725 # verify the required parameter 'account_id' is set 5726 if ('account_id' not in params) or (params['account_id'] is None): 5727 raise ValueError("Missing the required parameter `account_id` when calling `list_recipient_names_by_email`") 5728 5729 5730 collection_formats = {} 5731 5732 resource_path = '/v2.1/accounts/{accountId}/recipient_names'.replace('{format}', 'json') 5733 path_params = {} 5734 if 'account_id' in params: 5735 path_params['accountId'] = params['account_id'] 5736 5737 query_params = {} 5738 if 'email' in params: 5739 query_params['email'] = params['email'] 5740 5741 header_params = {} 5742 5743 form_params = [] 5744 local_var_files = {} 5745 5746 body_params = None 5747 # HTTP header `Accept` 5748 header_params['Accept'] = self.api_client.\ 5749 select_header_accept(['application/json']) 5750 5751 # Authentication setting 5752 auth_settings = [] 5753 5754 return self.api_client.call_api(resource_path, 'GET', 5755 path_params, 5756 query_params, 5757 header_params, 5758 body=body_params, 5759 post_params=form_params, 5760 files=local_var_files, 5761 response_type='RecipientNamesResponse', 5762 auth_settings=auth_settings, 5763 callback=params.get('callback'), 5764 _return_http_data_only=params.get('_return_http_data_only'), 5765 _preload_content=params.get('_preload_content', True), 5766 _request_timeout=params.get('_request_timeout'), 5767 collection_formats=collection_formats)
Gets recipient names associated with an email address.
Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string.
This method makes a synchronous HTTP request by default. To make 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_recipient_names_by_email_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 email: The email address for the user
Returns
RecipientNamesResponse If the method is called asynchronously, returns the request thread.
def
list_settings(self, account_id, **kwargs)
5769 def list_settings(self, account_id, **kwargs): 5770 """ 5771 Gets account settings information. 5772 Retrieves the account settings information for the specified account. 5773 This method makes a synchronous HTTP request by default. To make an 5774 asynchronous HTTP request, please define a `callback` function 5775 to be invoked when receiving the response. 5776 >>> def callback_function(response): 5777 >>> pprint(response) 5778 >>> 5779 >>> thread = api.list_settings(account_id, callback=callback_function) 5780 5781 :param callback function: The callback function 5782 for asynchronous request. (optional) 5783 :param str account_id: The external account number (int) or account ID Guid. (required) 5784 :return: AccountSettingsInformation 5785 If the method is called asynchronously, 5786 returns the request thread. 5787 """ 5788 kwargs['_return_http_data_only'] = True 5789 if kwargs.get('callback'): 5790 return self.list_settings_with_http_info(account_id, **kwargs) 5791 else: 5792 (data) = self.list_settings_with_http_info(account_id, **kwargs) 5793 return data
Gets account settings information.
Retrieves the account settings information for the specified 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.list_settings(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)
Returns
AccountSettingsInformation If the method is called asynchronously, returns the request thread.
def
list_settings_with_http_info(self, account_id, **kwargs)
5795 def list_settings_with_http_info(self, account_id, **kwargs): 5796 """ 5797 Gets account settings information. 5798 Retrieves the account settings information for the specified account. 5799 This method makes a synchronous HTTP request by default. To make an 5800 asynchronous HTTP request, please define a `callback` function 5801 to be invoked when receiving the response. 5802 >>> def callback_function(response): 5803 >>> pprint(response) 5804 >>> 5805 >>> thread = api.list_settings_with_http_info(account_id, callback=callback_function) 5806 5807 :param callback function: The callback function 5808 for asynchronous request. (optional) 5809 :param str account_id: The external account number (int) or account ID Guid. (required) 5810 :return: AccountSettingsInformation 5811 If the method is called asynchronously, 5812 returns the request thread. 5813 """ 5814 5815 all_params = ['account_id'] 5816 all_params.append('callback') 5817 all_params.append('_return_http_data_only') 5818 all_params.append('_preload_content') 5819 all_params.append('_request_timeout') 5820 5821 params = locals() 5822 for key, val in iteritems(params['kwargs']): 5823 if key not in all_params: 5824 raise TypeError( 5825 "Got an unexpected keyword argument '%s'" 5826 " to method list_settings" % key 5827 ) 5828 params[key] = val 5829 del params['kwargs'] 5830 # verify the required parameter 'account_id' is set 5831 if ('account_id' not in params) or (params['account_id'] is None): 5832 raise ValueError("Missing the required parameter `account_id` when calling `list_settings`") 5833 5834 5835 collection_formats = {} 5836 5837 resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json') 5838 path_params = {} 5839 if 'account_id' in params: 5840 path_params['accountId'] = params['account_id'] 5841 5842 query_params = {} 5843 5844 header_params = {} 5845 5846 form_params = [] 5847 local_var_files = {} 5848 5849 body_params = None 5850 # HTTP header `Accept` 5851 header_params['Accept'] = self.api_client.\ 5852 select_header_accept(['application/json']) 5853 5854 # Authentication setting 5855 auth_settings = [] 5856 5857 return self.api_client.call_api(resource_path, 'GET', 5858 path_params, 5859 query_params, 5860 header_params, 5861 body=body_params, 5862 post_params=form_params, 5863 files=local_var_files, 5864 response_type='AccountSettingsInformation', 5865 auth_settings=auth_settings, 5866 callback=params.get('callback'), 5867 _return_http_data_only=params.get('_return_http_data_only'), 5868 _preload_content=params.get('_preload_content', True), 5869 _request_timeout=params.get('_request_timeout'), 5870 collection_formats=collection_formats)
Gets account settings information.
Retrieves the account settings information for the specified 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.list_settings_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)
Returns
AccountSettingsInformation If the method is called asynchronously, returns the request thread.
def
list_signature_providers(self, account_id, **kwargs)
6007 def list_signature_providers(self, account_id, **kwargs): 6008 """ 6009 Returns Account available signature providers for specified account. 6010 Returns a list of signature providers that the specified account can use. 6011 This method makes a synchronous HTTP request by default. To make an 6012 asynchronous HTTP request, please define a `callback` function 6013 to be invoked when receiving the response. 6014 >>> def callback_function(response): 6015 >>> pprint(response) 6016 >>> 6017 >>> thread = api.list_signature_providers(account_id, callback=callback_function) 6018 6019 :param callback function: The callback function 6020 for asynchronous request. (optional) 6021 :param str account_id: The external account number (int) or account ID Guid. (required) 6022 :return: AccountSignatureProviders 6023 If the method is called asynchronously, 6024 returns the request thread. 6025 """ 6026 kwargs['_return_http_data_only'] = True 6027 if kwargs.get('callback'): 6028 return self.list_signature_providers_with_http_info(account_id, **kwargs) 6029 else: 6030 (data) = self.list_signature_providers_with_http_info(account_id, **kwargs) 6031 return data
Returns Account available signature providers for specified account.
Returns a list of signature providers that the specified account can use.
This method makes a synchronous HTTP request by default. To make 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_signature_providers(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)
Returns
AccountSignatureProviders If the method is called asynchronously, returns the request thread.
def
list_signature_providers_with_http_info(self, account_id, **kwargs)
6033 def list_signature_providers_with_http_info(self, account_id, **kwargs): 6034 """ 6035 Returns Account available signature providers for specified account. 6036 Returns a list of signature providers that the specified account can use. 6037 This method makes a synchronous HTTP request by default. To make an 6038 asynchronous HTTP request, please define a `callback` function 6039 to be invoked when receiving the response. 6040 >>> def callback_function(response): 6041 >>> pprint(response) 6042 >>> 6043 >>> thread = api.list_signature_providers_with_http_info(account_id, callback=callback_function) 6044 6045 :param callback function: The callback function 6046 for asynchronous request. (optional) 6047 :param str account_id: The external account number (int) or account ID Guid. (required) 6048 :return: AccountSignatureProviders 6049 If the method is called asynchronously, 6050 returns the request thread. 6051 """ 6052 6053 all_params = ['account_id'] 6054 all_params.append('callback') 6055 all_params.append('_return_http_data_only') 6056 all_params.append('_preload_content') 6057 all_params.append('_request_timeout') 6058 6059 params = locals() 6060 for key, val in iteritems(params['kwargs']): 6061 if key not in all_params: 6062 raise TypeError( 6063 "Got an unexpected keyword argument '%s'" 6064 " to method list_signature_providers" % key 6065 ) 6066 params[key] = val 6067 del params['kwargs'] 6068 # verify the required parameter 'account_id' is set 6069 if ('account_id' not in params) or (params['account_id'] is None): 6070 raise ValueError("Missing the required parameter `account_id` when calling `list_signature_providers`") 6071 6072 6073 collection_formats = {} 6074 6075 resource_path = '/v2.1/accounts/{accountId}/signatureProviders'.replace('{format}', 'json') 6076 path_params = {} 6077 if 'account_id' in params: 6078 path_params['accountId'] = params['account_id'] 6079 6080 query_params = {} 6081 6082 header_params = {} 6083 6084 form_params = [] 6085 local_var_files = {} 6086 6087 body_params = None 6088 # HTTP header `Accept` 6089 header_params['Accept'] = self.api_client.\ 6090 select_header_accept(['application/json']) 6091 6092 # Authentication setting 6093 auth_settings = [] 6094 6095 return self.api_client.call_api(resource_path, 'GET', 6096 path_params, 6097 query_params, 6098 header_params, 6099 body=body_params, 6100 post_params=form_params, 6101 files=local_var_files, 6102 response_type='AccountSignatureProviders', 6103 auth_settings=auth_settings, 6104 callback=params.get('callback'), 6105 _return_http_data_only=params.get('_return_http_data_only'), 6106 _preload_content=params.get('_preload_content', True), 6107 _request_timeout=params.get('_request_timeout'), 6108 collection_formats=collection_formats)
Returns Account available signature providers for specified account.
Returns a list of signature providers that the specified account can use.
This method makes a synchronous HTTP request by default. To make 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_signature_providers_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)
Returns
AccountSignatureProviders If the method is called asynchronously, returns the request thread.
def
list_unsupported_file_types(self, account_id, **kwargs)
6110 def list_unsupported_file_types(self, account_id, **kwargs): 6111 """ 6112 Gets a list of unsupported file types. 6113 Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system. 6114 This method makes a synchronous HTTP request by default. To make an 6115 asynchronous HTTP request, please define a `callback` function 6116 to be invoked when receiving the response. 6117 >>> def callback_function(response): 6118 >>> pprint(response) 6119 >>> 6120 >>> thread = api.list_unsupported_file_types(account_id, callback=callback_function) 6121 6122 :param callback function: The callback function 6123 for asynchronous request. (optional) 6124 :param str account_id: The external account number (int) or account ID Guid. (required) 6125 :return: FileTypeList 6126 If the method is called asynchronously, 6127 returns the request thread. 6128 """ 6129 kwargs['_return_http_data_only'] = True 6130 if kwargs.get('callback'): 6131 return self.list_unsupported_file_types_with_http_info(account_id, **kwargs) 6132 else: 6133 (data) = self.list_unsupported_file_types_with_http_info(account_id, **kwargs) 6134 return data
Gets a list of unsupported file types.
Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system.
This method makes a synchronous HTTP request by default. To make 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_unsupported_file_types(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)
Returns
FileTypeList If the method is called asynchronously, returns the request thread.
def
list_unsupported_file_types_with_http_info(self, account_id, **kwargs)
6136 def list_unsupported_file_types_with_http_info(self, account_id, **kwargs): 6137 """ 6138 Gets a list of unsupported file types. 6139 Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system. 6140 This method makes a synchronous HTTP request by default. To make an 6141 asynchronous HTTP request, please define a `callback` function 6142 to be invoked when receiving the response. 6143 >>> def callback_function(response): 6144 >>> pprint(response) 6145 >>> 6146 >>> thread = api.list_unsupported_file_types_with_http_info(account_id, callback=callback_function) 6147 6148 :param callback function: The callback function 6149 for asynchronous request. (optional) 6150 :param str account_id: The external account number (int) or account ID Guid. (required) 6151 :return: FileTypeList 6152 If the method is called asynchronously, 6153 returns the request thread. 6154 """ 6155 6156 all_params = ['account_id'] 6157 all_params.append('callback') 6158 all_params.append('_return_http_data_only') 6159 all_params.append('_preload_content') 6160 all_params.append('_request_timeout') 6161 6162 params = locals() 6163 for key, val in iteritems(params['kwargs']): 6164 if key not in all_params: 6165 raise TypeError( 6166 "Got an unexpected keyword argument '%s'" 6167 " to method list_unsupported_file_types" % key 6168 ) 6169 params[key] = val 6170 del params['kwargs'] 6171 # verify the required parameter 'account_id' is set 6172 if ('account_id' not in params) or (params['account_id'] is None): 6173 raise ValueError("Missing the required parameter `account_id` when calling `list_unsupported_file_types`") 6174 6175 6176 collection_formats = {} 6177 6178 resource_path = '/v2.1/accounts/{accountId}/unsupported_file_types'.replace('{format}', 'json') 6179 path_params = {} 6180 if 'account_id' in params: 6181 path_params['accountId'] = params['account_id'] 6182 6183 query_params = {} 6184 6185 header_params = {} 6186 6187 form_params = [] 6188 local_var_files = {} 6189 6190 body_params = None 6191 # HTTP header `Accept` 6192 header_params['Accept'] = self.api_client.\ 6193 select_header_accept(['application/json']) 6194 6195 # Authentication setting 6196 auth_settings = [] 6197 6198 return self.api_client.call_api(resource_path, 'GET', 6199 path_params, 6200 query_params, 6201 header_params, 6202 body=body_params, 6203 post_params=form_params, 6204 files=local_var_files, 6205 response_type='FileTypeList', 6206 auth_settings=auth_settings, 6207 callback=params.get('callback'), 6208 _return_http_data_only=params.get('_return_http_data_only'), 6209 _preload_content=params.get('_preload_content', True), 6210 _request_timeout=params.get('_request_timeout'), 6211 collection_formats=collection_formats)
Gets a list of unsupported file types.
Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system.
This method makes a synchronous HTTP request by default. To make 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_unsupported_file_types_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)
Returns
FileTypeList If the method is called asynchronously, returns the request thread.
def
un_favorite_template(self, account_id, **kwargs)
6213 def un_favorite_template(self, account_id, **kwargs): 6214 """ 6215 Unfavorite a template 6216 6217 This method makes a synchronous HTTP request by default. To make an 6218 asynchronous HTTP request, please define a `callback` function 6219 to be invoked when receiving the response. 6220 >>> def callback_function(response): 6221 >>> pprint(response) 6222 >>> 6223 >>> thread = api.un_favorite_template(account_id, callback=callback_function) 6224 6225 :param callback function: The callback function 6226 for asynchronous request. (optional) 6227 :param str account_id: The external account number (int) or account ID Guid. (required) 6228 :param FavoriteTemplatesInfo favorite_templates_info: 6229 :return: FavoriteTemplatesInfo 6230 If the method is called asynchronously, 6231 returns the request thread. 6232 """ 6233 kwargs['_return_http_data_only'] = True 6234 if kwargs.get('callback'): 6235 return self.un_favorite_template_with_http_info(account_id, **kwargs) 6236 else: 6237 (data) = self.un_favorite_template_with_http_info(account_id, **kwargs) 6238 return data
Unfavorite a template
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.un_favorite_template(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)
- FavoriteTemplatesInfo favorite_templates_info:
Returns
FavoriteTemplatesInfo If the method is called asynchronously, returns the request thread.
def
un_favorite_template_with_http_info(self, account_id, **kwargs)
6240 def un_favorite_template_with_http_info(self, account_id, **kwargs): 6241 """ 6242 Unfavorite a template 6243 6244 This method makes a synchronous HTTP request by default. To make an 6245 asynchronous HTTP request, please define a `callback` function 6246 to be invoked when receiving the response. 6247 >>> def callback_function(response): 6248 >>> pprint(response) 6249 >>> 6250 >>> thread = api.un_favorite_template_with_http_info(account_id, callback=callback_function) 6251 6252 :param callback function: The callback function 6253 for asynchronous request. (optional) 6254 :param str account_id: The external account number (int) or account ID Guid. (required) 6255 :param FavoriteTemplatesInfo favorite_templates_info: 6256 :return: FavoriteTemplatesInfo 6257 If the method is called asynchronously, 6258 returns the request thread. 6259 """ 6260 6261 all_params = ['account_id', 'favorite_templates_info'] 6262 all_params.append('callback') 6263 all_params.append('_return_http_data_only') 6264 all_params.append('_preload_content') 6265 all_params.append('_request_timeout') 6266 6267 params = locals() 6268 for key, val in iteritems(params['kwargs']): 6269 if key not in all_params: 6270 raise TypeError( 6271 "Got an unexpected keyword argument '%s'" 6272 " to method un_favorite_template" % key 6273 ) 6274 params[key] = val 6275 del params['kwargs'] 6276 # verify the required parameter 'account_id' is set 6277 if ('account_id' not in params) or (params['account_id'] is None): 6278 raise ValueError("Missing the required parameter `account_id` when calling `un_favorite_template`") 6279 6280 6281 collection_formats = {} 6282 6283 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 6284 path_params = {} 6285 if 'account_id' in params: 6286 path_params['accountId'] = params['account_id'] 6287 6288 query_params = {} 6289 6290 header_params = {} 6291 6292 form_params = [] 6293 local_var_files = {} 6294 6295 body_params = None 6296 if 'favorite_templates_info' in params: 6297 body_params = params['favorite_templates_info'] 6298 # HTTP header `Accept` 6299 header_params['Accept'] = self.api_client.\ 6300 select_header_accept(['application/json']) 6301 6302 # Authentication setting 6303 auth_settings = [] 6304 6305 return self.api_client.call_api(resource_path, 'DELETE', 6306 path_params, 6307 query_params, 6308 header_params, 6309 body=body_params, 6310 post_params=form_params, 6311 files=local_var_files, 6312 response_type='FavoriteTemplatesInfo', 6313 auth_settings=auth_settings, 6314 callback=params.get('callback'), 6315 _return_http_data_only=params.get('_return_http_data_only'), 6316 _preload_content=params.get('_preload_content', True), 6317 _request_timeout=params.get('_request_timeout'), 6318 collection_formats=collection_formats)
Unfavorite a template
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.un_favorite_template_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)
- FavoriteTemplatesInfo favorite_templates_info:
Returns
FavoriteTemplatesInfo If the method is called asynchronously, returns the request thread.
def
update_account_signature(self, account_id, **kwargs)
6320 def update_account_signature(self, account_id, **kwargs): 6321 """ 6322 Updates a account signature. 6323 6324 This method makes a synchronous HTTP request by default. To make an 6325 asynchronous HTTP request, please define a `callback` function 6326 to be invoked when receiving the response. 6327 >>> def callback_function(response): 6328 >>> pprint(response) 6329 >>> 6330 >>> thread = api.update_account_signature(account_id, callback=callback_function) 6331 6332 :param callback function: The callback function 6333 for asynchronous request. (optional) 6334 :param str account_id: The external account number (int) or account ID Guid. (required) 6335 :param AccountSignaturesInformation account_signatures_information: 6336 :return: AccountSignaturesInformation 6337 If the method is called asynchronously, 6338 returns the request thread. 6339 """ 6340 kwargs['_return_http_data_only'] = True 6341 if kwargs.get('callback'): 6342 return self.update_account_signature_with_http_info(account_id, **kwargs) 6343 else: 6344 (data) = self.update_account_signature_with_http_info(account_id, **kwargs) 6345 return data
Updates a account signature.
This method makes a synchronous HTTP request by default. To make 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_signature(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)
- AccountSignaturesInformation account_signatures_information:
Returns
AccountSignaturesInformation If the method is called asynchronously, returns the request thread.
def
update_account_signature_with_http_info(self, account_id, **kwargs)
6347 def update_account_signature_with_http_info(self, account_id, **kwargs): 6348 """ 6349 Updates a account signature. 6350 6351 This method makes a synchronous HTTP request by default. To make an 6352 asynchronous HTTP request, please define a `callback` function 6353 to be invoked when receiving the response. 6354 >>> def callback_function(response): 6355 >>> pprint(response) 6356 >>> 6357 >>> thread = api.update_account_signature_with_http_info(account_id, callback=callback_function) 6358 6359 :param callback function: The callback function 6360 for asynchronous request. (optional) 6361 :param str account_id: The external account number (int) or account ID Guid. (required) 6362 :param AccountSignaturesInformation account_signatures_information: 6363 :return: AccountSignaturesInformation 6364 If the method is called asynchronously, 6365 returns the request thread. 6366 """ 6367 6368 all_params = ['account_id', 'account_signatures_information'] 6369 all_params.append('callback') 6370 all_params.append('_return_http_data_only') 6371 all_params.append('_preload_content') 6372 all_params.append('_request_timeout') 6373 6374 params = locals() 6375 for key, val in iteritems(params['kwargs']): 6376 if key not in all_params: 6377 raise TypeError( 6378 "Got an unexpected keyword argument '%s'" 6379 " to method update_account_signature" % key 6380 ) 6381 params[key] = val 6382 del params['kwargs'] 6383 # verify the required parameter 'account_id' is set 6384 if ('account_id' not in params) or (params['account_id'] is None): 6385 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature`") 6386 6387 6388 collection_formats = {} 6389 6390 resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json') 6391 path_params = {} 6392 if 'account_id' in params: 6393 path_params['accountId'] = params['account_id'] 6394 6395 query_params = {} 6396 6397 header_params = {} 6398 6399 form_params = [] 6400 local_var_files = {} 6401 6402 body_params = None 6403 if 'account_signatures_information' in params: 6404 body_params = params['account_signatures_information'] 6405 # HTTP header `Accept` 6406 header_params['Accept'] = self.api_client.\ 6407 select_header_accept(['application/json']) 6408 6409 # Authentication setting 6410 auth_settings = [] 6411 6412 return self.api_client.call_api(resource_path, 'PUT', 6413 path_params, 6414 query_params, 6415 header_params, 6416 body=body_params, 6417 post_params=form_params, 6418 files=local_var_files, 6419 response_type='AccountSignaturesInformation', 6420 auth_settings=auth_settings, 6421 callback=params.get('callback'), 6422 _return_http_data_only=params.get('_return_http_data_only'), 6423 _preload_content=params.get('_preload_content', True), 6424 _request_timeout=params.get('_request_timeout'), 6425 collection_formats=collection_formats)
Updates a account signature.
This method makes a synchronous HTTP request by default. To make 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_signature_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)
- AccountSignaturesInformation account_signatures_information:
Returns
AccountSignaturesInformation If the method is called asynchronously, returns the request thread.
def
update_account_signature_by_id(self, account_id, signature_id, **kwargs)
6427 def update_account_signature_by_id(self, account_id, signature_id, **kwargs): 6428 """ 6429 Updates a account signature. 6430 6431 This method makes a synchronous HTTP request by default. To make an 6432 asynchronous HTTP request, please define a `callback` function 6433 to be invoked when receiving the response. 6434 >>> def callback_function(response): 6435 >>> pprint(response) 6436 >>> 6437 >>> thread = api.update_account_signature_by_id(account_id, signature_id, callback=callback_function) 6438 6439 :param callback function: The callback function 6440 for asynchronous request. (optional) 6441 :param str account_id: The external account number (int) or account ID Guid. (required) 6442 :param str signature_id: The ID of the signature being accessed. (required) 6443 :param str close_existing_signature: 6444 :param AccountSignatureDefinition account_signature_definition: 6445 :return: AccountSignature 6446 If the method is called asynchronously, 6447 returns the request thread. 6448 """ 6449 kwargs['_return_http_data_only'] = True 6450 if kwargs.get('callback'): 6451 return self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs) 6452 else: 6453 (data) = self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs) 6454 return data
Updates a account signature.
This method makes a synchronous HTTP request by default. To make 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_signature_by_id(account_id, signature_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str signature_id: The ID of the signature being accessed. (required)
- str close_existing_signature:
- AccountSignatureDefinition account_signature_definition:
Returns
AccountSignature If the method is called asynchronously, returns the request thread.
def
update_account_signature_by_id_with_http_info(self, account_id, signature_id, **kwargs)
6456 def update_account_signature_by_id_with_http_info(self, account_id, signature_id, **kwargs): 6457 """ 6458 Updates a account signature. 6459 6460 This method makes a synchronous HTTP request by default. To make an 6461 asynchronous HTTP request, please define a `callback` function 6462 to be invoked when receiving the response. 6463 >>> def callback_function(response): 6464 >>> pprint(response) 6465 >>> 6466 >>> thread = api.update_account_signature_by_id_with_http_info(account_id, signature_id, callback=callback_function) 6467 6468 :param callback function: The callback function 6469 for asynchronous request. (optional) 6470 :param str account_id: The external account number (int) or account ID Guid. (required) 6471 :param str signature_id: The ID of the signature being accessed. (required) 6472 :param str close_existing_signature: 6473 :param AccountSignatureDefinition account_signature_definition: 6474 :return: AccountSignature 6475 If the method is called asynchronously, 6476 returns the request thread. 6477 """ 6478 6479 all_params = ['account_id', 'signature_id', 'close_existing_signature', 'account_signature_definition'] 6480 all_params.append('callback') 6481 all_params.append('_return_http_data_only') 6482 all_params.append('_preload_content') 6483 all_params.append('_request_timeout') 6484 6485 params = locals() 6486 for key, val in iteritems(params['kwargs']): 6487 if key not in all_params: 6488 raise TypeError( 6489 "Got an unexpected keyword argument '%s'" 6490 " to method update_account_signature_by_id" % key 6491 ) 6492 params[key] = val 6493 del params['kwargs'] 6494 # verify the required parameter 'account_id' is set 6495 if ('account_id' not in params) or (params['account_id'] is None): 6496 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_by_id`") 6497 # verify the required parameter 'signature_id' is set 6498 if ('signature_id' not in params) or (params['signature_id'] is None): 6499 raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_by_id`") 6500 6501 6502 collection_formats = {} 6503 6504 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 6505 path_params = {} 6506 if 'account_id' in params: 6507 path_params['accountId'] = params['account_id'] 6508 if 'signature_id' in params: 6509 path_params['signatureId'] = params['signature_id'] 6510 6511 query_params = {} 6512 if 'close_existing_signature' in params: 6513 query_params['close_existing_signature'] = params['close_existing_signature'] 6514 6515 header_params = {} 6516 6517 form_params = [] 6518 local_var_files = {} 6519 6520 body_params = None 6521 if 'account_signature_definition' in params: 6522 body_params = params['account_signature_definition'] 6523 # HTTP header `Accept` 6524 header_params['Accept'] = self.api_client.\ 6525 select_header_accept(['application/json']) 6526 6527 # Authentication setting 6528 auth_settings = [] 6529 6530 return self.api_client.call_api(resource_path, 'PUT', 6531 path_params, 6532 query_params, 6533 header_params, 6534 body=body_params, 6535 post_params=form_params, 6536 files=local_var_files, 6537 response_type='AccountSignature', 6538 auth_settings=auth_settings, 6539 callback=params.get('callback'), 6540 _return_http_data_only=params.get('_return_http_data_only'), 6541 _preload_content=params.get('_preload_content', True), 6542 _request_timeout=params.get('_request_timeout'), 6543 collection_formats=collection_formats)
Updates a account signature.
This method makes a synchronous HTTP request by default. To make 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_signature_by_id_with_http_info(account_id, signature_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str signature_id: The ID of the signature being accessed. (required)
- str close_existing_signature:
- AccountSignatureDefinition account_signature_definition:
Returns
AccountSignature If the method is called asynchronously, returns the request thread.
def
update_account_signature_image(self, account_id, image_type, signature_id, **kwargs)
6545 def update_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 6546 """ 6547 Sets a signature, initials, or stamps image. 6548 6549 This method makes a synchronous HTTP request by default. To make an 6550 asynchronous HTTP request, please define a `callback` function 6551 to be invoked when receiving the response. 6552 >>> def callback_function(response): 6553 >>> pprint(response) 6554 >>> 6555 >>> thread = api.update_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 6556 6557 :param callback function: The callback function 6558 for asynchronous request. (optional) 6559 :param str account_id: The external account number (int) or account ID Guid. (required) 6560 :param str image_type: One of **signature_image** or **initials_image**. (required) 6561 :param str signature_id: The ID of the signature being accessed. (required) 6562 :param str transparent_png: 6563 :return: AccountSignature 6564 If the method is called asynchronously, 6565 returns the request thread. 6566 """ 6567 kwargs['_return_http_data_only'] = True 6568 if kwargs.get('callback'): 6569 return self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 6570 else: 6571 (data) = self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 6572 return data
Sets a signature, initials, or stamps 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.update_account_signature_image(account_id, image_type, signature_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str image_type: One of signature_image or initials_image. (required)
- str signature_id: The ID of the signature being accessed. (required)
- str transparent_png:
Returns
AccountSignature If the method is called asynchronously, returns the request thread.
def
update_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs)
6574 def update_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 6575 """ 6576 Sets a signature, initials, or stamps image. 6577 6578 This method makes a synchronous HTTP request by default. To make an 6579 asynchronous HTTP request, please define a `callback` function 6580 to be invoked when receiving the response. 6581 >>> def callback_function(response): 6582 >>> pprint(response) 6583 >>> 6584 >>> thread = api.update_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 6585 6586 :param callback function: The callback function 6587 for asynchronous request. (optional) 6588 :param str account_id: The external account number (int) or account ID Guid. (required) 6589 :param str image_type: One of **signature_image** or **initials_image**. (required) 6590 :param str signature_id: The ID of the signature being accessed. (required) 6591 :param str transparent_png: 6592 :return: AccountSignature 6593 If the method is called asynchronously, 6594 returns the request thread. 6595 """ 6596 6597 all_params = ['account_id', 'image_type', 'signature_id', 'transparent_png'] 6598 all_params.append('callback') 6599 all_params.append('_return_http_data_only') 6600 all_params.append('_preload_content') 6601 all_params.append('_request_timeout') 6602 6603 params = locals() 6604 for key, val in iteritems(params['kwargs']): 6605 if key not in all_params: 6606 raise TypeError( 6607 "Got an unexpected keyword argument '%s'" 6608 " to method update_account_signature_image" % key 6609 ) 6610 params[key] = val 6611 del params['kwargs'] 6612 # verify the required parameter 'account_id' is set 6613 if ('account_id' not in params) or (params['account_id'] is None): 6614 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_image`") 6615 # verify the required parameter 'image_type' is set 6616 if ('image_type' not in params) or (params['image_type'] is None): 6617 raise ValueError("Missing the required parameter `image_type` when calling `update_account_signature_image`") 6618 # verify the required parameter 'signature_id' is set 6619 if ('signature_id' not in params) or (params['signature_id'] is None): 6620 raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_image`") 6621 6622 6623 collection_formats = {} 6624 6625 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 6626 path_params = {} 6627 if 'account_id' in params: 6628 path_params['accountId'] = params['account_id'] 6629 if 'image_type' in params: 6630 path_params['imageType'] = params['image_type'] 6631 if 'signature_id' in params: 6632 path_params['signatureId'] = params['signature_id'] 6633 6634 query_params = {} 6635 if 'transparent_png' in params: 6636 query_params['transparent_png'] = params['transparent_png'] 6637 6638 header_params = {} 6639 6640 form_params = [] 6641 local_var_files = {} 6642 6643 body_params = None 6644 # HTTP header `Accept` 6645 header_params['Accept'] = self.api_client.\ 6646 select_header_accept(['application/json']) 6647 6648 # HTTP header `Content-Type` 6649 header_params['Content-Type'] = self.api_client.\ 6650 select_header_content_type(['image/gif']) 6651 6652 # Authentication setting 6653 auth_settings = [] 6654 6655 return self.api_client.call_api(resource_path, 'PUT', 6656 path_params, 6657 query_params, 6658 header_params, 6659 body=body_params, 6660 post_params=form_params, 6661 files=local_var_files, 6662 response_type='AccountSignature', 6663 auth_settings=auth_settings, 6664 callback=params.get('callback'), 6665 _return_http_data_only=params.get('_return_http_data_only'), 6666 _preload_content=params.get('_preload_content', True), 6667 _request_timeout=params.get('_request_timeout'), 6668 collection_formats=collection_formats)
Sets a signature, initials, or stamps 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.update_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str image_type: One of signature_image or initials_image. (required)
- str signature_id: The ID of the signature being accessed. (required)
- str transparent_png:
Returns
AccountSignature If the method is called asynchronously, returns the request thread.
def
update_account_tab_settings(self, account_id, **kwargs)
6670 def update_account_tab_settings(self, account_id, **kwargs): 6671 """ 6672 Modifies tab settings for specified account 6673 This method modifies the tab types and tab functionality that is enabled for an account. 6674 This method makes a synchronous HTTP request by default. To make an 6675 asynchronous HTTP request, please define a `callback` function 6676 to be invoked when receiving the response. 6677 >>> def callback_function(response): 6678 >>> pprint(response) 6679 >>> 6680 >>> thread = api.update_account_tab_settings(account_id, callback=callback_function) 6681 6682 :param callback function: The callback function 6683 for asynchronous request. (optional) 6684 :param str account_id: The external account number (int) or account ID Guid. (required) 6685 :param TabAccountSettings tab_account_settings: 6686 :return: TabAccountSettings 6687 If the method is called asynchronously, 6688 returns the request thread. 6689 """ 6690 kwargs['_return_http_data_only'] = True 6691 if kwargs.get('callback'): 6692 return self.update_account_tab_settings_with_http_info(account_id, **kwargs) 6693 else: 6694 (data) = self.update_account_tab_settings_with_http_info(account_id, **kwargs) 6695 return data
Modifies tab settings for specified account
This method modifies the tab types and tab functionality that is enabled for an 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_account_tab_settings(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)
- TabAccountSettings tab_account_settings:
Returns
TabAccountSettings If the method is called asynchronously, returns the request thread.
def
update_account_tab_settings_with_http_info(self, account_id, **kwargs)
6697 def update_account_tab_settings_with_http_info(self, account_id, **kwargs): 6698 """ 6699 Modifies tab settings for specified account 6700 This method modifies the tab types and tab functionality that is enabled for an account. 6701 This method makes a synchronous HTTP request by default. To make an 6702 asynchronous HTTP request, please define a `callback` function 6703 to be invoked when receiving the response. 6704 >>> def callback_function(response): 6705 >>> pprint(response) 6706 >>> 6707 >>> thread = api.update_account_tab_settings_with_http_info(account_id, callback=callback_function) 6708 6709 :param callback function: The callback function 6710 for asynchronous request. (optional) 6711 :param str account_id: The external account number (int) or account ID Guid. (required) 6712 :param TabAccountSettings tab_account_settings: 6713 :return: TabAccountSettings 6714 If the method is called asynchronously, 6715 returns the request thread. 6716 """ 6717 6718 all_params = ['account_id', 'tab_account_settings'] 6719 all_params.append('callback') 6720 all_params.append('_return_http_data_only') 6721 all_params.append('_preload_content') 6722 all_params.append('_request_timeout') 6723 6724 params = locals() 6725 for key, val in iteritems(params['kwargs']): 6726 if key not in all_params: 6727 raise TypeError( 6728 "Got an unexpected keyword argument '%s'" 6729 " to method update_account_tab_settings" % key 6730 ) 6731 params[key] = val 6732 del params['kwargs'] 6733 # verify the required parameter 'account_id' is set 6734 if ('account_id' not in params) or (params['account_id'] is None): 6735 raise ValueError("Missing the required parameter `account_id` when calling `update_account_tab_settings`") 6736 6737 6738 collection_formats = {} 6739 6740 resource_path = '/v2.1/accounts/{accountId}/settings/tabs'.replace('{format}', 'json') 6741 path_params = {} 6742 if 'account_id' in params: 6743 path_params['accountId'] = params['account_id'] 6744 6745 query_params = {} 6746 6747 header_params = {} 6748 6749 form_params = [] 6750 local_var_files = {} 6751 6752 body_params = None 6753 if 'tab_account_settings' in params: 6754 body_params = params['tab_account_settings'] 6755 # HTTP header `Accept` 6756 header_params['Accept'] = self.api_client.\ 6757 select_header_accept(['application/json']) 6758 6759 # Authentication setting 6760 auth_settings = [] 6761 6762 return self.api_client.call_api(resource_path, 'PUT', 6763 path_params, 6764 query_params, 6765 header_params, 6766 body=body_params, 6767 post_params=form_params, 6768 files=local_var_files, 6769 response_type='TabAccountSettings', 6770 auth_settings=auth_settings, 6771 callback=params.get('callback'), 6772 _return_http_data_only=params.get('_return_http_data_only'), 6773 _preload_content=params.get('_preload_content', True), 6774 _request_timeout=params.get('_request_timeout'), 6775 collection_formats=collection_formats)
Modifies tab settings for specified account
This method modifies the tab types and tab functionality that is enabled for an 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_account_tab_settings_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)
- TabAccountSettings tab_account_settings:
Returns
TabAccountSettings If the method is called asynchronously, returns the request thread.
def
update_brand(self, account_id, brand_id, **kwargs)
6777 def update_brand(self, account_id, brand_id, **kwargs): 6778 """ 6779 Updates an existing brand. 6780 This method updates an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 6781 This method makes a synchronous HTTP request by default. To make an 6782 asynchronous HTTP request, please define a `callback` function 6783 to be invoked when receiving the response. 6784 >>> def callback_function(response): 6785 >>> pprint(response) 6786 >>> 6787 >>> thread = api.update_brand(account_id, brand_id, callback=callback_function) 6788 6789 :param callback function: The callback function 6790 for asynchronous request. (optional) 6791 :param str account_id: The external account number (int) or account ID Guid. (required) 6792 :param str brand_id: The unique identifier of a brand. (required) 6793 :param str replace_brand: 6794 :param Brand brand: 6795 :return: Brand 6796 If the method is called asynchronously, 6797 returns the request thread. 6798 """ 6799 kwargs['_return_http_data_only'] = True 6800 if kwargs.get('callback'): 6801 return self.update_brand_with_http_info(account_id, brand_id, **kwargs) 6802 else: 6803 (data) = self.update_brand_with_http_info(account_id, brand_id, **kwargs) 6804 return data
Updates an existing brand.
This method updates an account brand. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be 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.update_brand(account_id, brand_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str brand_id: The unique identifier of a brand. (required)
- str replace_brand:
- Brand brand:
Returns
Brand If the method is called asynchronously, returns the request thread.
def
update_brand_with_http_info(self, account_id, brand_id, **kwargs)
6806 def update_brand_with_http_info(self, account_id, brand_id, **kwargs): 6807 """ 6808 Updates an existing brand. 6809 This method updates an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 6810 This method makes a synchronous HTTP request by default. To make an 6811 asynchronous HTTP request, please define a `callback` function 6812 to be invoked when receiving the response. 6813 >>> def callback_function(response): 6814 >>> pprint(response) 6815 >>> 6816 >>> thread = api.update_brand_with_http_info(account_id, brand_id, callback=callback_function) 6817 6818 :param callback function: The callback function 6819 for asynchronous request. (optional) 6820 :param str account_id: The external account number (int) or account ID Guid. (required) 6821 :param str brand_id: The unique identifier of a brand. (required) 6822 :param str replace_brand: 6823 :param Brand brand: 6824 :return: Brand 6825 If the method is called asynchronously, 6826 returns the request thread. 6827 """ 6828 6829 all_params = ['account_id', 'brand_id', 'replace_brand', 'brand'] 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 update_brand" % 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 `update_brand`") 6847 # verify the required parameter 'brand_id' is set 6848 if ('brand_id' not in params) or (params['brand_id'] is None): 6849 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand`") 6850 6851 6852 collection_formats = {} 6853 6854 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 6855 path_params = {} 6856 if 'account_id' in params: 6857 path_params['accountId'] = params['account_id'] 6858 if 'brand_id' in params: 6859 path_params['brandId'] = params['brand_id'] 6860 6861 query_params = {} 6862 if 'replace_brand' in params: 6863 query_params['replace_brand'] = params['replace_brand'] 6864 6865 header_params = {} 6866 6867 form_params = [] 6868 local_var_files = {} 6869 6870 body_params = None 6871 if 'brand' in params: 6872 body_params = params['brand'] 6873 # HTTP header `Accept` 6874 header_params['Accept'] = self.api_client.\ 6875 select_header_accept(['application/json']) 6876 6877 # Authentication setting 6878 auth_settings = [] 6879 6880 return self.api_client.call_api(resource_path, 'PUT', 6881 path_params, 6882 query_params, 6883 header_params, 6884 body=body_params, 6885 post_params=form_params, 6886 files=local_var_files, 6887 response_type='Brand', 6888 auth_settings=auth_settings, 6889 callback=params.get('callback'), 6890 _return_http_data_only=params.get('_return_http_data_only'), 6891 _preload_content=params.get('_preload_content', True), 6892 _request_timeout=params.get('_request_timeout'), 6893 collection_formats=collection_formats)
Updates an existing brand.
This method updates an account brand. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be 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.update_brand_with_http_info(account_id, brand_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str brand_id: The unique identifier of a brand. (required)
- str replace_brand:
- Brand brand:
Returns
Brand If the method is called asynchronously, returns the request thread.
def
update_brand_logo_by_type(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs)
6895 def update_brand_logo_by_type(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs): 6896 """ 6897 Put one branding logo. 6898 This method updates a single brand logo. You pass in the new version of the resource in the `Content-Disposition` header. Example: `Content-Disposition: form-data; name=\"file\"; filename=\"logo.jpg\"` **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 6899 This method makes a synchronous HTTP request by default. To make an 6900 asynchronous HTTP request, please define a `callback` function 6901 to be invoked when receiving the response. 6902 >>> def callback_function(response): 6903 >>> pprint(response) 6904 >>> 6905 >>> thread = api.update_brand_logo_by_type(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function) 6906 6907 :param callback function: The callback function 6908 for asynchronous request. (optional) 6909 :param str account_id: The external account number (int) or account ID GUID. (required) 6910 :param str brand_id: The ID of the brand. (required) 6911 :param str logo_type: The type of logo. Valid values are: - `primary` - `secondary` - `email` (required) 6912 :param str logo_file_bytes: Brand logo binary Stream. Supported formats: JPG, GIF, PNG. Maximum file size: 300 KB. Recommended dimensions: 296 x 76 pixels (larger images will be resized). Changes may take up to one hour to display in all places (required) 6913 :return: None 6914 If the method is called asynchronously, 6915 returns the request thread. 6916 """ 6917 kwargs['_return_http_data_only'] = True 6918 if kwargs.get('callback'): 6919 return self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs) 6920 else: 6921 (data) = self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs) 6922 return data
Put one branding logo.
This method updates a single brand logo. You pass in the new version of the resource in the Content-Disposition header. Example: Content-Disposition: form-data; name="file"; filename="logo.jpg" Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be 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.update_brand_logo_by_type(account_id, brand_id, logo_type, logo_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 brand_id: The ID of the brand. (required)
- str logo_type: The type of logo. Valid values are: -
primary-secondary-email(required) - str logo_file_bytes: Brand logo binary Stream. Supported formats: JPG, GIF, PNG. Maximum file size: 300 KB. Recommended dimensions: 296 x 76 pixels (larger images will be resized). Changes may take up to one hour to display in all places (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
update_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs)
6924 def update_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs): 6925 """ 6926 Put one branding logo. 6927 This method updates a single brand logo. You pass in the new version of the resource in the `Content-Disposition` header. Example: `Content-Disposition: form-data; name=\"file\"; filename=\"logo.jpg\"` **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 6928 This method makes a synchronous HTTP request by default. To make an 6929 asynchronous HTTP request, please define a `callback` function 6930 to be invoked when receiving the response. 6931 >>> def callback_function(response): 6932 >>> pprint(response) 6933 >>> 6934 >>> thread = api.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function) 6935 6936 :param callback function: The callback function 6937 for asynchronous request. (optional) 6938 :param str account_id: The external account number (int) or account ID GUID. (required) 6939 :param str brand_id: The ID of the brand. (required) 6940 :param str logo_type: The type of logo. Valid values are: - `primary` - `secondary` - `email` (required) 6941 :param str logo_file_bytes: Brand logo binary Stream. Supported formats: JPG, GIF, PNG. Maximum file size: 300 KB. Recommended dimensions: 296 x 76 pixels (larger images will be resized). Changes may take up to one hour to display in all places (required) 6942 :return: None 6943 If the method is called asynchronously, 6944 returns the request thread. 6945 """ 6946 6947 all_params = ['account_id', 'brand_id', 'logo_type', 'logo_file_bytes'] 6948 all_params.append('callback') 6949 all_params.append('_return_http_data_only') 6950 all_params.append('_preload_content') 6951 all_params.append('_request_timeout') 6952 6953 params = locals() 6954 for key, val in iteritems(params['kwargs']): 6955 if key not in all_params: 6956 raise TypeError( 6957 "Got an unexpected keyword argument '%s'" 6958 " to method update_brand_logo_by_type" % key 6959 ) 6960 params[key] = val 6961 del params['kwargs'] 6962 # verify the required parameter 'account_id' is set 6963 if ('account_id' not in params) or (params['account_id'] is None): 6964 raise ValueError("Missing the required parameter `account_id` when calling `update_brand_logo_by_type`") 6965 # verify the required parameter 'brand_id' is set 6966 if ('brand_id' not in params) or (params['brand_id'] is None): 6967 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_logo_by_type`") 6968 # verify the required parameter 'logo_type' is set 6969 if ('logo_type' not in params) or (params['logo_type'] is None): 6970 raise ValueError("Missing the required parameter `logo_type` when calling `update_brand_logo_by_type`") 6971 # verify the required parameter 'logo_file_bytes' is set 6972 if ('logo_file_bytes' not in params) or (params['logo_file_bytes'] is None): 6973 raise ValueError("Missing the required parameter `logo_file_bytes` when calling `update_brand_logo_by_type`") 6974 6975 6976 collection_formats = {} 6977 6978 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 6979 path_params = {} 6980 if 'account_id' in params: 6981 path_params['accountId'] = params['account_id'] 6982 if 'brand_id' in params: 6983 path_params['brandId'] = params['brand_id'] 6984 if 'logo_type' in params: 6985 path_params['logoType'] = params['logo_type'] 6986 6987 query_params = {} 6988 6989 header_params = {} 6990 6991 form_params = [] 6992 local_var_files = {} 6993 6994 body_params = None 6995 if 'logo_file_bytes' in params: 6996 body_params = params['logo_file_bytes'] 6997 # HTTP header `Accept` 6998 header_params['Accept'] = self.api_client.\ 6999 select_header_accept(['application/json']) 7000 7001 # HTTP header `Content-Type` 7002 header_params['Content-Type'] = self.api_client.\ 7003 select_header_content_type(['image/png']) 7004 7005 # Authentication setting 7006 auth_settings = [] 7007 7008 return self.api_client.call_api(resource_path, 'PUT', 7009 path_params, 7010 query_params, 7011 header_params, 7012 body=body_params, 7013 post_params=form_params, 7014 files=local_var_files, 7015 response_type=None, 7016 auth_settings=auth_settings, 7017 callback=params.get('callback'), 7018 _return_http_data_only=params.get('_return_http_data_only'), 7019 _preload_content=params.get('_preload_content', True), 7020 _request_timeout=params.get('_request_timeout'), 7021 collection_formats=collection_formats)
Put one branding logo.
This method updates a single brand logo. You pass in the new version of the resource in the Content-Disposition header. Example: Content-Disposition: form-data; name="file"; filename="logo.jpg" Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be 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.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_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 brand_id: The ID of the brand. (required)
- str logo_type: The type of logo. Valid values are: -
primary-secondary-email(required) - str logo_file_bytes: Brand logo binary Stream. Supported formats: JPG, GIF, PNG. Maximum file size: 300 KB. Recommended dimensions: 296 x 76 pixels (larger images will be resized). Changes may take up to one hour to display in all places (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
update_brand_resources_by_content_type( self, account_id, brand_id, resource_content_type, file_xml, **kwargs)
7023 def update_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, file_xml, **kwargs): 7024 """ 7025 Uploads a branding resource file. 7026 This method updates a branding resource file. You pass in the new version of the resource file in the `Content-Disposition` header. Example: `Content-Disposition: form-data; name=\"file\"; filename=\"DocuSign_SigningResource_4328673.xml\"` **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). **Important:** Customizing resource files is an advanced branding configuration option which can significantly impact your account, and should be done only by someone with expertise in XML and HTML. The master resource files are subject to change without notice. If you customize your resource files, after each release, DocuSign recommends you review any changes and update your custom files as needed. When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file. 7027 This method makes a synchronous HTTP request by default. To make an 7028 asynchronous HTTP request, please define a `callback` function 7029 to be invoked when receiving the response. 7030 >>> def callback_function(response): 7031 >>> pprint(response) 7032 >>> 7033 >>> thread = api.update_brand_resources_by_content_type(account_id, brand_id, resource_content_type, file_xml, callback=callback_function) 7034 7035 :param callback function: The callback function 7036 for asynchronous request. (optional) 7037 :param str account_id: The external account number (int) or account ID GUID. (required) 7038 :param str brand_id: The ID of the brand. (required) 7039 :param str resource_content_type: The type of brand resource file that you are updating. Valid values are: - `sending` - `signing` - `email` - `signing_captive` (required) 7040 :param file file_xml: Brand resource XML file. (required) 7041 :return: BrandResources 7042 If the method is called asynchronously, 7043 returns the request thread. 7044 """ 7045 kwargs['_return_http_data_only'] = True 7046 if kwargs.get('callback'): 7047 return self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs) 7048 else: 7049 (data) = self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs) 7050 return data
Uploads a branding resource file.
This method updates a branding resource file. You pass in the new version of the resource file in the Content-Disposition header. Example: Content-Disposition: form-data; name="file"; filename="DocuSign_SigningResource_4328673.xml" Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true). Important: Customizing resource files is an advanced branding configuration option which can significantly impact your account, and should be done only by someone with expertise in XML and HTML. The master resource files are subject to change without notice. If you customize your resource files, after each release, DocuSign recommends you review any changes and update your custom files as needed. When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file.
This method makes a synchronous HTTP request by default. To make 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_brand_resources_by_content_type(account_id, brand_id, resource_content_type, file_xml, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID GUID. (required)
- str brand_id: The ID of the brand. (required)
- str resource_content_type: The type of brand resource file that you are updating. Valid values are: -
sending-signing-email-signing_captive(required) - file file_xml: Brand resource XML file. (required)
Returns
BrandResources If the method is called asynchronously, returns the request thread.
def
update_brand_resources_by_content_type_with_http_info( self, account_id, brand_id, resource_content_type, file_xml, **kwargs)
7052 def update_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, file_xml, **kwargs): 7053 """ 7054 Uploads a branding resource file. 7055 This method updates a branding resource file. You pass in the new version of the resource file in the `Content-Disposition` header. Example: `Content-Disposition: form-data; name=\"file\"; filename=\"DocuSign_SigningResource_4328673.xml\"` **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). **Important:** Customizing resource files is an advanced branding configuration option which can significantly impact your account, and should be done only by someone with expertise in XML and HTML. The master resource files are subject to change without notice. If you customize your resource files, after each release, DocuSign recommends you review any changes and update your custom files as needed. When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file. 7056 This method makes a synchronous HTTP request by default. To make an 7057 asynchronous HTTP request, please define a `callback` function 7058 to be invoked when receiving the response. 7059 >>> def callback_function(response): 7060 >>> pprint(response) 7061 >>> 7062 >>> thread = api.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, callback=callback_function) 7063 7064 :param callback function: The callback function 7065 for asynchronous request. (optional) 7066 :param str account_id: The external account number (int) or account ID GUID. (required) 7067 :param str brand_id: The ID of the brand. (required) 7068 :param str resource_content_type: The type of brand resource file that you are updating. Valid values are: - `sending` - `signing` - `email` - `signing_captive` (required) 7069 :param file file_xml: Brand resource XML file. (required) 7070 :return: BrandResources 7071 If the method is called asynchronously, 7072 returns the request thread. 7073 """ 7074 7075 all_params = ['account_id', 'brand_id', 'resource_content_type', 'file_xml'] 7076 all_params.append('callback') 7077 all_params.append('_return_http_data_only') 7078 all_params.append('_preload_content') 7079 all_params.append('_request_timeout') 7080 7081 params = locals() 7082 for key, val in iteritems(params['kwargs']): 7083 if key not in all_params: 7084 raise TypeError( 7085 "Got an unexpected keyword argument '%s'" 7086 " to method update_brand_resources_by_content_type" % key 7087 ) 7088 params[key] = val 7089 del params['kwargs'] 7090 # verify the required parameter 'account_id' is set 7091 if ('account_id' not in params) or (params['account_id'] is None): 7092 raise ValueError("Missing the required parameter `account_id` when calling `update_brand_resources_by_content_type`") 7093 # verify the required parameter 'brand_id' is set 7094 if ('brand_id' not in params) or (params['brand_id'] is None): 7095 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_resources_by_content_type`") 7096 # verify the required parameter 'resource_content_type' is set 7097 if ('resource_content_type' not in params) or (params['resource_content_type'] is None): 7098 raise ValueError("Missing the required parameter `resource_content_type` when calling `update_brand_resources_by_content_type`") 7099 # verify the required parameter 'file_xml' is set 7100 if ('file_xml' not in params) or (params['file_xml'] is None): 7101 raise ValueError("Missing the required parameter `file_xml` when calling `update_brand_resources_by_content_type`") 7102 7103 7104 collection_formats = {} 7105 7106 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources/{resourceContentType}'.replace('{format}', 'json') 7107 path_params = {} 7108 if 'account_id' in params: 7109 path_params['accountId'] = params['account_id'] 7110 if 'brand_id' in params: 7111 path_params['brandId'] = params['brand_id'] 7112 if 'resource_content_type' in params: 7113 path_params['resourceContentType'] = params['resource_content_type'] 7114 7115 query_params = {} 7116 7117 header_params = {} 7118 7119 form_params = [] 7120 local_var_files = {} 7121 if 'file_xml' in params: 7122 local_var_files['file.xml'] = params['file_xml'] 7123 7124 body_params = None 7125 # HTTP header `Accept` 7126 header_params['Accept'] = self.api_client.\ 7127 select_header_accept(['application/json']) 7128 7129 # HTTP header `Content-Type` 7130 header_params['Content-Type'] = self.api_client.\ 7131 select_header_content_type(['multipart/form-data']) 7132 7133 # Authentication setting 7134 auth_settings = [] 7135 7136 return self.api_client.call_api(resource_path, 'PUT', 7137 path_params, 7138 query_params, 7139 header_params, 7140 body=body_params, 7141 post_params=form_params, 7142 files=local_var_files, 7143 response_type='BrandResources', 7144 auth_settings=auth_settings, 7145 callback=params.get('callback'), 7146 _return_http_data_only=params.get('_return_http_data_only'), 7147 _preload_content=params.get('_preload_content', True), 7148 _request_timeout=params.get('_request_timeout'), 7149 collection_formats=collection_formats)
Uploads a branding resource file.
This method updates a branding resource file. You pass in the new version of the resource file in the Content-Disposition header. Example: Content-Disposition: form-data; name="file"; filename="DocuSign_SigningResource_4328673.xml" Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true). Important: Customizing resource files is an advanced branding configuration option which can significantly impact your account, and should be done only by someone with expertise in XML and HTML. The master resource files are subject to change without notice. If you customize your resource files, after each release, DocuSign recommends you review any changes and update your custom files as needed. When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file.
This method makes a synchronous HTTP request by default. To make 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_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID GUID. (required)
- str brand_id: The ID of the brand. (required)
- str resource_content_type: The type of brand resource file that you are updating. Valid values are: -
sending-signing-email-signing_captive(required) - file file_xml: Brand resource XML file. (required)
Returns
BrandResources If the method is called asynchronously, returns the request thread.
def
update_consumer_disclosure(self, account_id, lang_code, **kwargs)
7151 def update_consumer_disclosure(self, account_id, lang_code, **kwargs): 7152 """ 7153 Update Consumer Disclosure. 7154 Account administrators can use this method to perform the following tasks: - Customize values in the default disclosure. - Switch to a custom disclosure that uses your own text and HTML formatting. - Change values in your existing consumer disclosure. To specify the signer language version of the disclosure that you are updating, use the optional `langCode` query parameter. **Note:** Only account administrators can use this method. Each time you change the disclosure content, all unsigned recipients of outstanding documents will be required to accept a new version. ## Updating the default disclosure When you update the default disclosure, you can edit all properties except for the following ones: - `accountEsignId`: This property is read-only. - `custom`: The default value is **false.** Editing this property causes the default disclosure to switch to a custom disclosure. - `esignAgreement`: This property is read-only. - `esignText`: You cannot edit this property when `custom` is set to **false.** The API returns a 200 OK HTTP response, but does not update the `esignText`. - Metadata properties: These properties are read-only. **Note:** The text of the default disclosure is always in English. ## Switching to a custom disclosure To switch to a custom disclosure, set the `custom` property to **true** and customize the value for the `eSignText` property. You can also edit all of the other properties except for the following ones: - `accountEsignId`: This property is read-only. - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only. **Note:** When you use a custom disclosure, you can create versions of it in different signer languages and se the `langCode` parameter to specify the signer language version that you are updating. **Important:** When you switch from a default to a custom disclosure, note the following information: - You will not be able to return to using the default disclosure. - Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use. ## Updating a custom disclosure When you update a custom disclosure, you can update all of the properties except for the following ones: - `accountEsignId`: This property is read-only. - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only. **Important:** Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use. 7155 This method makes a synchronous HTTP request by default. To make an 7156 asynchronous HTTP request, please define a `callback` function 7157 to be invoked when receiving the response. 7158 >>> def callback_function(response): 7159 >>> pprint(response) 7160 >>> 7161 >>> thread = api.update_consumer_disclosure(account_id, lang_code, callback=callback_function) 7162 7163 :param callback function: The callback function 7164 for asynchronous request. (optional) 7165 :param str account_id: The external account number (int) or account ID Guid. (required) 7166 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 7167 :param str include_metadata: 7168 :param ConsumerDisclosure consumer_disclosure: 7169 :return: ConsumerDisclosure 7170 If the method is called asynchronously, 7171 returns the request thread. 7172 """ 7173 kwargs['_return_http_data_only'] = True 7174 if kwargs.get('callback'): 7175 return self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 7176 else: 7177 (data) = self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 7178 return data
Update Consumer Disclosure.
Account administrators can use this method to perform the following tasks: - Customize values in the default disclosure. - Switch to a custom disclosure that uses your own text and HTML formatting. - Change values in your existing consumer disclosure. To specify the signer language version of the disclosure that you are updating, use the optional langCode query parameter. Note: Only account administrators can use this method. Each time you change the disclosure content, all unsigned recipients of outstanding documents will be required to accept a new version. ## Updating the default disclosure When you update the default disclosure, you can edit all properties except for the following ones: - accountEsignId: This property is read-only. - custom: The default value is false. Editing this property causes the default disclosure to switch to a custom disclosure. - esignAgreement: This property is read-only. - esignText: You cannot edit this property when custom is set to false. The API returns a 200 OK HTTP response, but does not update the esignText. - Metadata properties: These properties are read-only. Note: The text of the default disclosure is always in English. ## Switching to a custom disclosure To switch to a custom disclosure, set the custom property to true and customize the value for the eSignText property. You can also edit all of the other properties except for the following ones: - accountEsignId: This property is read-only. - esignAgreement: This property is read-only. - Metadata properties: These properties are read-only. Note: When you use a custom disclosure, you can create versions of it in different signer languages and se the langCode parameter to specify the signer language version that you are updating. Important: When you switch from a default to a custom disclosure, note the following information: - You will not be able to return to using the default disclosure. - Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use. ## Updating a custom disclosure When you update a custom disclosure, you can update all of the properties except for the following ones: - accountEsignId: This property is read-only. - esignAgreement: This property is read-only. - Metadata properties: These properties are read-only. Important: Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use.
This method makes a synchronous HTTP request by default. To make 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_consumer_disclosure(account_id, lang_code, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are: Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required)
- str include_metadata:
- ConsumerDisclosure consumer_disclosure:
Returns
ConsumerDisclosure If the method is called asynchronously, returns the request thread.
def
update_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs)
7180 def update_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs): 7181 """ 7182 Update Consumer Disclosure. 7183 Account administrators can use this method to perform the following tasks: - Customize values in the default disclosure. - Switch to a custom disclosure that uses your own text and HTML formatting. - Change values in your existing consumer disclosure. To specify the signer language version of the disclosure that you are updating, use the optional `langCode` query parameter. **Note:** Only account administrators can use this method. Each time you change the disclosure content, all unsigned recipients of outstanding documents will be required to accept a new version. ## Updating the default disclosure When you update the default disclosure, you can edit all properties except for the following ones: - `accountEsignId`: This property is read-only. - `custom`: The default value is **false.** Editing this property causes the default disclosure to switch to a custom disclosure. - `esignAgreement`: This property is read-only. - `esignText`: You cannot edit this property when `custom` is set to **false.** The API returns a 200 OK HTTP response, but does not update the `esignText`. - Metadata properties: These properties are read-only. **Note:** The text of the default disclosure is always in English. ## Switching to a custom disclosure To switch to a custom disclosure, set the `custom` property to **true** and customize the value for the `eSignText` property. You can also edit all of the other properties except for the following ones: - `accountEsignId`: This property is read-only. - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only. **Note:** When you use a custom disclosure, you can create versions of it in different signer languages and se the `langCode` parameter to specify the signer language version that you are updating. **Important:** When you switch from a default to a custom disclosure, note the following information: - You will not be able to return to using the default disclosure. - Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use. ## Updating a custom disclosure When you update a custom disclosure, you can update all of the properties except for the following ones: - `accountEsignId`: This property is read-only. - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only. **Important:** Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use. 7184 This method makes a synchronous HTTP request by default. To make an 7185 asynchronous HTTP request, please define a `callback` function 7186 to be invoked when receiving the response. 7187 >>> def callback_function(response): 7188 >>> pprint(response) 7189 >>> 7190 >>> thread = api.update_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function) 7191 7192 :param callback function: The callback function 7193 for asynchronous request. (optional) 7194 :param str account_id: The external account number (int) or account ID Guid. (required) 7195 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 7196 :param str include_metadata: 7197 :param ConsumerDisclosure consumer_disclosure: 7198 :return: ConsumerDisclosure 7199 If the method is called asynchronously, 7200 returns the request thread. 7201 """ 7202 7203 all_params = ['account_id', 'lang_code', 'include_metadata', 'consumer_disclosure'] 7204 all_params.append('callback') 7205 all_params.append('_return_http_data_only') 7206 all_params.append('_preload_content') 7207 all_params.append('_request_timeout') 7208 7209 params = locals() 7210 for key, val in iteritems(params['kwargs']): 7211 if key not in all_params: 7212 raise TypeError( 7213 "Got an unexpected keyword argument '%s'" 7214 " to method update_consumer_disclosure" % key 7215 ) 7216 params[key] = val 7217 del params['kwargs'] 7218 # verify the required parameter 'account_id' is set 7219 if ('account_id' not in params) or (params['account_id'] is None): 7220 raise ValueError("Missing the required parameter `account_id` when calling `update_consumer_disclosure`") 7221 # verify the required parameter 'lang_code' is set 7222 if ('lang_code' not in params) or (params['lang_code'] is None): 7223 raise ValueError("Missing the required parameter `lang_code` when calling `update_consumer_disclosure`") 7224 7225 7226 collection_formats = {} 7227 7228 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 7229 path_params = {} 7230 if 'account_id' in params: 7231 path_params['accountId'] = params['account_id'] 7232 if 'lang_code' in params: 7233 path_params['langCode'] = params['lang_code'] 7234 7235 query_params = {} 7236 if 'include_metadata' in params: 7237 query_params['include_metadata'] = params['include_metadata'] 7238 7239 header_params = {} 7240 7241 form_params = [] 7242 local_var_files = {} 7243 7244 body_params = None 7245 if 'consumer_disclosure' in params: 7246 body_params = params['consumer_disclosure'] 7247 # HTTP header `Accept` 7248 header_params['Accept'] = self.api_client.\ 7249 select_header_accept(['application/json']) 7250 7251 # Authentication setting 7252 auth_settings = [] 7253 7254 return self.api_client.call_api(resource_path, 'PUT', 7255 path_params, 7256 query_params, 7257 header_params, 7258 body=body_params, 7259 post_params=form_params, 7260 files=local_var_files, 7261 response_type='ConsumerDisclosure', 7262 auth_settings=auth_settings, 7263 callback=params.get('callback'), 7264 _return_http_data_only=params.get('_return_http_data_only'), 7265 _preload_content=params.get('_preload_content', True), 7266 _request_timeout=params.get('_request_timeout'), 7267 collection_formats=collection_formats)
Update Consumer Disclosure.
Account administrators can use this method to perform the following tasks: - Customize values in the default disclosure. - Switch to a custom disclosure that uses your own text and HTML formatting. - Change values in your existing consumer disclosure. To specify the signer language version of the disclosure that you are updating, use the optional langCode query parameter. Note: Only account administrators can use this method. Each time you change the disclosure content, all unsigned recipients of outstanding documents will be required to accept a new version. ## Updating the default disclosure When you update the default disclosure, you can edit all properties except for the following ones: - accountEsignId: This property is read-only. - custom: The default value is false. Editing this property causes the default disclosure to switch to a custom disclosure. - esignAgreement: This property is read-only. - esignText: You cannot edit this property when custom is set to false. The API returns a 200 OK HTTP response, but does not update the esignText. - Metadata properties: These properties are read-only. Note: The text of the default disclosure is always in English. ## Switching to a custom disclosure To switch to a custom disclosure, set the custom property to true and customize the value for the eSignText property. You can also edit all of the other properties except for the following ones: - accountEsignId: This property is read-only. - esignAgreement: This property is read-only. - Metadata properties: These properties are read-only. Note: When you use a custom disclosure, you can create versions of it in different signer languages and se the langCode parameter to specify the signer language version that you are updating. Important: When you switch from a default to a custom disclosure, note the following information: - You will not be able to return to using the default disclosure. - Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use. ## Updating a custom disclosure When you update a custom disclosure, you can update all of the properties except for the following ones: - accountEsignId: This property is read-only. - esignAgreement: This property is read-only. - Metadata properties: These properties are read-only. Important: Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use.
This method makes a synchronous HTTP request by default. To make 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_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are: Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required)
- str include_metadata:
- ConsumerDisclosure consumer_disclosure:
Returns
ConsumerDisclosure If the method is called asynchronously, returns the request thread.
def
update_custom_field(self, account_id, custom_field_id, **kwargs)
7269 def update_custom_field(self, account_id, custom_field_id, **kwargs): 7270 """ 7271 Updates an existing account custom field. 7272 This method updates an existing account custom field. 7273 This method makes a synchronous HTTP request by default. To make an 7274 asynchronous HTTP request, please define a `callback` function 7275 to be invoked when receiving the response. 7276 >>> def callback_function(response): 7277 >>> pprint(response) 7278 >>> 7279 >>> thread = api.update_custom_field(account_id, custom_field_id, callback=callback_function) 7280 7281 :param callback function: The callback function 7282 for asynchronous request. (optional) 7283 :param str account_id: The external account number (int) or account ID Guid. (required) 7284 :param str custom_field_id: (required) 7285 :param str apply_to_templates: 7286 :param CustomField custom_field: 7287 :return: CustomFields 7288 If the method is called asynchronously, 7289 returns the request thread. 7290 """ 7291 kwargs['_return_http_data_only'] = True 7292 if kwargs.get('callback'): 7293 return self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 7294 else: 7295 (data) = self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 7296 return data
Updates an existing account custom field.
This method updates an existing account custom field.
This method makes a synchronous HTTP request by default. To make 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_field(account_id, custom_field_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str custom_field_id: (required)
- str apply_to_templates:
- CustomField custom_field:
Returns
CustomFields If the method is called asynchronously, returns the request thread.
def
update_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs)
7298 def update_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs): 7299 """ 7300 Updates an existing account custom field. 7301 This method updates an existing account custom field. 7302 This method makes a synchronous HTTP request by default. To make an 7303 asynchronous HTTP request, please define a `callback` function 7304 to be invoked when receiving the response. 7305 >>> def callback_function(response): 7306 >>> pprint(response) 7307 >>> 7308 >>> thread = api.update_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function) 7309 7310 :param callback function: The callback function 7311 for asynchronous request. (optional) 7312 :param str account_id: The external account number (int) or account ID Guid. (required) 7313 :param str custom_field_id: (required) 7314 :param str apply_to_templates: 7315 :param CustomField custom_field: 7316 :return: CustomFields 7317 If the method is called asynchronously, 7318 returns the request thread. 7319 """ 7320 7321 all_params = ['account_id', 'custom_field_id', 'apply_to_templates', 'custom_field'] 7322 all_params.append('callback') 7323 all_params.append('_return_http_data_only') 7324 all_params.append('_preload_content') 7325 all_params.append('_request_timeout') 7326 7327 params = locals() 7328 for key, val in iteritems(params['kwargs']): 7329 if key not in all_params: 7330 raise TypeError( 7331 "Got an unexpected keyword argument '%s'" 7332 " to method update_custom_field" % key 7333 ) 7334 params[key] = val 7335 del params['kwargs'] 7336 # verify the required parameter 'account_id' is set 7337 if ('account_id' not in params) or (params['account_id'] is None): 7338 raise ValueError("Missing the required parameter `account_id` when calling `update_custom_field`") 7339 # verify the required parameter 'custom_field_id' is set 7340 if ('custom_field_id' not in params) or (params['custom_field_id'] is None): 7341 raise ValueError("Missing the required parameter `custom_field_id` when calling `update_custom_field`") 7342 7343 7344 collection_formats = {} 7345 7346 resource_path = '/v2.1/accounts/{accountId}/custom_fields/{customFieldId}'.replace('{format}', 'json') 7347 path_params = {} 7348 if 'account_id' in params: 7349 path_params['accountId'] = params['account_id'] 7350 if 'custom_field_id' in params: 7351 path_params['customFieldId'] = params['custom_field_id'] 7352 7353 query_params = {} 7354 if 'apply_to_templates' in params: 7355 query_params['apply_to_templates'] = params['apply_to_templates'] 7356 7357 header_params = {} 7358 7359 form_params = [] 7360 local_var_files = {} 7361 7362 body_params = None 7363 if 'custom_field' in params: 7364 body_params = params['custom_field'] 7365 # HTTP header `Accept` 7366 header_params['Accept'] = self.api_client.\ 7367 select_header_accept(['application/json']) 7368 7369 # Authentication setting 7370 auth_settings = [] 7371 7372 return self.api_client.call_api(resource_path, 'PUT', 7373 path_params, 7374 query_params, 7375 header_params, 7376 body=body_params, 7377 post_params=form_params, 7378 files=local_var_files, 7379 response_type='CustomFields', 7380 auth_settings=auth_settings, 7381 callback=params.get('callback'), 7382 _return_http_data_only=params.get('_return_http_data_only'), 7383 _preload_content=params.get('_preload_content', True), 7384 _request_timeout=params.get('_request_timeout'), 7385 collection_formats=collection_formats)
Updates an existing account custom field.
This method updates an existing account custom field.
This method makes a synchronous HTTP request by default. To make 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_field_with_http_info(account_id, custom_field_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str custom_field_id: (required)
- str apply_to_templates:
- CustomField custom_field:
Returns
CustomFields If the method is called asynchronously, returns the request thread.
def
update_e_note_configuration(self, account_id, **kwargs)
7387 def update_e_note_configuration(self, account_id, **kwargs): 7388 """ 7389 Updates configuration information for the eNote eOriginal integration. 7390 7391 This method makes a synchronous HTTP request by default. To make an 7392 asynchronous HTTP request, please define a `callback` function 7393 to be invoked when receiving the response. 7394 >>> def callback_function(response): 7395 >>> pprint(response) 7396 >>> 7397 >>> thread = api.update_e_note_configuration(account_id, callback=callback_function) 7398 7399 :param callback function: The callback function 7400 for asynchronous request. (optional) 7401 :param str account_id: The external account number (int) or account ID Guid. (required) 7402 :param ENoteConfiguration e_note_configuration: 7403 :return: ENoteConfiguration 7404 If the method is called asynchronously, 7405 returns the request thread. 7406 """ 7407 kwargs['_return_http_data_only'] = True 7408 if kwargs.get('callback'): 7409 return self.update_e_note_configuration_with_http_info(account_id, **kwargs) 7410 else: 7411 (data) = self.update_e_note_configuration_with_http_info(account_id, **kwargs) 7412 return data
Updates configuration information for the eNote eOriginal integration.
This method makes a synchronous HTTP request by default. To make 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_e_note_configuration(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)
- ENoteConfiguration e_note_configuration:
Returns
ENoteConfiguration If the method is called asynchronously, returns the request thread.
def
update_e_note_configuration_with_http_info(self, account_id, **kwargs)
7414 def update_e_note_configuration_with_http_info(self, account_id, **kwargs): 7415 """ 7416 Updates configuration information for the eNote eOriginal integration. 7417 7418 This method makes a synchronous HTTP request by default. To make an 7419 asynchronous HTTP request, please define a `callback` function 7420 to be invoked when receiving the response. 7421 >>> def callback_function(response): 7422 >>> pprint(response) 7423 >>> 7424 >>> thread = api.update_e_note_configuration_with_http_info(account_id, callback=callback_function) 7425 7426 :param callback function: The callback function 7427 for asynchronous request. (optional) 7428 :param str account_id: The external account number (int) or account ID Guid. (required) 7429 :param ENoteConfiguration e_note_configuration: 7430 :return: ENoteConfiguration 7431 If the method is called asynchronously, 7432 returns the request thread. 7433 """ 7434 7435 all_params = ['account_id', 'e_note_configuration'] 7436 all_params.append('callback') 7437 all_params.append('_return_http_data_only') 7438 all_params.append('_preload_content') 7439 all_params.append('_request_timeout') 7440 7441 params = locals() 7442 for key, val in iteritems(params['kwargs']): 7443 if key not in all_params: 7444 raise TypeError( 7445 "Got an unexpected keyword argument '%s'" 7446 " to method update_e_note_configuration" % key 7447 ) 7448 params[key] = val 7449 del params['kwargs'] 7450 # verify the required parameter 'account_id' is set 7451 if ('account_id' not in params) or (params['account_id'] is None): 7452 raise ValueError("Missing the required parameter `account_id` when calling `update_e_note_configuration`") 7453 7454 7455 collection_formats = {} 7456 7457 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 7458 path_params = {} 7459 if 'account_id' in params: 7460 path_params['accountId'] = params['account_id'] 7461 7462 query_params = {} 7463 7464 header_params = {} 7465 7466 form_params = [] 7467 local_var_files = {} 7468 7469 body_params = None 7470 if 'e_note_configuration' in params: 7471 body_params = params['e_note_configuration'] 7472 # HTTP header `Accept` 7473 header_params['Accept'] = self.api_client.\ 7474 select_header_accept(['application/json']) 7475 7476 # Authentication setting 7477 auth_settings = [] 7478 7479 return self.api_client.call_api(resource_path, 'PUT', 7480 path_params, 7481 query_params, 7482 header_params, 7483 body=body_params, 7484 post_params=form_params, 7485 files=local_var_files, 7486 response_type='ENoteConfiguration', 7487 auth_settings=auth_settings, 7488 callback=params.get('callback'), 7489 _return_http_data_only=params.get('_return_http_data_only'), 7490 _preload_content=params.get('_preload_content', True), 7491 _request_timeout=params.get('_request_timeout'), 7492 collection_formats=collection_formats)
Updates configuration information for the eNote eOriginal integration.
This method makes a synchronous HTTP request by default. To make 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_e_note_configuration_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)
- ENoteConfiguration e_note_configuration:
Returns
ENoteConfiguration If the method is called asynchronously, returns the request thread.
def
update_envelope_purge_configuration(self, account_id, **kwargs)
7494 def update_envelope_purge_configuration(self, account_id, **kwargs): 7495 """ 7496 Updates envelope purge configuration. 7497 An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method sets the envelope purge configuration for your account. **Note:** To use this method, you must be an account administrator. For more information, see [Purge Envelopes](https://support.docusign.com/en/guides/ndse-user-guide-purge-envelopes). 7498 This method makes a synchronous HTTP request by default. To make an 7499 asynchronous HTTP request, please define a `callback` function 7500 to be invoked when receiving the response. 7501 >>> def callback_function(response): 7502 >>> pprint(response) 7503 >>> 7504 >>> thread = api.update_envelope_purge_configuration(account_id, callback=callback_function) 7505 7506 :param callback function: The callback function 7507 for asynchronous request. (optional) 7508 :param str account_id: The external account number (int) or account ID Guid. (required) 7509 :param EnvelopePurgeConfiguration envelope_purge_configuration: 7510 :return: EnvelopePurgeConfiguration 7511 If the method is called asynchronously, 7512 returns the request thread. 7513 """ 7514 kwargs['_return_http_data_only'] = True 7515 if kwargs.get('callback'): 7516 return self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs) 7517 else: 7518 (data) = self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs) 7519 return data
Updates envelope purge configuration.
An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (retentionDays). This method sets the envelope purge configuration for your account. Note: To use this method, you must be an account administrator. For more information, see Purge 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.update_envelope_purge_configuration(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)
- EnvelopePurgeConfiguration envelope_purge_configuration:
Returns
EnvelopePurgeConfiguration If the method is called asynchronously, returns the request thread.
def
update_envelope_purge_configuration_with_http_info(self, account_id, **kwargs)
7521 def update_envelope_purge_configuration_with_http_info(self, account_id, **kwargs): 7522 """ 7523 Updates envelope purge configuration. 7524 An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method sets the envelope purge configuration for your account. **Note:** To use this method, you must be an account administrator. For more information, see [Purge Envelopes](https://support.docusign.com/en/guides/ndse-user-guide-purge-envelopes). 7525 This method makes a synchronous HTTP request by default. To make an 7526 asynchronous HTTP request, please define a `callback` function 7527 to be invoked when receiving the response. 7528 >>> def callback_function(response): 7529 >>> pprint(response) 7530 >>> 7531 >>> thread = api.update_envelope_purge_configuration_with_http_info(account_id, callback=callback_function) 7532 7533 :param callback function: The callback function 7534 for asynchronous request. (optional) 7535 :param str account_id: The external account number (int) or account ID Guid. (required) 7536 :param EnvelopePurgeConfiguration envelope_purge_configuration: 7537 :return: EnvelopePurgeConfiguration 7538 If the method is called asynchronously, 7539 returns the request thread. 7540 """ 7541 7542 all_params = ['account_id', 'envelope_purge_configuration'] 7543 all_params.append('callback') 7544 all_params.append('_return_http_data_only') 7545 all_params.append('_preload_content') 7546 all_params.append('_request_timeout') 7547 7548 params = locals() 7549 for key, val in iteritems(params['kwargs']): 7550 if key not in all_params: 7551 raise TypeError( 7552 "Got an unexpected keyword argument '%s'" 7553 " to method update_envelope_purge_configuration" % key 7554 ) 7555 params[key] = val 7556 del params['kwargs'] 7557 # verify the required parameter 'account_id' is set 7558 if ('account_id' not in params) or (params['account_id'] is None): 7559 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_purge_configuration`") 7560 7561 7562 collection_formats = {} 7563 7564 resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json') 7565 path_params = {} 7566 if 'account_id' in params: 7567 path_params['accountId'] = params['account_id'] 7568 7569 query_params = {} 7570 7571 header_params = {} 7572 7573 form_params = [] 7574 local_var_files = {} 7575 7576 body_params = None 7577 if 'envelope_purge_configuration' in params: 7578 body_params = params['envelope_purge_configuration'] 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, 'PUT', 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='EnvelopePurgeConfiguration', 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)
Updates envelope purge configuration.
An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (retentionDays). This method sets the envelope purge configuration for your account. Note: To use this method, you must be an account administrator. For more information, see Purge 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.update_envelope_purge_configuration_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)
- EnvelopePurgeConfiguration envelope_purge_configuration:
Returns
EnvelopePurgeConfiguration If the method is called asynchronously, returns the request thread.
def
update_favorite_template(self, account_id, **kwargs)
7601 def update_favorite_template(self, account_id, **kwargs): 7602 """ 7603 Favorites a template 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.update_favorite_template(account_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 FavoriteTemplatesInfo favorite_templates_info: 7617 :return: FavoriteTemplatesInfo 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.update_favorite_template_with_http_info(account_id, **kwargs) 7624 else: 7625 (data) = self.update_favorite_template_with_http_info(account_id, **kwargs) 7626 return data
Favorites a template
This method makes a synchronous HTTP request by default. To make 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_favorite_template(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)
- FavoriteTemplatesInfo favorite_templates_info:
Returns
FavoriteTemplatesInfo If the method is called asynchronously, returns the request thread.
def
update_favorite_template_with_http_info(self, account_id, **kwargs)
7628 def update_favorite_template_with_http_info(self, account_id, **kwargs): 7629 """ 7630 Favorites a template 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.update_favorite_template_with_http_info(account_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 FavoriteTemplatesInfo favorite_templates_info: 7644 :return: FavoriteTemplatesInfo 7645 If the method is called asynchronously, 7646 returns the request thread. 7647 """ 7648 7649 all_params = ['account_id', 'favorite_templates_info'] 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 update_favorite_template" % 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 `update_favorite_template`") 7667 7668 7669 collection_formats = {} 7670 7671 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 7672 path_params = {} 7673 if 'account_id' in params: 7674 path_params['accountId'] = params['account_id'] 7675 7676 query_params = {} 7677 7678 header_params = {} 7679 7680 form_params = [] 7681 local_var_files = {} 7682 7683 body_params = None 7684 if 'favorite_templates_info' in params: 7685 body_params = params['favorite_templates_info'] 7686 # HTTP header `Accept` 7687 header_params['Accept'] = self.api_client.\ 7688 select_header_accept(['application/json']) 7689 7690 # Authentication setting 7691 auth_settings = [] 7692 7693 return self.api_client.call_api(resource_path, 'PUT', 7694 path_params, 7695 query_params, 7696 header_params, 7697 body=body_params, 7698 post_params=form_params, 7699 files=local_var_files, 7700 response_type='FavoriteTemplatesInfo', 7701 auth_settings=auth_settings, 7702 callback=params.get('callback'), 7703 _return_http_data_only=params.get('_return_http_data_only'), 7704 _preload_content=params.get('_preload_content', True), 7705 _request_timeout=params.get('_request_timeout'), 7706 collection_formats=collection_formats)
Favorites a template
This method makes a synchronous HTTP request by default. To make 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_favorite_template_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)
- FavoriteTemplatesInfo favorite_templates_info:
Returns
FavoriteTemplatesInfo If the method is called asynchronously, returns the request thread.
def
update_notification_defaults(self, account_id, **kwargs)
7708 def update_notification_defaults(self, account_id, **kwargs): 7709 """ 7710 Updates default user level settings for a specified account 7711 This method changes the default settings for the email notifications that signers and senders receive about envelopes. 7712 This method makes a synchronous HTTP request by default. To make an 7713 asynchronous HTTP request, please define a `callback` function 7714 to be invoked when receiving the response. 7715 >>> def callback_function(response): 7716 >>> pprint(response) 7717 >>> 7718 >>> thread = api.update_notification_defaults(account_id, callback=callback_function) 7719 7720 :param callback function: The callback function 7721 for asynchronous request. (optional) 7722 :param str account_id: The external account number (int) or account ID Guid. (required) 7723 :param NotificationDefaults notification_defaults: 7724 :return: NotificationDefaults 7725 If the method is called asynchronously, 7726 returns the request thread. 7727 """ 7728 kwargs['_return_http_data_only'] = True 7729 if kwargs.get('callback'): 7730 return self.update_notification_defaults_with_http_info(account_id, **kwargs) 7731 else: 7732 (data) = self.update_notification_defaults_with_http_info(account_id, **kwargs) 7733 return data
Updates default user level settings for a specified account
This method changes the default settings for the email notifications that signers and senders receive about 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.update_notification_defaults(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)
- NotificationDefaults notification_defaults:
Returns
NotificationDefaults If the method is called asynchronously, returns the request thread.
def
update_notification_defaults_with_http_info(self, account_id, **kwargs)
7735 def update_notification_defaults_with_http_info(self, account_id, **kwargs): 7736 """ 7737 Updates default user level settings for a specified account 7738 This method changes the default settings for the email notifications that signers and senders receive about envelopes. 7739 This method makes a synchronous HTTP request by default. To make an 7740 asynchronous HTTP request, please define a `callback` function 7741 to be invoked when receiving the response. 7742 >>> def callback_function(response): 7743 >>> pprint(response) 7744 >>> 7745 >>> thread = api.update_notification_defaults_with_http_info(account_id, callback=callback_function) 7746 7747 :param callback function: The callback function 7748 for asynchronous request. (optional) 7749 :param str account_id: The external account number (int) or account ID Guid. (required) 7750 :param NotificationDefaults notification_defaults: 7751 :return: NotificationDefaults 7752 If the method is called asynchronously, 7753 returns the request thread. 7754 """ 7755 7756 all_params = ['account_id', 'notification_defaults'] 7757 all_params.append('callback') 7758 all_params.append('_return_http_data_only') 7759 all_params.append('_preload_content') 7760 all_params.append('_request_timeout') 7761 7762 params = locals() 7763 for key, val in iteritems(params['kwargs']): 7764 if key not in all_params: 7765 raise TypeError( 7766 "Got an unexpected keyword argument '%s'" 7767 " to method update_notification_defaults" % key 7768 ) 7769 params[key] = val 7770 del params['kwargs'] 7771 # verify the required parameter 'account_id' is set 7772 if ('account_id' not in params) or (params['account_id'] is None): 7773 raise ValueError("Missing the required parameter `account_id` when calling `update_notification_defaults`") 7774 7775 7776 collection_formats = {} 7777 7778 resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json') 7779 path_params = {} 7780 if 'account_id' in params: 7781 path_params['accountId'] = params['account_id'] 7782 7783 query_params = {} 7784 7785 header_params = {} 7786 7787 form_params = [] 7788 local_var_files = {} 7789 7790 body_params = None 7791 if 'notification_defaults' in params: 7792 body_params = params['notification_defaults'] 7793 # HTTP header `Accept` 7794 header_params['Accept'] = self.api_client.\ 7795 select_header_accept(['application/json']) 7796 7797 # Authentication setting 7798 auth_settings = [] 7799 7800 return self.api_client.call_api(resource_path, 'PUT', 7801 path_params, 7802 query_params, 7803 header_params, 7804 body=body_params, 7805 post_params=form_params, 7806 files=local_var_files, 7807 response_type='NotificationDefaults', 7808 auth_settings=auth_settings, 7809 callback=params.get('callback'), 7810 _return_http_data_only=params.get('_return_http_data_only'), 7811 _preload_content=params.get('_preload_content', True), 7812 _request_timeout=params.get('_request_timeout'), 7813 collection_formats=collection_formats)
Updates default user level settings for a specified account
This method changes the default settings for the email notifications that signers and senders receive about 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.update_notification_defaults_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)
- NotificationDefaults notification_defaults:
Returns
NotificationDefaults If the method is called asynchronously, returns the request thread.
def
update_password_rules(self, account_id, **kwargs)
7815 def update_password_rules(self, account_id, **kwargs): 7816 """ 7817 Update the password rules 7818 This method updates the password rules for an account. **Note:** To update the password rules for an account, you must be an account administrator. 7819 This method makes a synchronous HTTP request by default. To make an 7820 asynchronous HTTP request, please define a `callback` function 7821 to be invoked when receiving the response. 7822 >>> def callback_function(response): 7823 >>> pprint(response) 7824 >>> 7825 >>> thread = api.update_password_rules(account_id, callback=callback_function) 7826 7827 :param callback function: The callback function 7828 for asynchronous request. (optional) 7829 :param str account_id: The external account number (int) or account ID Guid. (required) 7830 :param AccountPasswordRules account_password_rules: 7831 :return: AccountPasswordRules 7832 If the method is called asynchronously, 7833 returns the request thread. 7834 """ 7835 kwargs['_return_http_data_only'] = True 7836 if kwargs.get('callback'): 7837 return self.update_password_rules_with_http_info(account_id, **kwargs) 7838 else: 7839 (data) = self.update_password_rules_with_http_info(account_id, **kwargs) 7840 return data
Update the password rules
This method updates the password rules for an account. Note: To update the password rules for an account, you must be an account administrator.
This method makes a synchronous HTTP request by default. To make 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_password_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)
- AccountPasswordRules account_password_rules:
Returns
AccountPasswordRules If the method is called asynchronously, returns the request thread.
def
update_password_rules_with_http_info(self, account_id, **kwargs)
7842 def update_password_rules_with_http_info(self, account_id, **kwargs): 7843 """ 7844 Update the password rules 7845 This method updates the password rules for an account. **Note:** To update the password rules for an account, you must be an account administrator. 7846 This method makes a synchronous HTTP request by default. To make an 7847 asynchronous HTTP request, please define a `callback` function 7848 to be invoked when receiving the response. 7849 >>> def callback_function(response): 7850 >>> pprint(response) 7851 >>> 7852 >>> thread = api.update_password_rules_with_http_info(account_id, callback=callback_function) 7853 7854 :param callback function: The callback function 7855 for asynchronous request. (optional) 7856 :param str account_id: The external account number (int) or account ID Guid. (required) 7857 :param AccountPasswordRules account_password_rules: 7858 :return: AccountPasswordRules 7859 If the method is called asynchronously, 7860 returns the request thread. 7861 """ 7862 7863 all_params = ['account_id', 'account_password_rules'] 7864 all_params.append('callback') 7865 all_params.append('_return_http_data_only') 7866 all_params.append('_preload_content') 7867 all_params.append('_request_timeout') 7868 7869 params = locals() 7870 for key, val in iteritems(params['kwargs']): 7871 if key not in all_params: 7872 raise TypeError( 7873 "Got an unexpected keyword argument '%s'" 7874 " to method update_password_rules" % key 7875 ) 7876 params[key] = val 7877 del params['kwargs'] 7878 # verify the required parameter 'account_id' is set 7879 if ('account_id' not in params) or (params['account_id'] is None): 7880 raise ValueError("Missing the required parameter `account_id` when calling `update_password_rules`") 7881 7882 7883 collection_formats = {} 7884 7885 resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json') 7886 path_params = {} 7887 if 'account_id' in params: 7888 path_params['accountId'] = params['account_id'] 7889 7890 query_params = {} 7891 7892 header_params = {} 7893 7894 form_params = [] 7895 local_var_files = {} 7896 7897 body_params = None 7898 if 'account_password_rules' in params: 7899 body_params = params['account_password_rules'] 7900 # HTTP header `Accept` 7901 header_params['Accept'] = self.api_client.\ 7902 select_header_accept(['application/json']) 7903 7904 # Authentication setting 7905 auth_settings = [] 7906 7907 return self.api_client.call_api(resource_path, 'PUT', 7908 path_params, 7909 query_params, 7910 header_params, 7911 body=body_params, 7912 post_params=form_params, 7913 files=local_var_files, 7914 response_type='AccountPasswordRules', 7915 auth_settings=auth_settings, 7916 callback=params.get('callback'), 7917 _return_http_data_only=params.get('_return_http_data_only'), 7918 _preload_content=params.get('_preload_content', True), 7919 _request_timeout=params.get('_request_timeout'), 7920 collection_formats=collection_formats)
Update the password rules
This method updates the password rules for an account. Note: To update the password rules for an account, you must be an account administrator.
This method makes a synchronous HTTP request by default. To make 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_password_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)
- AccountPasswordRules account_password_rules:
Returns
AccountPasswordRules If the method is called asynchronously, returns the request thread.
def
update_permission_profile(self, account_id, permission_profile_id, **kwargs)
7922 def update_permission_profile(self, account_id, permission_profile_id, **kwargs): 7923 """ 7924 Updates a permission profile within the specified account. 7925 This method updates an account permission profile. ### Related topics - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 7926 This method makes a synchronous HTTP request by default. To make an 7927 asynchronous HTTP request, please define a `callback` function 7928 to be invoked when receiving the response. 7929 >>> def callback_function(response): 7930 >>> pprint(response) 7931 >>> 7932 >>> thread = api.update_permission_profile(account_id, permission_profile_id, callback=callback_function) 7933 7934 :param callback function: The callback function 7935 for asynchronous request. (optional) 7936 :param str account_id: The external account number (int) or account ID Guid. (required) 7937 :param str permission_profile_id: (required) 7938 :param str include: 7939 :param PermissionProfile permission_profile: 7940 :return: PermissionProfile 7941 If the method is called asynchronously, 7942 returns the request thread. 7943 """ 7944 kwargs['_return_http_data_only'] = True 7945 if kwargs.get('callback'): 7946 return self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 7947 else: 7948 (data) = self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 7949 return data
Updates a permission profile within the specified account.
This method updates an account permission profile. ### Related topics - How to update individual permission settings
This method makes a synchronous HTTP request by default. To make 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_permission_profile(account_id, permission_profile_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str permission_profile_id: (required)
- str include:
- PermissionProfile permission_profile:
Returns
PermissionProfile If the method is called asynchronously, returns the request thread.
def
update_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs)
7951 def update_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 7952 """ 7953 Updates a permission profile within the specified account. 7954 This method updates an account permission profile. ### Related topics - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 7955 This method makes a synchronous HTTP request by default. To make an 7956 asynchronous HTTP request, please define a `callback` function 7957 to be invoked when receiving the response. 7958 >>> def callback_function(response): 7959 >>> pprint(response) 7960 >>> 7961 >>> thread = api.update_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 7962 7963 :param callback function: The callback function 7964 for asynchronous request. (optional) 7965 :param str account_id: The external account number (int) or account ID Guid. (required) 7966 :param str permission_profile_id: (required) 7967 :param str include: 7968 :param PermissionProfile permission_profile: 7969 :return: PermissionProfile 7970 If the method is called asynchronously, 7971 returns the request thread. 7972 """ 7973 7974 all_params = ['account_id', 'permission_profile_id', 'include', 'permission_profile'] 7975 all_params.append('callback') 7976 all_params.append('_return_http_data_only') 7977 all_params.append('_preload_content') 7978 all_params.append('_request_timeout') 7979 7980 params = locals() 7981 for key, val in iteritems(params['kwargs']): 7982 if key not in all_params: 7983 raise TypeError( 7984 "Got an unexpected keyword argument '%s'" 7985 " to method update_permission_profile" % key 7986 ) 7987 params[key] = val 7988 del params['kwargs'] 7989 # verify the required parameter 'account_id' is set 7990 if ('account_id' not in params) or (params['account_id'] is None): 7991 raise ValueError("Missing the required parameter `account_id` when calling `update_permission_profile`") 7992 # verify the required parameter 'permission_profile_id' is set 7993 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 7994 raise ValueError("Missing the required parameter `permission_profile_id` when calling `update_permission_profile`") 7995 7996 7997 collection_formats = {} 7998 7999 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 8000 path_params = {} 8001 if 'account_id' in params: 8002 path_params['accountId'] = params['account_id'] 8003 if 'permission_profile_id' in params: 8004 path_params['permissionProfileId'] = params['permission_profile_id'] 8005 8006 query_params = {} 8007 if 'include' in params: 8008 query_params['include'] = params['include'] 8009 8010 header_params = {} 8011 8012 form_params = [] 8013 local_var_files = {} 8014 8015 body_params = None 8016 if 'permission_profile' in params: 8017 body_params = params['permission_profile'] 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, 'PUT', 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='PermissionProfile', 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)
Updates a permission profile within the specified account.
This method updates an account permission profile. ### Related topics - How to update individual permission settings
This method makes a synchronous HTTP request by default. To make 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_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str permission_profile_id: (required)
- str include:
- PermissionProfile permission_profile:
Returns
PermissionProfile If the method is called asynchronously, returns the request thread.
def
update_settings(self, account_id, **kwargs)
8040 def update_settings(self, account_id, **kwargs): 8041 """ 8042 Updates the account settings for an account. 8043 Updates the account settings for the specified account. 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.update_settings(account_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 AccountSettingsInformation account_settings_information: 8056 :return: None 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.update_settings_with_http_info(account_id, **kwargs) 8063 else: 8064 (data) = self.update_settings_with_http_info(account_id, **kwargs) 8065 return data
Updates the account settings for an account.
Updates the account settings for the specified 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_settings(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)
- AccountSettingsInformation account_settings_information:
Returns
None If the method is called asynchronously, returns the request thread.
def
update_settings_with_http_info(self, account_id, **kwargs)
8067 def update_settings_with_http_info(self, account_id, **kwargs): 8068 """ 8069 Updates the account settings for an account. 8070 Updates the account settings for the specified account. 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.update_settings_with_http_info(account_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 AccountSettingsInformation account_settings_information: 8083 :return: None 8084 If the method is called asynchronously, 8085 returns the request thread. 8086 """ 8087 8088 all_params = ['account_id', 'account_settings_information'] 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 update_settings" % 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 `update_settings`") 8106 8107 8108 collection_formats = {} 8109 8110 resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json') 8111 path_params = {} 8112 if 'account_id' in params: 8113 path_params['accountId'] = params['account_id'] 8114 8115 query_params = {} 8116 8117 header_params = {} 8118 8119 form_params = [] 8120 local_var_files = {} 8121 8122 body_params = None 8123 if 'account_settings_information' in params: 8124 body_params = params['account_settings_information'] 8125 # HTTP header `Accept` 8126 header_params['Accept'] = self.api_client.\ 8127 select_header_accept(['application/json']) 8128 8129 # Authentication setting 8130 auth_settings = [] 8131 8132 return self.api_client.call_api(resource_path, 'PUT', 8133 path_params, 8134 query_params, 8135 header_params, 8136 body=body_params, 8137 post_params=form_params, 8138 files=local_var_files, 8139 response_type=None, 8140 auth_settings=auth_settings, 8141 callback=params.get('callback'), 8142 _return_http_data_only=params.get('_return_http_data_only'), 8143 _preload_content=params.get('_preload_content', True), 8144 _request_timeout=params.get('_request_timeout'), 8145 collection_formats=collection_formats)
Updates the account settings for an account.
Updates the account settings for the specified 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_settings_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)
- AccountSettingsInformation account_settings_information:
Returns
None If the method is called asynchronously, returns the request thread.
def
update_watermark(self, account_id, **kwargs)
8385 def update_watermark(self, account_id, **kwargs): 8386 """ 8387 Update watermark information. 8388 8389 This method makes a synchronous HTTP request by default. To make an 8390 asynchronous HTTP request, please define a `callback` function 8391 to be invoked when receiving the response. 8392 >>> def callback_function(response): 8393 >>> pprint(response) 8394 >>> 8395 >>> thread = api.update_watermark(account_id, callback=callback_function) 8396 8397 :param callback function: The callback function 8398 for asynchronous request. (optional) 8399 :param str account_id: The external account number (int) or account ID Guid. (required) 8400 :param Watermark watermark: 8401 :return: Watermark 8402 If the method is called asynchronously, 8403 returns the request thread. 8404 """ 8405 kwargs['_return_http_data_only'] = True 8406 if kwargs.get('callback'): 8407 return self.update_watermark_with_http_info(account_id, **kwargs) 8408 else: 8409 (data) = self.update_watermark_with_http_info(account_id, **kwargs) 8410 return data
Update watermark information.
This method makes a synchronous HTTP request by default. To make 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_watermark(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)
- Watermark watermark:
Returns
Watermark If the method is called asynchronously, returns the request thread.
def
update_watermark_with_http_info(self, account_id, **kwargs)
8412 def update_watermark_with_http_info(self, account_id, **kwargs): 8413 """ 8414 Update watermark information. 8415 8416 This method makes a synchronous HTTP request by default. To make an 8417 asynchronous HTTP request, please define a `callback` function 8418 to be invoked when receiving the response. 8419 >>> def callback_function(response): 8420 >>> pprint(response) 8421 >>> 8422 >>> thread = api.update_watermark_with_http_info(account_id, callback=callback_function) 8423 8424 :param callback function: The callback function 8425 for asynchronous request. (optional) 8426 :param str account_id: The external account number (int) or account ID Guid. (required) 8427 :param Watermark watermark: 8428 :return: Watermark 8429 If the method is called asynchronously, 8430 returns the request thread. 8431 """ 8432 8433 all_params = ['account_id', 'watermark'] 8434 all_params.append('callback') 8435 all_params.append('_return_http_data_only') 8436 all_params.append('_preload_content') 8437 all_params.append('_request_timeout') 8438 8439 params = locals() 8440 for key, val in iteritems(params['kwargs']): 8441 if key not in all_params: 8442 raise TypeError( 8443 "Got an unexpected keyword argument '%s'" 8444 " to method update_watermark" % key 8445 ) 8446 params[key] = val 8447 del params['kwargs'] 8448 # verify the required parameter 'account_id' is set 8449 if ('account_id' not in params) or (params['account_id'] is None): 8450 raise ValueError("Missing the required parameter `account_id` when calling `update_watermark`") 8451 8452 8453 collection_formats = {} 8454 8455 resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json') 8456 path_params = {} 8457 if 'account_id' in params: 8458 path_params['accountId'] = params['account_id'] 8459 8460 query_params = {} 8461 8462 header_params = {} 8463 8464 form_params = [] 8465 local_var_files = {} 8466 8467 body_params = None 8468 if 'watermark' in params: 8469 body_params = params['watermark'] 8470 # HTTP header `Accept` 8471 header_params['Accept'] = self.api_client.\ 8472 select_header_accept(['application/json']) 8473 8474 # Authentication setting 8475 auth_settings = [] 8476 8477 return self.api_client.call_api(resource_path, 'PUT', 8478 path_params, 8479 query_params, 8480 header_params, 8481 body=body_params, 8482 post_params=form_params, 8483 files=local_var_files, 8484 response_type='Watermark', 8485 auth_settings=auth_settings, 8486 callback=params.get('callback'), 8487 _return_http_data_only=params.get('_return_http_data_only'), 8488 _preload_content=params.get('_preload_content', True), 8489 _request_timeout=params.get('_request_timeout'), 8490 collection_formats=collection_formats)
Update watermark information.
This method makes a synchronous HTTP request by default. To make 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_watermark_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)
- Watermark watermark:
Returns
Watermark If the method is called asynchronously, returns the request thread.