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 :param str include_trial_eligibility: 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 :param str include_trial_eligibility: 2303 :return: AccountInformation 2304 If the method is called asynchronously, 2305 returns the request thread. 2306 """ 2307 2308 all_params = ['account_id', 'include_account_settings', 'include_trial_eligibility'] 2309 all_params.append('callback') 2310 all_params.append('_return_http_data_only') 2311 all_params.append('_preload_content') 2312 all_params.append('_request_timeout') 2313 2314 params = locals() 2315 for key, val in iteritems(params['kwargs']): 2316 if key not in all_params: 2317 raise TypeError( 2318 "Got an unexpected keyword argument '%s'" 2319 " to method get_account_information" % key 2320 ) 2321 params[key] = val 2322 del params['kwargs'] 2323 # verify the required parameter 'account_id' is set 2324 if ('account_id' not in params) or (params['account_id'] is None): 2325 raise ValueError("Missing the required parameter `account_id` when calling `get_account_information`") 2326 2327 2328 collection_formats = {} 2329 2330 resource_path = '/v2.1/accounts/{accountId}'.replace('{format}', 'json') 2331 path_params = {} 2332 if 'account_id' in params: 2333 path_params['accountId'] = params['account_id'] 2334 2335 query_params = {} 2336 if 'include_account_settings' in params: 2337 query_params['include_account_settings'] = params['include_account_settings'] 2338 if 'include_trial_eligibility' in params: 2339 query_params['include_trial_eligibility'] = params['include_trial_eligibility'] 2340 2341 header_params = {} 2342 2343 form_params = [] 2344 local_var_files = {} 2345 2346 body_params = None 2347 # HTTP header `Accept` 2348 header_params['Accept'] = self.api_client.\ 2349 select_header_accept(['application/json']) 2350 2351 # Authentication setting 2352 auth_settings = [] 2353 2354 return self.api_client.call_api(resource_path, 'GET', 2355 path_params, 2356 query_params, 2357 header_params, 2358 body=body_params, 2359 post_params=form_params, 2360 files=local_var_files, 2361 response_type='AccountInformation', 2362 auth_settings=auth_settings, 2363 callback=params.get('callback'), 2364 _return_http_data_only=params.get('_return_http_data_only'), 2365 _preload_content=params.get('_preload_content', True), 2366 _request_timeout=params.get('_request_timeout'), 2367 collection_formats=collection_formats) 2368 2369 def get_account_signature(self, account_id, signature_id, **kwargs): 2370 """ 2371 Returns information about a single signature by specifed signatureId. 2372 2373 This method makes a synchronous HTTP request by default. To make an 2374 asynchronous HTTP request, please define a `callback` function 2375 to be invoked when receiving the response. 2376 >>> def callback_function(response): 2377 >>> pprint(response) 2378 >>> 2379 >>> thread = api.get_account_signature(account_id, signature_id, callback=callback_function) 2380 2381 :param callback function: The callback function 2382 for asynchronous request. (optional) 2383 :param str account_id: The external account number (int) or account ID Guid. (required) 2384 :param str signature_id: The ID of the signature being accessed. (required) 2385 :return: AccountSignature 2386 If the method is called asynchronously, 2387 returns the request thread. 2388 """ 2389 kwargs['_return_http_data_only'] = True 2390 if kwargs.get('callback'): 2391 return self.get_account_signature_with_http_info(account_id, signature_id, **kwargs) 2392 else: 2393 (data) = self.get_account_signature_with_http_info(account_id, signature_id, **kwargs) 2394 return data 2395 2396 def get_account_signature_with_http_info(self, account_id, signature_id, **kwargs): 2397 """ 2398 Returns information about a single signature by specifed signatureId. 2399 2400 This method makes a synchronous HTTP request by default. To make an 2401 asynchronous HTTP request, please define a `callback` function 2402 to be invoked when receiving the response. 2403 >>> def callback_function(response): 2404 >>> pprint(response) 2405 >>> 2406 >>> thread = api.get_account_signature_with_http_info(account_id, signature_id, callback=callback_function) 2407 2408 :param callback function: The callback function 2409 for asynchronous request. (optional) 2410 :param str account_id: The external account number (int) or account ID Guid. (required) 2411 :param str signature_id: The ID of the signature being accessed. (required) 2412 :return: AccountSignature 2413 If the method is called asynchronously, 2414 returns the request thread. 2415 """ 2416 2417 all_params = ['account_id', 'signature_id'] 2418 all_params.append('callback') 2419 all_params.append('_return_http_data_only') 2420 all_params.append('_preload_content') 2421 all_params.append('_request_timeout') 2422 2423 params = locals() 2424 for key, val in iteritems(params['kwargs']): 2425 if key not in all_params: 2426 raise TypeError( 2427 "Got an unexpected keyword argument '%s'" 2428 " to method get_account_signature" % key 2429 ) 2430 params[key] = val 2431 del params['kwargs'] 2432 # verify the required parameter 'account_id' is set 2433 if ('account_id' not in params) or (params['account_id'] is None): 2434 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signature`") 2435 # verify the required parameter 'signature_id' is set 2436 if ('signature_id' not in params) or (params['signature_id'] is None): 2437 raise ValueError("Missing the required parameter `signature_id` when calling `get_account_signature`") 2438 2439 2440 collection_formats = {} 2441 2442 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 2443 path_params = {} 2444 if 'account_id' in params: 2445 path_params['accountId'] = params['account_id'] 2446 if 'signature_id' in params: 2447 path_params['signatureId'] = params['signature_id'] 2448 2449 query_params = {} 2450 2451 header_params = {} 2452 2453 form_params = [] 2454 local_var_files = {} 2455 2456 body_params = None 2457 # HTTP header `Accept` 2458 header_params['Accept'] = self.api_client.\ 2459 select_header_accept(['application/json']) 2460 2461 # Authentication setting 2462 auth_settings = [] 2463 2464 return self.api_client.call_api(resource_path, 'GET', 2465 path_params, 2466 query_params, 2467 header_params, 2468 body=body_params, 2469 post_params=form_params, 2470 files=local_var_files, 2471 response_type='AccountSignature', 2472 auth_settings=auth_settings, 2473 callback=params.get('callback'), 2474 _return_http_data_only=params.get('_return_http_data_only'), 2475 _preload_content=params.get('_preload_content', True), 2476 _request_timeout=params.get('_request_timeout'), 2477 collection_formats=collection_formats) 2478 2479 def get_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 2480 """ 2481 Returns a signature, initials, or stamps image. 2482 2483 This method makes a synchronous HTTP request by default. To make an 2484 asynchronous HTTP request, please define a `callback` function 2485 to be invoked when receiving the response. 2486 >>> def callback_function(response): 2487 >>> pprint(response) 2488 >>> 2489 >>> thread = api.get_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 2490 2491 :param callback function: The callback function 2492 for asynchronous request. (optional) 2493 :param str account_id: The external account number (int) or account ID Guid. (required) 2494 :param str image_type: One of **signature_image** or **initials_image**. (required) 2495 :param str signature_id: The ID of the signature being accessed. (required) 2496 :param str include_chrome: 2497 :return: file 2498 If the method is called asynchronously, 2499 returns the request thread. 2500 """ 2501 kwargs['_return_http_data_only'] = True 2502 if kwargs.get('callback'): 2503 return self.get_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 2504 else: 2505 (data) = self.get_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 2506 return data 2507 2508 def get_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 2509 """ 2510 Returns a signature, initials, or stamps image. 2511 2512 This method makes a synchronous HTTP request by default. To make an 2513 asynchronous HTTP request, please define a `callback` function 2514 to be invoked when receiving the response. 2515 >>> def callback_function(response): 2516 >>> pprint(response) 2517 >>> 2518 >>> thread = api.get_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 2519 2520 :param callback function: The callback function 2521 for asynchronous request. (optional) 2522 :param str account_id: The external account number (int) or account ID Guid. (required) 2523 :param str image_type: One of **signature_image** or **initials_image**. (required) 2524 :param str signature_id: The ID of the signature being accessed. (required) 2525 :param str include_chrome: 2526 :return: file 2527 If the method is called asynchronously, 2528 returns the request thread. 2529 """ 2530 2531 all_params = ['account_id', 'image_type', 'signature_id', 'include_chrome'] 2532 all_params.append('callback') 2533 all_params.append('_return_http_data_only') 2534 all_params.append('_preload_content') 2535 all_params.append('_request_timeout') 2536 2537 params = locals() 2538 for key, val in iteritems(params['kwargs']): 2539 if key not in all_params: 2540 raise TypeError( 2541 "Got an unexpected keyword argument '%s'" 2542 " to method get_account_signature_image" % key 2543 ) 2544 params[key] = val 2545 del params['kwargs'] 2546 # verify the required parameter 'account_id' is set 2547 if ('account_id' not in params) or (params['account_id'] is None): 2548 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signature_image`") 2549 # verify the required parameter 'image_type' is set 2550 if ('image_type' not in params) or (params['image_type'] is None): 2551 raise ValueError("Missing the required parameter `image_type` when calling `get_account_signature_image`") 2552 # verify the required parameter 'signature_id' is set 2553 if ('signature_id' not in params) or (params['signature_id'] is None): 2554 raise ValueError("Missing the required parameter `signature_id` when calling `get_account_signature_image`") 2555 2556 2557 collection_formats = {} 2558 2559 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 2560 path_params = {} 2561 if 'account_id' in params: 2562 path_params['accountId'] = params['account_id'] 2563 if 'image_type' in params: 2564 path_params['imageType'] = params['image_type'] 2565 if 'signature_id' in params: 2566 path_params['signatureId'] = params['signature_id'] 2567 2568 query_params = {} 2569 if 'include_chrome' in params: 2570 query_params['include_chrome'] = params['include_chrome'] 2571 2572 header_params = {} 2573 2574 form_params = [] 2575 local_var_files = {} 2576 2577 body_params = None 2578 # HTTP header `Accept` 2579 header_params['Accept'] = self.api_client.\ 2580 select_header_accept(['image/gif']) 2581 2582 # Authentication setting 2583 auth_settings = [] 2584 2585 return self.api_client.call_api(resource_path, 'GET', 2586 path_params, 2587 query_params, 2588 header_params, 2589 body=body_params, 2590 post_params=form_params, 2591 files=local_var_files, 2592 response_type='file', 2593 auth_settings=auth_settings, 2594 callback=params.get('callback'), 2595 _return_http_data_only=params.get('_return_http_data_only'), 2596 _preload_content=params.get('_preload_content', True), 2597 _request_timeout=params.get('_request_timeout'), 2598 collection_formats=collection_formats) 2599 2600 def get_account_signatures(self, account_id, **kwargs): 2601 """ 2602 Returns the managed signature definitions for the account 2603 2604 This method makes a synchronous HTTP request by default. To make an 2605 asynchronous HTTP request, please define a `callback` function 2606 to be invoked when receiving the response. 2607 >>> def callback_function(response): 2608 >>> pprint(response) 2609 >>> 2610 >>> thread = api.get_account_signatures(account_id, callback=callback_function) 2611 2612 :param callback function: The callback function 2613 for asynchronous request. (optional) 2614 :param str account_id: The external account number (int) or account ID Guid. (required) 2615 :param str stamp_format: 2616 :param str stamp_name: 2617 :param str stamp_type: 2618 :return: AccountSignaturesInformation 2619 If the method is called asynchronously, 2620 returns the request thread. 2621 """ 2622 kwargs['_return_http_data_only'] = True 2623 if kwargs.get('callback'): 2624 return self.get_account_signatures_with_http_info(account_id, **kwargs) 2625 else: 2626 (data) = self.get_account_signatures_with_http_info(account_id, **kwargs) 2627 return data 2628 2629 def get_account_signatures_with_http_info(self, account_id, **kwargs): 2630 """ 2631 Returns the managed signature definitions for the account 2632 2633 This method makes a synchronous HTTP request by default. To make an 2634 asynchronous HTTP request, please define a `callback` function 2635 to be invoked when receiving the response. 2636 >>> def callback_function(response): 2637 >>> pprint(response) 2638 >>> 2639 >>> thread = api.get_account_signatures_with_http_info(account_id, callback=callback_function) 2640 2641 :param callback function: The callback function 2642 for asynchronous request. (optional) 2643 :param str account_id: The external account number (int) or account ID Guid. (required) 2644 :param str stamp_format: 2645 :param str stamp_name: 2646 :param str stamp_type: 2647 :return: AccountSignaturesInformation 2648 If the method is called asynchronously, 2649 returns the request thread. 2650 """ 2651 2652 all_params = ['account_id', 'stamp_format', 'stamp_name', 'stamp_type'] 2653 all_params.append('callback') 2654 all_params.append('_return_http_data_only') 2655 all_params.append('_preload_content') 2656 all_params.append('_request_timeout') 2657 2658 params = locals() 2659 for key, val in iteritems(params['kwargs']): 2660 if key not in all_params: 2661 raise TypeError( 2662 "Got an unexpected keyword argument '%s'" 2663 " to method get_account_signatures" % key 2664 ) 2665 params[key] = val 2666 del params['kwargs'] 2667 # verify the required parameter 'account_id' is set 2668 if ('account_id' not in params) or (params['account_id'] is None): 2669 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signatures`") 2670 2671 2672 collection_formats = {} 2673 2674 resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json') 2675 path_params = {} 2676 if 'account_id' in params: 2677 path_params['accountId'] = params['account_id'] 2678 2679 query_params = {} 2680 if 'stamp_format' in params: 2681 query_params['stamp_format'] = params['stamp_format'] 2682 if 'stamp_name' in params: 2683 query_params['stamp_name'] = params['stamp_name'] 2684 if 'stamp_type' in params: 2685 query_params['stamp_type'] = params['stamp_type'] 2686 2687 header_params = {} 2688 2689 form_params = [] 2690 local_var_files = {} 2691 2692 body_params = None 2693 # HTTP header `Accept` 2694 header_params['Accept'] = self.api_client.\ 2695 select_header_accept(['application/json']) 2696 2697 # Authentication setting 2698 auth_settings = [] 2699 2700 return self.api_client.call_api(resource_path, 'GET', 2701 path_params, 2702 query_params, 2703 header_params, 2704 body=body_params, 2705 post_params=form_params, 2706 files=local_var_files, 2707 response_type='AccountSignaturesInformation', 2708 auth_settings=auth_settings, 2709 callback=params.get('callback'), 2710 _return_http_data_only=params.get('_return_http_data_only'), 2711 _preload_content=params.get('_preload_content', True), 2712 _request_timeout=params.get('_request_timeout'), 2713 collection_formats=collection_formats) 2714 2715 def get_account_tab_settings(self, account_id, **kwargs): 2716 """ 2717 Returns tab settings list for specified account 2718 This method returns information about the tab types and tab functionality that is currently enabled for an account. 2719 This method makes a synchronous HTTP request by default. To make an 2720 asynchronous HTTP request, please define a `callback` function 2721 to be invoked when receiving the response. 2722 >>> def callback_function(response): 2723 >>> pprint(response) 2724 >>> 2725 >>> thread = api.get_account_tab_settings(account_id, callback=callback_function) 2726 2727 :param callback function: The callback function 2728 for asynchronous request. (optional) 2729 :param str account_id: The external account number (int) or account ID Guid. (required) 2730 :return: TabAccountSettings 2731 If the method is called asynchronously, 2732 returns the request thread. 2733 """ 2734 kwargs['_return_http_data_only'] = True 2735 if kwargs.get('callback'): 2736 return self.get_account_tab_settings_with_http_info(account_id, **kwargs) 2737 else: 2738 (data) = self.get_account_tab_settings_with_http_info(account_id, **kwargs) 2739 return data 2740 2741 def get_account_tab_settings_with_http_info(self, account_id, **kwargs): 2742 """ 2743 Returns tab settings list for specified account 2744 This method returns information about the tab types and tab functionality that is currently enabled for an account. 2745 This method makes a synchronous HTTP request by default. To make an 2746 asynchronous HTTP request, please define a `callback` function 2747 to be invoked when receiving the response. 2748 >>> def callback_function(response): 2749 >>> pprint(response) 2750 >>> 2751 >>> thread = api.get_account_tab_settings_with_http_info(account_id, callback=callback_function) 2752 2753 :param callback function: The callback function 2754 for asynchronous request. (optional) 2755 :param str account_id: The external account number (int) or account ID Guid. (required) 2756 :return: TabAccountSettings 2757 If the method is called asynchronously, 2758 returns the request thread. 2759 """ 2760 2761 all_params = ['account_id'] 2762 all_params.append('callback') 2763 all_params.append('_return_http_data_only') 2764 all_params.append('_preload_content') 2765 all_params.append('_request_timeout') 2766 2767 params = locals() 2768 for key, val in iteritems(params['kwargs']): 2769 if key not in all_params: 2770 raise TypeError( 2771 "Got an unexpected keyword argument '%s'" 2772 " to method get_account_tab_settings" % key 2773 ) 2774 params[key] = val 2775 del params['kwargs'] 2776 # verify the required parameter 'account_id' is set 2777 if ('account_id' not in params) or (params['account_id'] is None): 2778 raise ValueError("Missing the required parameter `account_id` when calling `get_account_tab_settings`") 2779 2780 2781 collection_formats = {} 2782 2783 resource_path = '/v2.1/accounts/{accountId}/settings/tabs'.replace('{format}', 'json') 2784 path_params = {} 2785 if 'account_id' in params: 2786 path_params['accountId'] = params['account_id'] 2787 2788 query_params = {} 2789 2790 header_params = {} 2791 2792 form_params = [] 2793 local_var_files = {} 2794 2795 body_params = None 2796 # HTTP header `Accept` 2797 header_params['Accept'] = self.api_client.\ 2798 select_header_accept(['application/json']) 2799 2800 # Authentication setting 2801 auth_settings = [] 2802 2803 return self.api_client.call_api(resource_path, 'GET', 2804 path_params, 2805 query_params, 2806 header_params, 2807 body=body_params, 2808 post_params=form_params, 2809 files=local_var_files, 2810 response_type='TabAccountSettings', 2811 auth_settings=auth_settings, 2812 callback=params.get('callback'), 2813 _return_http_data_only=params.get('_return_http_data_only'), 2814 _preload_content=params.get('_preload_content', True), 2815 _request_timeout=params.get('_request_timeout'), 2816 collection_formats=collection_formats) 2817 2818 def get_agent_user_authorizations(self, account_id, user_id, **kwargs): 2819 """ 2820 Returns the agent user authorizations 2821 This method makes a synchronous HTTP request by default. To make an 2822 asynchronous HTTP request, please define a `callback` function 2823 to be invoked when receiving the response. 2824 >>> def callback_function(response): 2825 >>> pprint(response) 2826 >>> 2827 >>> thread = api.get_agent_user_authorizations(account_id, user_id, callback=callback_function) 2828 2829 :param callback function: The callback function 2830 for asynchronous request. (optional) 2831 :param str account_id: The external account number (int) or account ID Guid. (required) 2832 :param str 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) 2833 :param str active_only: 2834 :param str count: 2835 :param str email_substring: Part (substring) of email we are searching for. 2836 :param str include_closed_users: 2837 :param str permissions: 2838 :param str start_position: 2839 :param str user_name_substring: 2840 :return: UserAuthorizations 2841 If the method is called asynchronously, 2842 returns the request thread. 2843 """ 2844 kwargs['_return_http_data_only'] = True 2845 if kwargs.get('callback'): 2846 return self.get_agent_user_authorizations_with_http_info(account_id, user_id, **kwargs) 2847 else: 2848 (data) = self.get_agent_user_authorizations_with_http_info(account_id, user_id, **kwargs) 2849 return data 2850 2851 def get_agent_user_authorizations_with_http_info(self, account_id, user_id, **kwargs): 2852 """ 2853 Returns the agent user authorizations 2854 This method makes a synchronous HTTP request by default. To make an 2855 asynchronous HTTP request, please define a `callback` function 2856 to be invoked when receiving the response. 2857 >>> def callback_function(response): 2858 >>> pprint(response) 2859 >>> 2860 >>> thread = api.get_agent_user_authorizations_with_http_info(account_id, user_id, callback=callback_function) 2861 2862 :param callback function: The callback function 2863 for asynchronous request. (optional) 2864 :param str account_id: The external account number (int) or account ID Guid. (required) 2865 :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) 2866 :param str active_only: 2867 :param str count: 2868 :param str email_substring: Part (substring) of email we are searching for. 2869 :param str include_closed_users: 2870 :param str permissions: 2871 :param str start_position: 2872 :param str user_name_substring: 2873 :return: UserAuthorizations 2874 If the method is called asynchronously, 2875 returns the request thread. 2876 """ 2877 2878 all_params = ['account_id', 'user_id', 'active_only', 'count', 'email_substring', 'include_closed_users', 'permissions', 'start_position', 'user_name_substring'] 2879 all_params.append('callback') 2880 all_params.append('_return_http_data_only') 2881 all_params.append('_preload_content') 2882 all_params.append('_request_timeout') 2883 2884 params = locals() 2885 for key, val in iteritems(params['kwargs']): 2886 if key not in all_params: 2887 raise TypeError( 2888 "Got an unexpected keyword argument '%s'" 2889 " to method get_agent_user_authorizations" % key 2890 ) 2891 params[key] = val 2892 del params['kwargs'] 2893 # verify the required parameter 'account_id' is set 2894 if ('account_id' not in params) or (params['account_id'] is None): 2895 raise ValueError("Missing the required parameter `account_id` when calling `get_agent_user_authorizations`") 2896 # verify the required parameter 'user_id' is set 2897 if ('user_id' not in params) or (params['user_id'] is None): 2898 raise ValueError("Missing the required parameter `user_id` when calling `get_agent_user_authorizations`") 2899 2900 2901 collection_formats = {} 2902 2903 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorizations/agent'.replace('{format}', 'json') 2904 path_params = {} 2905 if 'account_id' in params: 2906 path_params['accountId'] = params['account_id'] 2907 if 'user_id' in params: 2908 path_params['userId'] = params['user_id'] 2909 2910 query_params = {} 2911 if 'active_only' in params: 2912 query_params['active_only'] = params['active_only'] 2913 if 'count' in params: 2914 query_params['count'] = params['count'] 2915 if 'email_substring' in params: 2916 query_params['email_substring'] = params['email_substring'] 2917 if 'include_closed_users' in params: 2918 query_params['include_closed_users'] = params['include_closed_users'] 2919 if 'permissions' in params: 2920 query_params['permissions'] = params['permissions'] 2921 if 'start_position' in params: 2922 query_params['start_position'] = params['start_position'] 2923 if 'user_name_substring' in params: 2924 query_params['user_name_substring'] = params['user_name_substring'] 2925 2926 header_params = {} 2927 2928 form_params = [] 2929 local_var_files = {} 2930 2931 body_params = None 2932 # HTTP header `Accept` 2933 header_params['Accept'] = self.api_client.\ 2934 select_header_accept(['application/json']) 2935 2936 # Authentication setting 2937 auth_settings = [] 2938 2939 return self.api_client.call_api(resource_path, 'GET', 2940 path_params, 2941 query_params, 2942 header_params, 2943 body=body_params, 2944 post_params=form_params, 2945 files=local_var_files, 2946 response_type='UserAuthorizations', 2947 auth_settings=auth_settings, 2948 callback=params.get('callback'), 2949 _return_http_data_only=params.get('_return_http_data_only'), 2950 _preload_content=params.get('_preload_content', True), 2951 _request_timeout=params.get('_request_timeout'), 2952 collection_formats=collection_formats) 2953 2954 def get_all_payment_gateway_accounts(self, account_id, **kwargs): 2955 """ 2956 Get all payment gateway account for the provided accountId 2957 This method returns a list of payment gateway accounts and basic information about them. 2958 This method makes a synchronous HTTP request by default. To make an 2959 asynchronous HTTP request, please define a `callback` function 2960 to be invoked when receiving the response. 2961 >>> def callback_function(response): 2962 >>> pprint(response) 2963 >>> 2964 >>> thread = api.get_all_payment_gateway_accounts(account_id, callback=callback_function) 2965 2966 :param callback function: The callback function 2967 for asynchronous request. (optional) 2968 :param str account_id: The external account number (int) or account ID Guid. (required) 2969 :return: PaymentGatewayAccountsInfo 2970 If the method is called asynchronously, 2971 returns the request thread. 2972 """ 2973 kwargs['_return_http_data_only'] = True 2974 if kwargs.get('callback'): 2975 return self.get_all_payment_gateway_accounts_with_http_info(account_id, **kwargs) 2976 else: 2977 (data) = self.get_all_payment_gateway_accounts_with_http_info(account_id, **kwargs) 2978 return data 2979 2980 def get_all_payment_gateway_accounts_with_http_info(self, account_id, **kwargs): 2981 """ 2982 Get all payment gateway account for the provided accountId 2983 This method returns a list of payment gateway accounts and basic information about them. 2984 This method makes a synchronous HTTP request by default. To make an 2985 asynchronous HTTP request, please define a `callback` function 2986 to be invoked when receiving the response. 2987 >>> def callback_function(response): 2988 >>> pprint(response) 2989 >>> 2990 >>> thread = api.get_all_payment_gateway_accounts_with_http_info(account_id, callback=callback_function) 2991 2992 :param callback function: The callback function 2993 for asynchronous request. (optional) 2994 :param str account_id: The external account number (int) or account ID Guid. (required) 2995 :return: PaymentGatewayAccountsInfo 2996 If the method is called asynchronously, 2997 returns the request thread. 2998 """ 2999 3000 all_params = ['account_id'] 3001 all_params.append('callback') 3002 all_params.append('_return_http_data_only') 3003 all_params.append('_preload_content') 3004 all_params.append('_request_timeout') 3005 3006 params = locals() 3007 for key, val in iteritems(params['kwargs']): 3008 if key not in all_params: 3009 raise TypeError( 3010 "Got an unexpected keyword argument '%s'" 3011 " to method get_all_payment_gateway_accounts" % key 3012 ) 3013 params[key] = val 3014 del params['kwargs'] 3015 # verify the required parameter 'account_id' is set 3016 if ('account_id' not in params) or (params['account_id'] is None): 3017 raise ValueError("Missing the required parameter `account_id` when calling `get_all_payment_gateway_accounts`") 3018 3019 3020 collection_formats = {} 3021 3022 resource_path = '/v2.1/accounts/{accountId}/payment_gateway_accounts'.replace('{format}', 'json') 3023 path_params = {} 3024 if 'account_id' in params: 3025 path_params['accountId'] = params['account_id'] 3026 3027 query_params = {} 3028 3029 header_params = {} 3030 3031 form_params = [] 3032 local_var_files = {} 3033 3034 body_params = None 3035 # HTTP header `Accept` 3036 header_params['Accept'] = self.api_client.\ 3037 select_header_accept(['application/json']) 3038 3039 # Authentication setting 3040 auth_settings = [] 3041 3042 return self.api_client.call_api(resource_path, 'GET', 3043 path_params, 3044 query_params, 3045 header_params, 3046 body=body_params, 3047 post_params=form_params, 3048 files=local_var_files, 3049 response_type='PaymentGatewayAccountsInfo', 3050 auth_settings=auth_settings, 3051 callback=params.get('callback'), 3052 _return_http_data_only=params.get('_return_http_data_only'), 3053 _preload_content=params.get('_preload_content', True), 3054 _request_timeout=params.get('_request_timeout'), 3055 collection_formats=collection_formats) 3056 3057 def get_billing_charges(self, account_id, **kwargs): 3058 """ 3059 Gets list of recurring and usage charges for the account. 3060 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 3061 This method makes a synchronous HTTP request by default. To make an 3062 asynchronous HTTP request, please define a `callback` function 3063 to be invoked when receiving the response. 3064 >>> def callback_function(response): 3065 >>> pprint(response) 3066 >>> 3067 >>> thread = api.get_billing_charges(account_id, callback=callback_function) 3068 3069 :param callback function: The callback function 3070 for asynchronous request. (optional) 3071 :param str account_id: The external account number (int) or account ID Guid. (required) 3072 :param str include_charges: Specifies which billing charges to return. Valid values are: * envelopes * seats 3073 :return: BillingChargeResponse 3074 If the method is called asynchronously, 3075 returns the request thread. 3076 """ 3077 kwargs['_return_http_data_only'] = True 3078 if kwargs.get('callback'): 3079 return self.get_billing_charges_with_http_info(account_id, **kwargs) 3080 else: 3081 (data) = self.get_billing_charges_with_http_info(account_id, **kwargs) 3082 return data 3083 3084 def get_billing_charges_with_http_info(self, account_id, **kwargs): 3085 """ 3086 Gets list of recurring and usage charges for the account. 3087 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 3088 This method makes a synchronous HTTP request by default. To make an 3089 asynchronous HTTP request, please define a `callback` function 3090 to be invoked when receiving the response. 3091 >>> def callback_function(response): 3092 >>> pprint(response) 3093 >>> 3094 >>> thread = api.get_billing_charges_with_http_info(account_id, callback=callback_function) 3095 3096 :param callback function: The callback function 3097 for asynchronous request. (optional) 3098 :param str account_id: The external account number (int) or account ID Guid. (required) 3099 :param str include_charges: Specifies which billing charges to return. Valid values are: * envelopes * seats 3100 :return: BillingChargeResponse 3101 If the method is called asynchronously, 3102 returns the request thread. 3103 """ 3104 3105 all_params = ['account_id', 'include_charges'] 3106 all_params.append('callback') 3107 all_params.append('_return_http_data_only') 3108 all_params.append('_preload_content') 3109 all_params.append('_request_timeout') 3110 3111 params = locals() 3112 for key, val in iteritems(params['kwargs']): 3113 if key not in all_params: 3114 raise TypeError( 3115 "Got an unexpected keyword argument '%s'" 3116 " to method get_billing_charges" % key 3117 ) 3118 params[key] = val 3119 del params['kwargs'] 3120 # verify the required parameter 'account_id' is set 3121 if ('account_id' not in params) or (params['account_id'] is None): 3122 raise ValueError("Missing the required parameter `account_id` when calling `get_billing_charges`") 3123 3124 3125 collection_formats = {} 3126 3127 resource_path = '/v2.1/accounts/{accountId}/billing_charges'.replace('{format}', 'json') 3128 path_params = {} 3129 if 'account_id' in params: 3130 path_params['accountId'] = params['account_id'] 3131 3132 query_params = {} 3133 if 'include_charges' in params: 3134 query_params['include_charges'] = params['include_charges'] 3135 3136 header_params = {} 3137 3138 form_params = [] 3139 local_var_files = {} 3140 3141 body_params = None 3142 # HTTP header `Accept` 3143 header_params['Accept'] = self.api_client.\ 3144 select_header_accept(['application/json']) 3145 3146 # Authentication setting 3147 auth_settings = [] 3148 3149 return self.api_client.call_api(resource_path, 'GET', 3150 path_params, 3151 query_params, 3152 header_params, 3153 body=body_params, 3154 post_params=form_params, 3155 files=local_var_files, 3156 response_type='BillingChargeResponse', 3157 auth_settings=auth_settings, 3158 callback=params.get('callback'), 3159 _return_http_data_only=params.get('_return_http_data_only'), 3160 _preload_content=params.get('_preload_content', True), 3161 _request_timeout=params.get('_request_timeout'), 3162 collection_formats=collection_formats) 3163 3164 def get_brand(self, account_id, brand_id, **kwargs): 3165 """ 3166 Get information for a specific brand. 3167 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**). 3168 This method makes a synchronous HTTP request by default. To make an 3169 asynchronous HTTP request, please define a `callback` function 3170 to be invoked when receiving the response. 3171 >>> def callback_function(response): 3172 >>> pprint(response) 3173 >>> 3174 >>> thread = api.get_brand(account_id, brand_id, callback=callback_function) 3175 3176 :param callback function: The callback function 3177 for asynchronous request. (optional) 3178 :param str account_id: The external account number (int) or account ID Guid. (required) 3179 :param str brand_id: The unique identifier of a brand. (required) 3180 :param str include_external_references: 3181 :param str include_logos: 3182 :return: Brand 3183 If the method is called asynchronously, 3184 returns the request thread. 3185 """ 3186 kwargs['_return_http_data_only'] = True 3187 if kwargs.get('callback'): 3188 return self.get_brand_with_http_info(account_id, brand_id, **kwargs) 3189 else: 3190 (data) = self.get_brand_with_http_info(account_id, brand_id, **kwargs) 3191 return data 3192 3193 def get_brand_with_http_info(self, account_id, brand_id, **kwargs): 3194 """ 3195 Get information for a specific brand. 3196 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**). 3197 This method makes a synchronous HTTP request by default. To make an 3198 asynchronous HTTP request, please define a `callback` function 3199 to be invoked when receiving the response. 3200 >>> def callback_function(response): 3201 >>> pprint(response) 3202 >>> 3203 >>> thread = api.get_brand_with_http_info(account_id, brand_id, callback=callback_function) 3204 3205 :param callback function: The callback function 3206 for asynchronous request. (optional) 3207 :param str account_id: The external account number (int) or account ID Guid. (required) 3208 :param str brand_id: The unique identifier of a brand. (required) 3209 :param str include_external_references: 3210 :param str include_logos: 3211 :return: Brand 3212 If the method is called asynchronously, 3213 returns the request thread. 3214 """ 3215 3216 all_params = ['account_id', 'brand_id', 'include_external_references', 'include_logos'] 3217 all_params.append('callback') 3218 all_params.append('_return_http_data_only') 3219 all_params.append('_preload_content') 3220 all_params.append('_request_timeout') 3221 3222 params = locals() 3223 for key, val in iteritems(params['kwargs']): 3224 if key not in all_params: 3225 raise TypeError( 3226 "Got an unexpected keyword argument '%s'" 3227 " to method get_brand" % key 3228 ) 3229 params[key] = val 3230 del params['kwargs'] 3231 # verify the required parameter 'account_id' is set 3232 if ('account_id' not in params) or (params['account_id'] is None): 3233 raise ValueError("Missing the required parameter `account_id` when calling `get_brand`") 3234 # verify the required parameter 'brand_id' is set 3235 if ('brand_id' not in params) or (params['brand_id'] is None): 3236 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand`") 3237 3238 3239 collection_formats = {} 3240 3241 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 3242 path_params = {} 3243 if 'account_id' in params: 3244 path_params['accountId'] = params['account_id'] 3245 if 'brand_id' in params: 3246 path_params['brandId'] = params['brand_id'] 3247 3248 query_params = {} 3249 if 'include_external_references' in params: 3250 query_params['include_external_references'] = params['include_external_references'] 3251 if 'include_logos' in params: 3252 query_params['include_logos'] = params['include_logos'] 3253 3254 header_params = {} 3255 3256 form_params = [] 3257 local_var_files = {} 3258 3259 body_params = None 3260 # HTTP header `Accept` 3261 header_params['Accept'] = self.api_client.\ 3262 select_header_accept(['application/json']) 3263 3264 # Authentication setting 3265 auth_settings = [] 3266 3267 return self.api_client.call_api(resource_path, 'GET', 3268 path_params, 3269 query_params, 3270 header_params, 3271 body=body_params, 3272 post_params=form_params, 3273 files=local_var_files, 3274 response_type='Brand', 3275 auth_settings=auth_settings, 3276 callback=params.get('callback'), 3277 _return_http_data_only=params.get('_return_http_data_only'), 3278 _preload_content=params.get('_preload_content', True), 3279 _request_timeout=params.get('_request_timeout'), 3280 collection_formats=collection_formats) 3281 3282 def get_brand_export_file(self, account_id, brand_id, **kwargs): 3283 """ 3284 Export a specific brand. 3285 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**). 3286 This method makes a synchronous HTTP request by default. To make an 3287 asynchronous HTTP request, please define a `callback` function 3288 to be invoked when receiving the response. 3289 >>> def callback_function(response): 3290 >>> pprint(response) 3291 >>> 3292 >>> thread = api.get_brand_export_file(account_id, brand_id, callback=callback_function) 3293 3294 :param callback function: The callback function 3295 for asynchronous request. (optional) 3296 :param str account_id: The external account number (int) or account ID Guid. (required) 3297 :param str brand_id: The unique identifier of a brand. (required) 3298 :return: None 3299 If the method is called asynchronously, 3300 returns the request thread. 3301 """ 3302 kwargs['_return_http_data_only'] = True 3303 if kwargs.get('callback'): 3304 return self.get_brand_export_file_with_http_info(account_id, brand_id, **kwargs) 3305 else: 3306 (data) = self.get_brand_export_file_with_http_info(account_id, brand_id, **kwargs) 3307 return data 3308 3309 def get_brand_export_file_with_http_info(self, account_id, brand_id, **kwargs): 3310 """ 3311 Export a specific brand. 3312 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**). 3313 This method makes a synchronous HTTP request by default. To make an 3314 asynchronous HTTP request, please define a `callback` function 3315 to be invoked when receiving the response. 3316 >>> def callback_function(response): 3317 >>> pprint(response) 3318 >>> 3319 >>> thread = api.get_brand_export_file_with_http_info(account_id, brand_id, callback=callback_function) 3320 3321 :param callback function: The callback function 3322 for asynchronous request. (optional) 3323 :param str account_id: The external account number (int) or account ID Guid. (required) 3324 :param str brand_id: The unique identifier of a brand. (required) 3325 :return: None 3326 If the method is called asynchronously, 3327 returns the request thread. 3328 """ 3329 3330 all_params = ['account_id', 'brand_id'] 3331 all_params.append('callback') 3332 all_params.append('_return_http_data_only') 3333 all_params.append('_preload_content') 3334 all_params.append('_request_timeout') 3335 3336 params = locals() 3337 for key, val in iteritems(params['kwargs']): 3338 if key not in all_params: 3339 raise TypeError( 3340 "Got an unexpected keyword argument '%s'" 3341 " to method get_brand_export_file" % key 3342 ) 3343 params[key] = val 3344 del params['kwargs'] 3345 # verify the required parameter 'account_id' is set 3346 if ('account_id' not in params) or (params['account_id'] is None): 3347 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_export_file`") 3348 # verify the required parameter 'brand_id' is set 3349 if ('brand_id' not in params) or (params['brand_id'] is None): 3350 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_export_file`") 3351 3352 3353 collection_formats = {} 3354 3355 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/file'.replace('{format}', 'json') 3356 path_params = {} 3357 if 'account_id' in params: 3358 path_params['accountId'] = params['account_id'] 3359 if 'brand_id' in params: 3360 path_params['brandId'] = params['brand_id'] 3361 3362 query_params = {} 3363 3364 header_params = {} 3365 3366 form_params = [] 3367 local_var_files = {} 3368 3369 body_params = None 3370 # HTTP header `Accept` 3371 header_params['Accept'] = self.api_client.\ 3372 select_header_accept(['application/json']) 3373 3374 # Authentication setting 3375 auth_settings = [] 3376 3377 return self.api_client.call_api(resource_path, 'GET', 3378 path_params, 3379 query_params, 3380 header_params, 3381 body=body_params, 3382 post_params=form_params, 3383 files=local_var_files, 3384 response_type=None, 3385 auth_settings=auth_settings, 3386 callback=params.get('callback'), 3387 _return_http_data_only=params.get('_return_http_data_only'), 3388 _preload_content=params.get('_preload_content', True), 3389 _request_timeout=params.get('_request_timeout'), 3390 collection_formats=collection_formats) 3391 3392 def get_brand_logo_by_type(self, account_id, brand_id, logo_type, **kwargs): 3393 """ 3394 Obtains the specified image for a brand. 3395 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**). 3396 This method makes a synchronous HTTP request by default. To make an 3397 asynchronous HTTP request, please define a `callback` function 3398 to be invoked when receiving the response. 3399 >>> def callback_function(response): 3400 >>> pprint(response) 3401 >>> 3402 >>> thread = api.get_brand_logo_by_type(account_id, brand_id, logo_type, callback=callback_function) 3403 3404 :param callback function: The callback function 3405 for asynchronous request. (optional) 3406 :param str account_id: The external account number (int) or account ID Guid. (required) 3407 :param str brand_id: The unique identifier of a brand. (required) 3408 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 3409 :return: file 3410 If the method is called asynchronously, 3411 returns the request thread. 3412 """ 3413 kwargs['_return_http_data_only'] = True 3414 if kwargs.get('callback'): 3415 return self.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 3416 else: 3417 (data) = self.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 3418 return data 3419 3420 def get_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, **kwargs): 3421 """ 3422 Obtains the specified image for a brand. 3423 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**). 3424 This method makes a synchronous HTTP request by default. To make an 3425 asynchronous HTTP request, please define a `callback` function 3426 to be invoked when receiving the response. 3427 >>> def callback_function(response): 3428 >>> pprint(response) 3429 >>> 3430 >>> thread = api.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, callback=callback_function) 3431 3432 :param callback function: The callback function 3433 for asynchronous request. (optional) 3434 :param str account_id: The external account number (int) or account ID Guid. (required) 3435 :param str brand_id: The unique identifier of a brand. (required) 3436 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 3437 :return: file 3438 If the method is called asynchronously, 3439 returns the request thread. 3440 """ 3441 3442 all_params = ['account_id', 'brand_id', 'logo_type'] 3443 all_params.append('callback') 3444 all_params.append('_return_http_data_only') 3445 all_params.append('_preload_content') 3446 all_params.append('_request_timeout') 3447 3448 params = locals() 3449 for key, val in iteritems(params['kwargs']): 3450 if key not in all_params: 3451 raise TypeError( 3452 "Got an unexpected keyword argument '%s'" 3453 " to method get_brand_logo_by_type" % key 3454 ) 3455 params[key] = val 3456 del params['kwargs'] 3457 # verify the required parameter 'account_id' is set 3458 if ('account_id' not in params) or (params['account_id'] is None): 3459 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_logo_by_type`") 3460 # verify the required parameter 'brand_id' is set 3461 if ('brand_id' not in params) or (params['brand_id'] is None): 3462 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_logo_by_type`") 3463 # verify the required parameter 'logo_type' is set 3464 if ('logo_type' not in params) or (params['logo_type'] is None): 3465 raise ValueError("Missing the required parameter `logo_type` when calling `get_brand_logo_by_type`") 3466 3467 3468 collection_formats = {} 3469 3470 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 3471 path_params = {} 3472 if 'account_id' in params: 3473 path_params['accountId'] = params['account_id'] 3474 if 'brand_id' in params: 3475 path_params['brandId'] = params['brand_id'] 3476 if 'logo_type' in params: 3477 path_params['logoType'] = params['logo_type'] 3478 3479 query_params = {} 3480 3481 header_params = {} 3482 3483 form_params = [] 3484 local_var_files = {} 3485 3486 body_params = None 3487 # HTTP header `Accept` 3488 header_params['Accept'] = self.api_client.\ 3489 select_header_accept(['image/png']) 3490 3491 # Authentication setting 3492 auth_settings = [] 3493 3494 return self.api_client.call_api(resource_path, 'GET', 3495 path_params, 3496 query_params, 3497 header_params, 3498 body=body_params, 3499 post_params=form_params, 3500 files=local_var_files, 3501 response_type='file', 3502 auth_settings=auth_settings, 3503 callback=params.get('callback'), 3504 _return_http_data_only=params.get('_return_http_data_only'), 3505 _preload_content=params.get('_preload_content', True), 3506 _request_timeout=params.get('_request_timeout'), 3507 collection_formats=collection_formats) 3508 3509 def get_brand_resources(self, account_id, brand_id, **kwargs): 3510 """ 3511 Returns the specified account's list of branding resources (metadata). 3512 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**). 3513 This method makes a synchronous HTTP request by default. To make an 3514 asynchronous HTTP request, please define a `callback` function 3515 to be invoked when receiving the response. 3516 >>> def callback_function(response): 3517 >>> pprint(response) 3518 >>> 3519 >>> thread = api.get_brand_resources(account_id, brand_id, callback=callback_function) 3520 3521 :param callback function: The callback function 3522 for asynchronous request. (optional) 3523 :param str account_id: The external account number (int) or account ID Guid. (required) 3524 :param str brand_id: The unique identifier of a brand. (required) 3525 :return: BrandResourcesList 3526 If the method is called asynchronously, 3527 returns the request thread. 3528 """ 3529 kwargs['_return_http_data_only'] = True 3530 if kwargs.get('callback'): 3531 return self.get_brand_resources_with_http_info(account_id, brand_id, **kwargs) 3532 else: 3533 (data) = self.get_brand_resources_with_http_info(account_id, brand_id, **kwargs) 3534 return data 3535 3536 def get_brand_resources_with_http_info(self, account_id, brand_id, **kwargs): 3537 """ 3538 Returns the specified account's list of branding resources (metadata). 3539 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**). 3540 This method makes a synchronous HTTP request by default. To make an 3541 asynchronous HTTP request, please define a `callback` function 3542 to be invoked when receiving the response. 3543 >>> def callback_function(response): 3544 >>> pprint(response) 3545 >>> 3546 >>> thread = api.get_brand_resources_with_http_info(account_id, brand_id, callback=callback_function) 3547 3548 :param callback function: The callback function 3549 for asynchronous request. (optional) 3550 :param str account_id: The external account number (int) or account ID Guid. (required) 3551 :param str brand_id: The unique identifier of a brand. (required) 3552 :return: BrandResourcesList 3553 If the method is called asynchronously, 3554 returns the request thread. 3555 """ 3556 3557 all_params = ['account_id', 'brand_id'] 3558 all_params.append('callback') 3559 all_params.append('_return_http_data_only') 3560 all_params.append('_preload_content') 3561 all_params.append('_request_timeout') 3562 3563 params = locals() 3564 for key, val in iteritems(params['kwargs']): 3565 if key not in all_params: 3566 raise TypeError( 3567 "Got an unexpected keyword argument '%s'" 3568 " to method get_brand_resources" % key 3569 ) 3570 params[key] = val 3571 del params['kwargs'] 3572 # verify the required parameter 'account_id' is set 3573 if ('account_id' not in params) or (params['account_id'] is None): 3574 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_resources`") 3575 # verify the required parameter 'brand_id' is set 3576 if ('brand_id' not in params) or (params['brand_id'] is None): 3577 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_resources`") 3578 3579 3580 collection_formats = {} 3581 3582 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources'.replace('{format}', 'json') 3583 path_params = {} 3584 if 'account_id' in params: 3585 path_params['accountId'] = params['account_id'] 3586 if 'brand_id' in params: 3587 path_params['brandId'] = params['brand_id'] 3588 3589 query_params = {} 3590 3591 header_params = {} 3592 3593 form_params = [] 3594 local_var_files = {} 3595 3596 body_params = None 3597 # HTTP header `Accept` 3598 header_params['Accept'] = self.api_client.\ 3599 select_header_accept(['application/json']) 3600 3601 # Authentication setting 3602 auth_settings = [] 3603 3604 return self.api_client.call_api(resource_path, 'GET', 3605 path_params, 3606 query_params, 3607 header_params, 3608 body=body_params, 3609 post_params=form_params, 3610 files=local_var_files, 3611 response_type='BrandResourcesList', 3612 auth_settings=auth_settings, 3613 callback=params.get('callback'), 3614 _return_http_data_only=params.get('_return_http_data_only'), 3615 _preload_content=params.get('_preload_content', True), 3616 _request_timeout=params.get('_request_timeout'), 3617 collection_formats=collection_formats) 3618 3619 def get_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, **kwargs): 3620 """ 3621 Returns the specified branding resource file. 3622 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**). 3623 This method makes a synchronous HTTP request by default. To make an 3624 asynchronous HTTP request, please define a `callback` function 3625 to be invoked when receiving the response. 3626 >>> def callback_function(response): 3627 >>> pprint(response) 3628 >>> 3629 >>> thread = api.get_brand_resources_by_content_type(account_id, brand_id, resource_content_type, callback=callback_function) 3630 3631 :param callback function: The callback function 3632 for asynchronous request. (optional) 3633 :param str account_id: The external account number (int) or account ID Guid. (required) 3634 :param str brand_id: The unique identifier of a brand. (required) 3635 :param str resource_content_type: (required) 3636 :param str langcode: 3637 :param str return_master: 3638 :return: None 3639 If the method is called asynchronously, 3640 returns the request thread. 3641 """ 3642 kwargs['_return_http_data_only'] = True 3643 if kwargs.get('callback'): 3644 return self.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, **kwargs) 3645 else: 3646 (data) = self.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, **kwargs) 3647 return data 3648 3649 def get_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, **kwargs): 3650 """ 3651 Returns the specified branding resource file. 3652 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**). 3653 This method makes a synchronous HTTP request by default. To make an 3654 asynchronous HTTP request, please define a `callback` function 3655 to be invoked when receiving the response. 3656 >>> def callback_function(response): 3657 >>> pprint(response) 3658 >>> 3659 >>> thread = api.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, callback=callback_function) 3660 3661 :param callback function: The callback function 3662 for asynchronous request. (optional) 3663 :param str account_id: The external account number (int) or account ID Guid. (required) 3664 :param str brand_id: The unique identifier of a brand. (required) 3665 :param str resource_content_type: (required) 3666 :param str langcode: 3667 :param str return_master: 3668 :return: None 3669 If the method is called asynchronously, 3670 returns the request thread. 3671 """ 3672 3673 all_params = ['account_id', 'brand_id', 'resource_content_type', 'langcode', 'return_master'] 3674 all_params.append('callback') 3675 all_params.append('_return_http_data_only') 3676 all_params.append('_preload_content') 3677 all_params.append('_request_timeout') 3678 3679 params = locals() 3680 for key, val in iteritems(params['kwargs']): 3681 if key not in all_params: 3682 raise TypeError( 3683 "Got an unexpected keyword argument '%s'" 3684 " to method get_brand_resources_by_content_type" % key 3685 ) 3686 params[key] = val 3687 del params['kwargs'] 3688 # verify the required parameter 'account_id' is set 3689 if ('account_id' not in params) or (params['account_id'] is None): 3690 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_resources_by_content_type`") 3691 # verify the required parameter 'brand_id' is set 3692 if ('brand_id' not in params) or (params['brand_id'] is None): 3693 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_resources_by_content_type`") 3694 # verify the required parameter 'resource_content_type' is set 3695 if ('resource_content_type' not in params) or (params['resource_content_type'] is None): 3696 raise ValueError("Missing the required parameter `resource_content_type` when calling `get_brand_resources_by_content_type`") 3697 3698 3699 collection_formats = {} 3700 3701 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources/{resourceContentType}'.replace('{format}', 'json') 3702 path_params = {} 3703 if 'account_id' in params: 3704 path_params['accountId'] = params['account_id'] 3705 if 'brand_id' in params: 3706 path_params['brandId'] = params['brand_id'] 3707 if 'resource_content_type' in params: 3708 path_params['resourceContentType'] = params['resource_content_type'] 3709 3710 query_params = {} 3711 if 'langcode' in params: 3712 query_params['langcode'] = params['langcode'] 3713 if 'return_master' in params: 3714 query_params['return_master'] = params['return_master'] 3715 3716 header_params = {} 3717 3718 form_params = [] 3719 local_var_files = {} 3720 3721 body_params = None 3722 # HTTP header `Accept` 3723 header_params['Accept'] = self.api_client.\ 3724 select_header_accept(['application/json']) 3725 3726 # Authentication setting 3727 auth_settings = [] 3728 3729 return self.api_client.call_api(resource_path, 'GET', 3730 path_params, 3731 query_params, 3732 header_params, 3733 body=body_params, 3734 post_params=form_params, 3735 files=local_var_files, 3736 response_type=None, 3737 auth_settings=auth_settings, 3738 callback=params.get('callback'), 3739 _return_http_data_only=params.get('_return_http_data_only'), 3740 _preload_content=params.get('_preload_content', True), 3741 _request_timeout=params.get('_request_timeout'), 3742 collection_formats=collection_formats) 3743 3744 def get_consumer_disclosure(self, account_id, lang_code, **kwargs): 3745 """ 3746 Gets the Electronic Record and Signature Disclosure. 3747 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. 3748 This method makes a synchronous HTTP request by default. To make an 3749 asynchronous HTTP request, please define a `callback` function 3750 to be invoked when receiving the response. 3751 >>> def callback_function(response): 3752 >>> pprint(response) 3753 >>> 3754 >>> thread = api.get_consumer_disclosure(account_id, lang_code, callback=callback_function) 3755 3756 :param callback function: The callback function 3757 for asynchronous request. (optional) 3758 :param str account_id: The external account number (int) or account ID Guid. (required) 3759 :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) 3760 :return: ConsumerDisclosure 3761 If the method is called asynchronously, 3762 returns the request thread. 3763 """ 3764 kwargs['_return_http_data_only'] = True 3765 if kwargs.get('callback'): 3766 return self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 3767 else: 3768 (data) = self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 3769 return data 3770 3771 def get_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs): 3772 """ 3773 Gets the Electronic Record and Signature Disclosure. 3774 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. 3775 This method makes a synchronous HTTP request by default. To make an 3776 asynchronous HTTP request, please define a `callback` function 3777 to be invoked when receiving the response. 3778 >>> def callback_function(response): 3779 >>> pprint(response) 3780 >>> 3781 >>> thread = api.get_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function) 3782 3783 :param callback function: The callback function 3784 for asynchronous request. (optional) 3785 :param str account_id: The external account number (int) or account ID Guid. (required) 3786 :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) 3787 :return: ConsumerDisclosure 3788 If the method is called asynchronously, 3789 returns the request thread. 3790 """ 3791 3792 all_params = ['account_id', 'lang_code'] 3793 all_params.append('callback') 3794 all_params.append('_return_http_data_only') 3795 all_params.append('_preload_content') 3796 all_params.append('_request_timeout') 3797 3798 params = locals() 3799 for key, val in iteritems(params['kwargs']): 3800 if key not in all_params: 3801 raise TypeError( 3802 "Got an unexpected keyword argument '%s'" 3803 " to method get_consumer_disclosure" % key 3804 ) 3805 params[key] = val 3806 del params['kwargs'] 3807 # verify the required parameter 'account_id' is set 3808 if ('account_id' not in params) or (params['account_id'] is None): 3809 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure`") 3810 # verify the required parameter 'lang_code' is set 3811 if ('lang_code' not in params) or (params['lang_code'] is None): 3812 raise ValueError("Missing the required parameter `lang_code` when calling `get_consumer_disclosure`") 3813 3814 3815 collection_formats = {} 3816 3817 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 3818 path_params = {} 3819 if 'account_id' in params: 3820 path_params['accountId'] = params['account_id'] 3821 if 'lang_code' in params: 3822 path_params['langCode'] = params['lang_code'] 3823 3824 query_params = {} 3825 3826 header_params = {} 3827 3828 form_params = [] 3829 local_var_files = {} 3830 3831 body_params = None 3832 # HTTP header `Accept` 3833 header_params['Accept'] = self.api_client.\ 3834 select_header_accept(['application/json']) 3835 3836 # Authentication setting 3837 auth_settings = [] 3838 3839 return self.api_client.call_api(resource_path, 'GET', 3840 path_params, 3841 query_params, 3842 header_params, 3843 body=body_params, 3844 post_params=form_params, 3845 files=local_var_files, 3846 response_type='ConsumerDisclosure', 3847 auth_settings=auth_settings, 3848 callback=params.get('callback'), 3849 _return_http_data_only=params.get('_return_http_data_only'), 3850 _preload_content=params.get('_preload_content', True), 3851 _request_timeout=params.get('_request_timeout'), 3852 collection_formats=collection_formats) 3853 3854 def get_consumer_disclosure_default(self, account_id, **kwargs): 3855 """ 3856 Gets the Electronic Record and Signature Disclosure for the account. 3857 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. 3858 This method makes a synchronous HTTP request by default. To make an 3859 asynchronous HTTP request, please define a `callback` function 3860 to be invoked when receiving the response. 3861 >>> def callback_function(response): 3862 >>> pprint(response) 3863 >>> 3864 >>> thread = api.get_consumer_disclosure_default(account_id, callback=callback_function) 3865 3866 :param callback function: The callback function 3867 for asynchronous request. (optional) 3868 :param str account_id: The external account number (int) or account ID Guid. (required) 3869 :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. 3870 :return: ConsumerDisclosure 3871 If the method is called asynchronously, 3872 returns the request thread. 3873 """ 3874 kwargs['_return_http_data_only'] = True 3875 if kwargs.get('callback'): 3876 return self.get_consumer_disclosure_default_with_http_info(account_id, **kwargs) 3877 else: 3878 (data) = self.get_consumer_disclosure_default_with_http_info(account_id, **kwargs) 3879 return data 3880 3881 def get_consumer_disclosure_default_with_http_info(self, account_id, **kwargs): 3882 """ 3883 Gets the Electronic Record and Signature Disclosure for the account. 3884 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. 3885 This method makes a synchronous HTTP request by default. To make an 3886 asynchronous HTTP request, please define a `callback` function 3887 to be invoked when receiving the response. 3888 >>> def callback_function(response): 3889 >>> pprint(response) 3890 >>> 3891 >>> thread = api.get_consumer_disclosure_default_with_http_info(account_id, callback=callback_function) 3892 3893 :param callback function: The callback function 3894 for asynchronous request. (optional) 3895 :param str account_id: The external account number (int) or account ID Guid. (required) 3896 :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. 3897 :return: ConsumerDisclosure 3898 If the method is called asynchronously, 3899 returns the request thread. 3900 """ 3901 3902 all_params = ['account_id', 'lang_code'] 3903 all_params.append('callback') 3904 all_params.append('_return_http_data_only') 3905 all_params.append('_preload_content') 3906 all_params.append('_request_timeout') 3907 3908 params = locals() 3909 for key, val in iteritems(params['kwargs']): 3910 if key not in all_params: 3911 raise TypeError( 3912 "Got an unexpected keyword argument '%s'" 3913 " to method get_consumer_disclosure_default" % key 3914 ) 3915 params[key] = val 3916 del params['kwargs'] 3917 # verify the required parameter 'account_id' is set 3918 if ('account_id' not in params) or (params['account_id'] is None): 3919 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure_default`") 3920 3921 3922 collection_formats = {} 3923 3924 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure'.replace('{format}', 'json') 3925 path_params = {} 3926 if 'account_id' in params: 3927 path_params['accountId'] = params['account_id'] 3928 3929 query_params = {} 3930 if 'lang_code' in params: 3931 query_params['langCode'] = params['lang_code'] 3932 3933 header_params = {} 3934 3935 form_params = [] 3936 local_var_files = {} 3937 3938 body_params = None 3939 # HTTP header `Accept` 3940 header_params['Accept'] = self.api_client.\ 3941 select_header_accept(['application/json']) 3942 3943 # Authentication setting 3944 auth_settings = [] 3945 3946 return self.api_client.call_api(resource_path, 'GET', 3947 path_params, 3948 query_params, 3949 header_params, 3950 body=body_params, 3951 post_params=form_params, 3952 files=local_var_files, 3953 response_type='ConsumerDisclosure', 3954 auth_settings=auth_settings, 3955 callback=params.get('callback'), 3956 _return_http_data_only=params.get('_return_http_data_only'), 3957 _preload_content=params.get('_preload_content', True), 3958 _request_timeout=params.get('_request_timeout'), 3959 collection_formats=collection_formats) 3960 3961 def get_e_note_configuration(self, account_id, **kwargs): 3962 """ 3963 Returns the configuration information for the eNote eOriginal integration. 3964 3965 This method makes a synchronous HTTP request by default. To make an 3966 asynchronous HTTP request, please define a `callback` function 3967 to be invoked when receiving the response. 3968 >>> def callback_function(response): 3969 >>> pprint(response) 3970 >>> 3971 >>> thread = api.get_e_note_configuration(account_id, callback=callback_function) 3972 3973 :param callback function: The callback function 3974 for asynchronous request. (optional) 3975 :param str account_id: The external account number (int) or account ID Guid. (required) 3976 :return: ENoteConfiguration 3977 If the method is called asynchronously, 3978 returns the request thread. 3979 """ 3980 kwargs['_return_http_data_only'] = True 3981 if kwargs.get('callback'): 3982 return self.get_e_note_configuration_with_http_info(account_id, **kwargs) 3983 else: 3984 (data) = self.get_e_note_configuration_with_http_info(account_id, **kwargs) 3985 return data 3986 3987 def get_e_note_configuration_with_http_info(self, account_id, **kwargs): 3988 """ 3989 Returns the configuration information for the eNote eOriginal integration. 3990 3991 This method makes a synchronous HTTP request by default. To make an 3992 asynchronous HTTP request, please define a `callback` function 3993 to be invoked when receiving the response. 3994 >>> def callback_function(response): 3995 >>> pprint(response) 3996 >>> 3997 >>> thread = api.get_e_note_configuration_with_http_info(account_id, callback=callback_function) 3998 3999 :param callback function: The callback function 4000 for asynchronous request. (optional) 4001 :param str account_id: The external account number (int) or account ID Guid. (required) 4002 :return: ENoteConfiguration 4003 If the method is called asynchronously, 4004 returns the request thread. 4005 """ 4006 4007 all_params = ['account_id'] 4008 all_params.append('callback') 4009 all_params.append('_return_http_data_only') 4010 all_params.append('_preload_content') 4011 all_params.append('_request_timeout') 4012 4013 params = locals() 4014 for key, val in iteritems(params['kwargs']): 4015 if key not in all_params: 4016 raise TypeError( 4017 "Got an unexpected keyword argument '%s'" 4018 " to method get_e_note_configuration" % key 4019 ) 4020 params[key] = val 4021 del params['kwargs'] 4022 # verify the required parameter 'account_id' is set 4023 if ('account_id' not in params) or (params['account_id'] is None): 4024 raise ValueError("Missing the required parameter `account_id` when calling `get_e_note_configuration`") 4025 4026 4027 collection_formats = {} 4028 4029 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 4030 path_params = {} 4031 if 'account_id' in params: 4032 path_params['accountId'] = params['account_id'] 4033 4034 query_params = {} 4035 4036 header_params = {} 4037 4038 form_params = [] 4039 local_var_files = {} 4040 4041 body_params = None 4042 # HTTP header `Accept` 4043 header_params['Accept'] = self.api_client.\ 4044 select_header_accept(['application/json']) 4045 4046 # Authentication setting 4047 auth_settings = [] 4048 4049 return self.api_client.call_api(resource_path, 'GET', 4050 path_params, 4051 query_params, 4052 header_params, 4053 body=body_params, 4054 post_params=form_params, 4055 files=local_var_files, 4056 response_type='ENoteConfiguration', 4057 auth_settings=auth_settings, 4058 callback=params.get('callback'), 4059 _return_http_data_only=params.get('_return_http_data_only'), 4060 _preload_content=params.get('_preload_content', True), 4061 _request_timeout=params.get('_request_timeout'), 4062 collection_formats=collection_formats) 4063 4064 def get_envelope_purge_configuration(self, account_id, **kwargs): 4065 """ 4066 Select envelope purge configuration. 4067 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. 4068 This method makes a synchronous HTTP request by default. To make an 4069 asynchronous HTTP request, please define a `callback` function 4070 to be invoked when receiving the response. 4071 >>> def callback_function(response): 4072 >>> pprint(response) 4073 >>> 4074 >>> thread = api.get_envelope_purge_configuration(account_id, callback=callback_function) 4075 4076 :param callback function: The callback function 4077 for asynchronous request. (optional) 4078 :param str account_id: The external account number (int) or account ID Guid. (required) 4079 :return: EnvelopePurgeConfiguration 4080 If the method is called asynchronously, 4081 returns the request thread. 4082 """ 4083 kwargs['_return_http_data_only'] = True 4084 if kwargs.get('callback'): 4085 return self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs) 4086 else: 4087 (data) = self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs) 4088 return data 4089 4090 def get_envelope_purge_configuration_with_http_info(self, account_id, **kwargs): 4091 """ 4092 Select envelope purge configuration. 4093 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. 4094 This method makes a synchronous HTTP request by default. To make an 4095 asynchronous HTTP request, please define a `callback` function 4096 to be invoked when receiving the response. 4097 >>> def callback_function(response): 4098 >>> pprint(response) 4099 >>> 4100 >>> thread = api.get_envelope_purge_configuration_with_http_info(account_id, callback=callback_function) 4101 4102 :param callback function: The callback function 4103 for asynchronous request. (optional) 4104 :param str account_id: The external account number (int) or account ID Guid. (required) 4105 :return: EnvelopePurgeConfiguration 4106 If the method is called asynchronously, 4107 returns the request thread. 4108 """ 4109 4110 all_params = ['account_id'] 4111 all_params.append('callback') 4112 all_params.append('_return_http_data_only') 4113 all_params.append('_preload_content') 4114 all_params.append('_request_timeout') 4115 4116 params = locals() 4117 for key, val in iteritems(params['kwargs']): 4118 if key not in all_params: 4119 raise TypeError( 4120 "Got an unexpected keyword argument '%s'" 4121 " to method get_envelope_purge_configuration" % key 4122 ) 4123 params[key] = val 4124 del params['kwargs'] 4125 # verify the required parameter 'account_id' is set 4126 if ('account_id' not in params) or (params['account_id'] is None): 4127 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_purge_configuration`") 4128 4129 4130 collection_formats = {} 4131 4132 resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json') 4133 path_params = {} 4134 if 'account_id' in params: 4135 path_params['accountId'] = params['account_id'] 4136 4137 query_params = {} 4138 4139 header_params = {} 4140 4141 form_params = [] 4142 local_var_files = {} 4143 4144 body_params = None 4145 # HTTP header `Accept` 4146 header_params['Accept'] = self.api_client.\ 4147 select_header_accept(['application/json']) 4148 4149 # Authentication setting 4150 auth_settings = [] 4151 4152 return self.api_client.call_api(resource_path, 'GET', 4153 path_params, 4154 query_params, 4155 header_params, 4156 body=body_params, 4157 post_params=form_params, 4158 files=local_var_files, 4159 response_type='EnvelopePurgeConfiguration', 4160 auth_settings=auth_settings, 4161 callback=params.get('callback'), 4162 _return_http_data_only=params.get('_return_http_data_only'), 4163 _preload_content=params.get('_preload_content', True), 4164 _request_timeout=params.get('_request_timeout'), 4165 collection_formats=collection_formats) 4166 4167 def get_favorite_templates(self, account_id, **kwargs): 4168 """ 4169 Retrieves the list of favorited templates for this caller 4170 4171 This method makes a synchronous HTTP request by default. To make an 4172 asynchronous HTTP request, please define a `callback` function 4173 to be invoked when receiving the response. 4174 >>> def callback_function(response): 4175 >>> pprint(response) 4176 >>> 4177 >>> thread = api.get_favorite_templates(account_id, callback=callback_function) 4178 4179 :param callback function: The callback function 4180 for asynchronous request. (optional) 4181 :param str account_id: The external account number (int) or account ID Guid. (required) 4182 :return: FavoriteTemplatesInfo 4183 If the method is called asynchronously, 4184 returns the request thread. 4185 """ 4186 kwargs['_return_http_data_only'] = True 4187 if kwargs.get('callback'): 4188 return self.get_favorite_templates_with_http_info(account_id, **kwargs) 4189 else: 4190 (data) = self.get_favorite_templates_with_http_info(account_id, **kwargs) 4191 return data 4192 4193 def get_favorite_templates_with_http_info(self, account_id, **kwargs): 4194 """ 4195 Retrieves the list of favorited templates for this caller 4196 4197 This method makes a synchronous HTTP request by default. To make an 4198 asynchronous HTTP request, please define a `callback` function 4199 to be invoked when receiving the response. 4200 >>> def callback_function(response): 4201 >>> pprint(response) 4202 >>> 4203 >>> thread = api.get_favorite_templates_with_http_info(account_id, callback=callback_function) 4204 4205 :param callback function: The callback function 4206 for asynchronous request. (optional) 4207 :param str account_id: The external account number (int) or account ID Guid. (required) 4208 :return: FavoriteTemplatesInfo 4209 If the method is called asynchronously, 4210 returns the request thread. 4211 """ 4212 4213 all_params = ['account_id'] 4214 all_params.append('callback') 4215 all_params.append('_return_http_data_only') 4216 all_params.append('_preload_content') 4217 all_params.append('_request_timeout') 4218 4219 params = locals() 4220 for key, val in iteritems(params['kwargs']): 4221 if key not in all_params: 4222 raise TypeError( 4223 "Got an unexpected keyword argument '%s'" 4224 " to method get_favorite_templates" % key 4225 ) 4226 params[key] = val 4227 del params['kwargs'] 4228 # verify the required parameter 'account_id' is set 4229 if ('account_id' not in params) or (params['account_id'] is None): 4230 raise ValueError("Missing the required parameter `account_id` when calling `get_favorite_templates`") 4231 4232 4233 collection_formats = {} 4234 4235 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 4236 path_params = {} 4237 if 'account_id' in params: 4238 path_params['accountId'] = params['account_id'] 4239 4240 query_params = {} 4241 4242 header_params = {} 4243 4244 form_params = [] 4245 local_var_files = {} 4246 4247 body_params = None 4248 # HTTP header `Accept` 4249 header_params['Accept'] = self.api_client.\ 4250 select_header_accept(['application/json']) 4251 4252 # Authentication setting 4253 auth_settings = [] 4254 4255 return self.api_client.call_api(resource_path, 'GET', 4256 path_params, 4257 query_params, 4258 header_params, 4259 body=body_params, 4260 post_params=form_params, 4261 files=local_var_files, 4262 response_type='FavoriteTemplatesInfo', 4263 auth_settings=auth_settings, 4264 callback=params.get('callback'), 4265 _return_http_data_only=params.get('_return_http_data_only'), 4266 _preload_content=params.get('_preload_content', True), 4267 _request_timeout=params.get('_request_timeout'), 4268 collection_formats=collection_formats) 4269 4270 def get_notification_defaults(self, account_id, **kwargs): 4271 """ 4272 Returns default user level settings for a specified account 4273 This method returns the default settings for the email notifications that signers and senders receive about envelopes. 4274 This method makes a synchronous HTTP request by default. To make an 4275 asynchronous HTTP request, please define a `callback` function 4276 to be invoked when receiving the response. 4277 >>> def callback_function(response): 4278 >>> pprint(response) 4279 >>> 4280 >>> thread = api.get_notification_defaults(account_id, callback=callback_function) 4281 4282 :param callback function: The callback function 4283 for asynchronous request. (optional) 4284 :param str account_id: The external account number (int) or account ID Guid. (required) 4285 :return: NotificationDefaults 4286 If the method is called asynchronously, 4287 returns the request thread. 4288 """ 4289 kwargs['_return_http_data_only'] = True 4290 if kwargs.get('callback'): 4291 return self.get_notification_defaults_with_http_info(account_id, **kwargs) 4292 else: 4293 (data) = self.get_notification_defaults_with_http_info(account_id, **kwargs) 4294 return data 4295 4296 def get_notification_defaults_with_http_info(self, account_id, **kwargs): 4297 """ 4298 Returns default user level settings for a specified account 4299 This method returns the default settings for the email notifications that signers and senders receive about envelopes. 4300 This method makes a synchronous HTTP request by default. To make an 4301 asynchronous HTTP request, please define a `callback` function 4302 to be invoked when receiving the response. 4303 >>> def callback_function(response): 4304 >>> pprint(response) 4305 >>> 4306 >>> thread = api.get_notification_defaults_with_http_info(account_id, callback=callback_function) 4307 4308 :param callback function: The callback function 4309 for asynchronous request. (optional) 4310 :param str account_id: The external account number (int) or account ID Guid. (required) 4311 :return: NotificationDefaults 4312 If the method is called asynchronously, 4313 returns the request thread. 4314 """ 4315 4316 all_params = ['account_id'] 4317 all_params.append('callback') 4318 all_params.append('_return_http_data_only') 4319 all_params.append('_preload_content') 4320 all_params.append('_request_timeout') 4321 4322 params = locals() 4323 for key, val in iteritems(params['kwargs']): 4324 if key not in all_params: 4325 raise TypeError( 4326 "Got an unexpected keyword argument '%s'" 4327 " to method get_notification_defaults" % key 4328 ) 4329 params[key] = val 4330 del params['kwargs'] 4331 # verify the required parameter 'account_id' is set 4332 if ('account_id' not in params) or (params['account_id'] is None): 4333 raise ValueError("Missing the required parameter `account_id` when calling `get_notification_defaults`") 4334 4335 4336 collection_formats = {} 4337 4338 resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json') 4339 path_params = {} 4340 if 'account_id' in params: 4341 path_params['accountId'] = params['account_id'] 4342 4343 query_params = {} 4344 4345 header_params = {} 4346 4347 form_params = [] 4348 local_var_files = {} 4349 4350 body_params = None 4351 # HTTP header `Accept` 4352 header_params['Accept'] = self.api_client.\ 4353 select_header_accept(['application/json']) 4354 4355 # Authentication setting 4356 auth_settings = [] 4357 4358 return self.api_client.call_api(resource_path, 'GET', 4359 path_params, 4360 query_params, 4361 header_params, 4362 body=body_params, 4363 post_params=form_params, 4364 files=local_var_files, 4365 response_type='NotificationDefaults', 4366 auth_settings=auth_settings, 4367 callback=params.get('callback'), 4368 _return_http_data_only=params.get('_return_http_data_only'), 4369 _preload_content=params.get('_preload_content', True), 4370 _request_timeout=params.get('_request_timeout'), 4371 collection_formats=collection_formats) 4372 4373 def get_password_rules(self, account_id, **kwargs): 4374 """ 4375 Get the password rules 4376 This method retrieves the password rules for an account. 4377 This method makes a synchronous HTTP request by default. To make an 4378 asynchronous HTTP request, please define a `callback` function 4379 to be invoked when receiving the response. 4380 >>> def callback_function(response): 4381 >>> pprint(response) 4382 >>> 4383 >>> thread = api.get_password_rules(account_id, callback=callback_function) 4384 4385 :param callback function: The callback function 4386 for asynchronous request. (optional) 4387 :param str account_id: The external account number (int) or account ID Guid. (required) 4388 :return: AccountPasswordRules 4389 If the method is called asynchronously, 4390 returns the request thread. 4391 """ 4392 kwargs['_return_http_data_only'] = True 4393 if kwargs.get('callback'): 4394 return self.get_password_rules_with_http_info(account_id, **kwargs) 4395 else: 4396 (data) = self.get_password_rules_with_http_info(account_id, **kwargs) 4397 return data 4398 4399 def get_password_rules_with_http_info(self, account_id, **kwargs): 4400 """ 4401 Get the password rules 4402 This method retrieves the password rules for an account. 4403 This method makes a synchronous HTTP request by default. To make an 4404 asynchronous HTTP request, please define a `callback` function 4405 to be invoked when receiving the response. 4406 >>> def callback_function(response): 4407 >>> pprint(response) 4408 >>> 4409 >>> thread = api.get_password_rules_with_http_info(account_id, callback=callback_function) 4410 4411 :param callback function: The callback function 4412 for asynchronous request. (optional) 4413 :param str account_id: The external account number (int) or account ID Guid. (required) 4414 :return: AccountPasswordRules 4415 If the method is called asynchronously, 4416 returns the request thread. 4417 """ 4418 4419 all_params = ['account_id'] 4420 all_params.append('callback') 4421 all_params.append('_return_http_data_only') 4422 all_params.append('_preload_content') 4423 all_params.append('_request_timeout') 4424 4425 params = locals() 4426 for key, val in iteritems(params['kwargs']): 4427 if key not in all_params: 4428 raise TypeError( 4429 "Got an unexpected keyword argument '%s'" 4430 " to method get_password_rules" % key 4431 ) 4432 params[key] = val 4433 del params['kwargs'] 4434 # verify the required parameter 'account_id' is set 4435 if ('account_id' not in params) or (params['account_id'] is None): 4436 raise ValueError("Missing the required parameter `account_id` when calling `get_password_rules`") 4437 4438 4439 collection_formats = {} 4440 4441 resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json') 4442 path_params = {} 4443 if 'account_id' in params: 4444 path_params['accountId'] = params['account_id'] 4445 4446 query_params = {} 4447 4448 header_params = {} 4449 4450 form_params = [] 4451 local_var_files = {} 4452 4453 body_params = None 4454 # HTTP header `Accept` 4455 header_params['Accept'] = self.api_client.\ 4456 select_header_accept(['application/json']) 4457 4458 # Authentication setting 4459 auth_settings = [] 4460 4461 return self.api_client.call_api(resource_path, 'GET', 4462 path_params, 4463 query_params, 4464 header_params, 4465 body=body_params, 4466 post_params=form_params, 4467 files=local_var_files, 4468 response_type='AccountPasswordRules', 4469 auth_settings=auth_settings, 4470 callback=params.get('callback'), 4471 _return_http_data_only=params.get('_return_http_data_only'), 4472 _preload_content=params.get('_preload_content', True), 4473 _request_timeout=params.get('_request_timeout'), 4474 collection_formats=collection_formats) 4475 4476 def get_password_rules_0(self, **kwargs): 4477 """ 4478 Get membership account password rules 4479 4480 This method makes a synchronous HTTP request by default. To make an 4481 asynchronous HTTP request, please define a `callback` function 4482 to be invoked when receiving the response. 4483 >>> def callback_function(response): 4484 >>> pprint(response) 4485 >>> 4486 >>> thread = api.get_password_rules_0(callback=callback_function) 4487 4488 :param callback function: The callback function 4489 for asynchronous request. (optional) 4490 :return: UserPasswordRules 4491 If the method is called asynchronously, 4492 returns the request thread. 4493 """ 4494 kwargs['_return_http_data_only'] = True 4495 if kwargs.get('callback'): 4496 return self.get_password_rules_0_with_http_info(**kwargs) 4497 else: 4498 (data) = self.get_password_rules_0_with_http_info(**kwargs) 4499 return data 4500 4501 def get_password_rules_0_with_http_info(self, **kwargs): 4502 """ 4503 Get membership account password rules 4504 4505 This method makes a synchronous HTTP request by default. To make an 4506 asynchronous HTTP request, please define a `callback` function 4507 to be invoked when receiving the response. 4508 >>> def callback_function(response): 4509 >>> pprint(response) 4510 >>> 4511 >>> thread = api.get_password_rules_0_with_http_info(callback=callback_function) 4512 4513 :param callback function: The callback function 4514 for asynchronous request. (optional) 4515 :return: UserPasswordRules 4516 If the method is called asynchronously, 4517 returns the request thread. 4518 """ 4519 4520 all_params = [] 4521 all_params.append('callback') 4522 all_params.append('_return_http_data_only') 4523 all_params.append('_preload_content') 4524 all_params.append('_request_timeout') 4525 4526 params = locals() 4527 for key, val in iteritems(params['kwargs']): 4528 if key not in all_params: 4529 raise TypeError( 4530 "Got an unexpected keyword argument '%s'" 4531 " to method get_password_rules_0" % key 4532 ) 4533 params[key] = val 4534 del params['kwargs'] 4535 4536 collection_formats = {} 4537 4538 resource_path = '/v2.1/current_user/password_rules'.replace('{format}', 'json') 4539 path_params = {} 4540 4541 query_params = {} 4542 4543 header_params = {} 4544 4545 form_params = [] 4546 local_var_files = {} 4547 4548 body_params = None 4549 # HTTP header `Accept` 4550 header_params['Accept'] = self.api_client.\ 4551 select_header_accept(['application/json']) 4552 4553 # Authentication setting 4554 auth_settings = [] 4555 4556 return self.api_client.call_api(resource_path, 'GET', 4557 path_params, 4558 query_params, 4559 header_params, 4560 body=body_params, 4561 post_params=form_params, 4562 files=local_var_files, 4563 response_type='UserPasswordRules', 4564 auth_settings=auth_settings, 4565 callback=params.get('callback'), 4566 _return_http_data_only=params.get('_return_http_data_only'), 4567 _preload_content=params.get('_preload_content', True), 4568 _request_timeout=params.get('_request_timeout'), 4569 collection_formats=collection_formats) 4570 4571 def get_permission_profile(self, account_id, permission_profile_id, **kwargs): 4572 """ 4573 Returns a permissions profile in the specified account. 4574 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/) 4575 This method makes a synchronous HTTP request by default. To make an 4576 asynchronous HTTP request, please define a `callback` function 4577 to be invoked when receiving the response. 4578 >>> def callback_function(response): 4579 >>> pprint(response) 4580 >>> 4581 >>> thread = api.get_permission_profile(account_id, permission_profile_id, callback=callback_function) 4582 4583 :param callback function: The callback function 4584 for asynchronous request. (optional) 4585 :param str account_id: The external account number (int) or account ID Guid. (required) 4586 :param str permission_profile_id: (required) 4587 :param str include: 4588 :return: PermissionProfile 4589 If the method is called asynchronously, 4590 returns the request thread. 4591 """ 4592 kwargs['_return_http_data_only'] = True 4593 if kwargs.get('callback'): 4594 return self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 4595 else: 4596 (data) = self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 4597 return data 4598 4599 def get_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 4600 """ 4601 Returns a permissions profile in the specified account. 4602 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/) 4603 This method makes a synchronous HTTP request by default. To make an 4604 asynchronous HTTP request, please define a `callback` function 4605 to be invoked when receiving the response. 4606 >>> def callback_function(response): 4607 >>> pprint(response) 4608 >>> 4609 >>> thread = api.get_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 4610 4611 :param callback function: The callback function 4612 for asynchronous request. (optional) 4613 :param str account_id: The external account number (int) or account ID Guid. (required) 4614 :param str permission_profile_id: (required) 4615 :param str include: 4616 :return: PermissionProfile 4617 If the method is called asynchronously, 4618 returns the request thread. 4619 """ 4620 4621 all_params = ['account_id', 'permission_profile_id', 'include'] 4622 all_params.append('callback') 4623 all_params.append('_return_http_data_only') 4624 all_params.append('_preload_content') 4625 all_params.append('_request_timeout') 4626 4627 params = locals() 4628 for key, val in iteritems(params['kwargs']): 4629 if key not in all_params: 4630 raise TypeError( 4631 "Got an unexpected keyword argument '%s'" 4632 " to method get_permission_profile" % key 4633 ) 4634 params[key] = val 4635 del params['kwargs'] 4636 # verify the required parameter 'account_id' is set 4637 if ('account_id' not in params) or (params['account_id'] is None): 4638 raise ValueError("Missing the required parameter `account_id` when calling `get_permission_profile`") 4639 # verify the required parameter 'permission_profile_id' is set 4640 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 4641 raise ValueError("Missing the required parameter `permission_profile_id` when calling `get_permission_profile`") 4642 4643 4644 collection_formats = {} 4645 4646 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 4647 path_params = {} 4648 if 'account_id' in params: 4649 path_params['accountId'] = params['account_id'] 4650 if 'permission_profile_id' in params: 4651 path_params['permissionProfileId'] = params['permission_profile_id'] 4652 4653 query_params = {} 4654 if 'include' in params: 4655 query_params['include'] = params['include'] 4656 4657 header_params = {} 4658 4659 form_params = [] 4660 local_var_files = {} 4661 4662 body_params = None 4663 # HTTP header `Accept` 4664 header_params['Accept'] = self.api_client.\ 4665 select_header_accept(['application/json']) 4666 4667 # Authentication setting 4668 auth_settings = [] 4669 4670 return self.api_client.call_api(resource_path, 'GET', 4671 path_params, 4672 query_params, 4673 header_params, 4674 body=body_params, 4675 post_params=form_params, 4676 files=local_var_files, 4677 response_type='PermissionProfile', 4678 auth_settings=auth_settings, 4679 callback=params.get('callback'), 4680 _return_http_data_only=params.get('_return_http_data_only'), 4681 _preload_content=params.get('_preload_content', True), 4682 _request_timeout=params.get('_request_timeout'), 4683 collection_formats=collection_formats) 4684 4685 def get_principal_user_authorizations(self, account_id, user_id, **kwargs): 4686 """ 4687 Returns the principal user authorizations 4688 This method makes a synchronous HTTP request by default. To make an 4689 asynchronous HTTP request, please define a `callback` function 4690 to be invoked when receiving the response. 4691 >>> def callback_function(response): 4692 >>> pprint(response) 4693 >>> 4694 >>> thread = api.get_principal_user_authorizations(account_id, user_id, callback=callback_function) 4695 4696 :param callback function: The callback function 4697 for asynchronous request. (optional) 4698 :param str account_id: The external account number (int) or account ID Guid. (required) 4699 :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) 4700 :param str active_only: 4701 :param str count: 4702 :param str email_substring: Part (substring) of email we are searching for. 4703 :param str include_closed_users: 4704 :param str permissions: 4705 :param str start_position: 4706 :param str user_name_substring: 4707 :return: UserAuthorizations 4708 If the method is called asynchronously, 4709 returns the request thread. 4710 """ 4711 kwargs['_return_http_data_only'] = True 4712 if kwargs.get('callback'): 4713 return self.get_principal_user_authorizations_with_http_info(account_id, user_id, **kwargs) 4714 else: 4715 (data) = self.get_principal_user_authorizations_with_http_info(account_id, user_id, **kwargs) 4716 return data 4717 4718 def get_principal_user_authorizations_with_http_info(self, account_id, user_id, **kwargs): 4719 """ 4720 Returns the principal user authorizations 4721 This method makes a synchronous HTTP request by default. To make an 4722 asynchronous HTTP request, please define a `callback` function 4723 to be invoked when receiving the response. 4724 >>> def callback_function(response): 4725 >>> pprint(response) 4726 >>> 4727 >>> thread = api.get_principal_user_authorizations_with_http_info(account_id, user_id, callback=callback_function) 4728 4729 :param callback function: The callback function 4730 for asynchronous request. (optional) 4731 :param str account_id: The external account number (int) or account ID Guid. (required) 4732 :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) 4733 :param str active_only: 4734 :param str count: 4735 :param str email_substring: Part (substring) of email we are searching for. 4736 :param str include_closed_users: 4737 :param str permissions: 4738 :param str start_position: 4739 :param str user_name_substring: 4740 :return: UserAuthorizations 4741 If the method is called asynchronously, 4742 returns the request thread. 4743 """ 4744 4745 all_params = ['account_id', 'user_id', 'active_only', 'count', 'email_substring', 'include_closed_users', 'permissions', 'start_position', 'user_name_substring'] 4746 all_params.append('callback') 4747 all_params.append('_return_http_data_only') 4748 all_params.append('_preload_content') 4749 all_params.append('_request_timeout') 4750 4751 params = locals() 4752 for key, val in iteritems(params['kwargs']): 4753 if key not in all_params: 4754 raise TypeError( 4755 "Got an unexpected keyword argument '%s'" 4756 " to method get_principal_user_authorizations" % key 4757 ) 4758 params[key] = val 4759 del params['kwargs'] 4760 # verify the required parameter 'account_id' is set 4761 if ('account_id' not in params) or (params['account_id'] is None): 4762 raise ValueError("Missing the required parameter `account_id` when calling `get_principal_user_authorizations`") 4763 # verify the required parameter 'user_id' is set 4764 if ('user_id' not in params) or (params['user_id'] is None): 4765 raise ValueError("Missing the required parameter `user_id` when calling `get_principal_user_authorizations`") 4766 4767 4768 collection_formats = {} 4769 4770 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorizations'.replace('{format}', 'json') 4771 path_params = {} 4772 if 'account_id' in params: 4773 path_params['accountId'] = params['account_id'] 4774 if 'user_id' in params: 4775 path_params['userId'] = params['user_id'] 4776 4777 query_params = {} 4778 if 'active_only' in params: 4779 query_params['active_only'] = params['active_only'] 4780 if 'count' in params: 4781 query_params['count'] = params['count'] 4782 if 'email_substring' in params: 4783 query_params['email_substring'] = params['email_substring'] 4784 if 'include_closed_users' in params: 4785 query_params['include_closed_users'] = params['include_closed_users'] 4786 if 'permissions' in params: 4787 query_params['permissions'] = params['permissions'] 4788 if 'start_position' in params: 4789 query_params['start_position'] = params['start_position'] 4790 if 'user_name_substring' in params: 4791 query_params['user_name_substring'] = params['user_name_substring'] 4792 4793 header_params = {} 4794 4795 form_params = [] 4796 local_var_files = {} 4797 4798 body_params = None 4799 # HTTP header `Accept` 4800 header_params['Accept'] = self.api_client.\ 4801 select_header_accept(['application/json']) 4802 4803 # Authentication setting 4804 auth_settings = [] 4805 4806 return self.api_client.call_api(resource_path, 'GET', 4807 path_params, 4808 query_params, 4809 header_params, 4810 body=body_params, 4811 post_params=form_params, 4812 files=local_var_files, 4813 response_type='UserAuthorizations', 4814 auth_settings=auth_settings, 4815 callback=params.get('callback'), 4816 _return_http_data_only=params.get('_return_http_data_only'), 4817 _preload_content=params.get('_preload_content', True), 4818 _request_timeout=params.get('_request_timeout'), 4819 collection_formats=collection_formats) 4820 4821 def get_provisioning(self, **kwargs): 4822 """ 4823 Retrieves the account provisioning information for the account. 4824 Retrieves the account provisioning information for the account. 4825 This method makes a synchronous HTTP request by default. To make an 4826 asynchronous HTTP request, please define a `callback` function 4827 to be invoked when receiving the response. 4828 >>> def callback_function(response): 4829 >>> pprint(response) 4830 >>> 4831 >>> thread = api.get_provisioning(callback=callback_function) 4832 4833 :param callback function: The callback function 4834 for asynchronous request. (optional) 4835 :return: ProvisioningInformation 4836 If the method is called asynchronously, 4837 returns the request thread. 4838 """ 4839 kwargs['_return_http_data_only'] = True 4840 if kwargs.get('callback'): 4841 return self.get_provisioning_with_http_info(**kwargs) 4842 else: 4843 (data) = self.get_provisioning_with_http_info(**kwargs) 4844 return data 4845 4846 def get_provisioning_with_http_info(self, **kwargs): 4847 """ 4848 Retrieves the account provisioning information for the account. 4849 Retrieves the account provisioning information for the account. 4850 This method makes a synchronous HTTP request by default. To make an 4851 asynchronous HTTP request, please define a `callback` function 4852 to be invoked when receiving the response. 4853 >>> def callback_function(response): 4854 >>> pprint(response) 4855 >>> 4856 >>> thread = api.get_provisioning_with_http_info(callback=callback_function) 4857 4858 :param callback function: The callback function 4859 for asynchronous request. (optional) 4860 :return: ProvisioningInformation 4861 If the method is called asynchronously, 4862 returns the request thread. 4863 """ 4864 4865 all_params = [] 4866 all_params.append('callback') 4867 all_params.append('_return_http_data_only') 4868 all_params.append('_preload_content') 4869 all_params.append('_request_timeout') 4870 4871 params = locals() 4872 for key, val in iteritems(params['kwargs']): 4873 if key not in all_params: 4874 raise TypeError( 4875 "Got an unexpected keyword argument '%s'" 4876 " to method get_provisioning" % key 4877 ) 4878 params[key] = val 4879 del params['kwargs'] 4880 4881 collection_formats = {} 4882 4883 resource_path = '/v2.1/accounts/provisioning'.replace('{format}', 'json') 4884 path_params = {} 4885 4886 query_params = {} 4887 4888 header_params = {} 4889 4890 form_params = [] 4891 local_var_files = {} 4892 4893 body_params = None 4894 # HTTP header `Accept` 4895 header_params['Accept'] = self.api_client.\ 4896 select_header_accept(['application/json']) 4897 4898 # Authentication setting 4899 auth_settings = [] 4900 4901 return self.api_client.call_api(resource_path, 'GET', 4902 path_params, 4903 query_params, 4904 header_params, 4905 body=body_params, 4906 post_params=form_params, 4907 files=local_var_files, 4908 response_type='ProvisioningInformation', 4909 auth_settings=auth_settings, 4910 callback=params.get('callback'), 4911 _return_http_data_only=params.get('_return_http_data_only'), 4912 _preload_content=params.get('_preload_content', True), 4913 _request_timeout=params.get('_request_timeout'), 4914 collection_formats=collection_formats) 4915 4916 def get_supported_languages(self, account_id, **kwargs): 4917 """ 4918 Gets list of supported languages for recipient language setting. 4919 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). 4920 This method makes a synchronous HTTP request by default. To make an 4921 asynchronous HTTP request, please define a `callback` function 4922 to be invoked when receiving the response. 4923 >>> def callback_function(response): 4924 >>> pprint(response) 4925 >>> 4926 >>> thread = api.get_supported_languages(account_id, callback=callback_function) 4927 4928 :param callback function: The callback function 4929 for asynchronous request. (optional) 4930 :param str account_id: The external account number (int) or account ID Guid. (required) 4931 :return: SupportedLanguages 4932 If the method is called asynchronously, 4933 returns the request thread. 4934 """ 4935 kwargs['_return_http_data_only'] = True 4936 if kwargs.get('callback'): 4937 return self.get_supported_languages_with_http_info(account_id, **kwargs) 4938 else: 4939 (data) = self.get_supported_languages_with_http_info(account_id, **kwargs) 4940 return data 4941 4942 def get_supported_languages_with_http_info(self, account_id, **kwargs): 4943 """ 4944 Gets list of supported languages for recipient language setting. 4945 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). 4946 This method makes a synchronous HTTP request by default. To make an 4947 asynchronous HTTP request, please define a `callback` function 4948 to be invoked when receiving the response. 4949 >>> def callback_function(response): 4950 >>> pprint(response) 4951 >>> 4952 >>> thread = api.get_supported_languages_with_http_info(account_id, callback=callback_function) 4953 4954 :param callback function: The callback function 4955 for asynchronous request. (optional) 4956 :param str account_id: The external account number (int) or account ID Guid. (required) 4957 :return: SupportedLanguages 4958 If the method is called asynchronously, 4959 returns the request thread. 4960 """ 4961 4962 all_params = ['account_id'] 4963 all_params.append('callback') 4964 all_params.append('_return_http_data_only') 4965 all_params.append('_preload_content') 4966 all_params.append('_request_timeout') 4967 4968 params = locals() 4969 for key, val in iteritems(params['kwargs']): 4970 if key not in all_params: 4971 raise TypeError( 4972 "Got an unexpected keyword argument '%s'" 4973 " to method get_supported_languages" % key 4974 ) 4975 params[key] = val 4976 del params['kwargs'] 4977 # verify the required parameter 'account_id' is set 4978 if ('account_id' not in params) or (params['account_id'] is None): 4979 raise ValueError("Missing the required parameter `account_id` when calling `get_supported_languages`") 4980 4981 4982 collection_formats = {} 4983 4984 resource_path = '/v2.1/accounts/{accountId}/supported_languages'.replace('{format}', 'json') 4985 path_params = {} 4986 if 'account_id' in params: 4987 path_params['accountId'] = params['account_id'] 4988 4989 query_params = {} 4990 4991 header_params = {} 4992 4993 form_params = [] 4994 local_var_files = {} 4995 4996 body_params = None 4997 # HTTP header `Accept` 4998 header_params['Accept'] = self.api_client.\ 4999 select_header_accept(['application/json']) 5000 5001 # Authentication setting 5002 auth_settings = [] 5003 5004 return self.api_client.call_api(resource_path, 'GET', 5005 path_params, 5006 query_params, 5007 header_params, 5008 body=body_params, 5009 post_params=form_params, 5010 files=local_var_files, 5011 response_type='SupportedLanguages', 5012 auth_settings=auth_settings, 5013 callback=params.get('callback'), 5014 _return_http_data_only=params.get('_return_http_data_only'), 5015 _preload_content=params.get('_preload_content', True), 5016 _request_timeout=params.get('_request_timeout'), 5017 collection_formats=collection_formats) 5018 5019 def get_user_authorization(self, account_id, authorization_id, user_id, **kwargs): 5020 """ 5021 Returns the user authorization for a given authorization id 5022 This method makes a synchronous HTTP request by default. To make an 5023 asynchronous HTTP request, please define a `callback` function 5024 to be invoked when receiving the response. 5025 >>> def callback_function(response): 5026 >>> pprint(response) 5027 >>> 5028 >>> thread = api.get_user_authorization(account_id, authorization_id, user_id, callback=callback_function) 5029 5030 :param callback function: The callback function 5031 for asynchronous request. (optional) 5032 :param str account_id: The external account number (int) or account ID Guid. (required) 5033 :param str authorization_id: (required) 5034 :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) 5035 :return: UserAuthorization 5036 If the method is called asynchronously, 5037 returns the request thread. 5038 """ 5039 kwargs['_return_http_data_only'] = True 5040 if kwargs.get('callback'): 5041 return self.get_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 5042 else: 5043 (data) = self.get_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 5044 return data 5045 5046 def get_user_authorization_with_http_info(self, account_id, authorization_id, user_id, **kwargs): 5047 """ 5048 Returns the user authorization for a given authorization id 5049 This method makes a synchronous HTTP request by default. To make an 5050 asynchronous HTTP request, please define a `callback` function 5051 to be invoked when receiving the response. 5052 >>> def callback_function(response): 5053 >>> pprint(response) 5054 >>> 5055 >>> thread = api.get_user_authorization_with_http_info(account_id, authorization_id, user_id, callback=callback_function) 5056 5057 :param callback function: The callback function 5058 for asynchronous request. (optional) 5059 :param str account_id: The external account number (int) or account ID Guid. (required) 5060 :param str authorization_id: (required) 5061 :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) 5062 :return: UserAuthorization 5063 If the method is called asynchronously, 5064 returns the request thread. 5065 """ 5066 5067 all_params = ['account_id', 'authorization_id', 'user_id'] 5068 all_params.append('callback') 5069 all_params.append('_return_http_data_only') 5070 all_params.append('_preload_content') 5071 all_params.append('_request_timeout') 5072 5073 params = locals() 5074 for key, val in iteritems(params['kwargs']): 5075 if key not in all_params: 5076 raise TypeError( 5077 "Got an unexpected keyword argument '%s'" 5078 " to method get_user_authorization" % key 5079 ) 5080 params[key] = val 5081 del params['kwargs'] 5082 # verify the required parameter 'account_id' is set 5083 if ('account_id' not in params) or (params['account_id'] is None): 5084 raise ValueError("Missing the required parameter `account_id` when calling `get_user_authorization`") 5085 # verify the required parameter 'authorization_id' is set 5086 if ('authorization_id' not in params) or (params['authorization_id'] is None): 5087 raise ValueError("Missing the required parameter `authorization_id` when calling `get_user_authorization`") 5088 # verify the required parameter 'user_id' is set 5089 if ('user_id' not in params) or (params['user_id'] is None): 5090 raise ValueError("Missing the required parameter `user_id` when calling `get_user_authorization`") 5091 5092 5093 collection_formats = {} 5094 5095 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorization/{authorizationId}'.replace('{format}', 'json') 5096 path_params = {} 5097 if 'account_id' in params: 5098 path_params['accountId'] = params['account_id'] 5099 if 'authorization_id' in params: 5100 path_params['authorizationId'] = params['authorization_id'] 5101 if 'user_id' in params: 5102 path_params['userId'] = params['user_id'] 5103 5104 query_params = {} 5105 5106 header_params = {} 5107 5108 form_params = [] 5109 local_var_files = {} 5110 5111 body_params = None 5112 # HTTP header `Accept` 5113 header_params['Accept'] = self.api_client.\ 5114 select_header_accept(['application/json']) 5115 5116 # Authentication setting 5117 auth_settings = [] 5118 5119 return self.api_client.call_api(resource_path, 'GET', 5120 path_params, 5121 query_params, 5122 header_params, 5123 body=body_params, 5124 post_params=form_params, 5125 files=local_var_files, 5126 response_type='UserAuthorization', 5127 auth_settings=auth_settings, 5128 callback=params.get('callback'), 5129 _return_http_data_only=params.get('_return_http_data_only'), 5130 _preload_content=params.get('_preload_content', True), 5131 _request_timeout=params.get('_request_timeout'), 5132 collection_formats=collection_formats) 5133 5134 def get_watermark(self, account_id, **kwargs): 5135 """ 5136 Get watermark information. 5137 5138 This method makes a synchronous HTTP request by default. To make an 5139 asynchronous HTTP request, please define a `callback` function 5140 to be invoked when receiving the response. 5141 >>> def callback_function(response): 5142 >>> pprint(response) 5143 >>> 5144 >>> thread = api.get_watermark(account_id, callback=callback_function) 5145 5146 :param callback function: The callback function 5147 for asynchronous request. (optional) 5148 :param str account_id: The external account number (int) or account ID Guid. (required) 5149 :return: Watermark 5150 If the method is called asynchronously, 5151 returns the request thread. 5152 """ 5153 kwargs['_return_http_data_only'] = True 5154 if kwargs.get('callback'): 5155 return self.get_watermark_with_http_info(account_id, **kwargs) 5156 else: 5157 (data) = self.get_watermark_with_http_info(account_id, **kwargs) 5158 return data 5159 5160 def get_watermark_with_http_info(self, account_id, **kwargs): 5161 """ 5162 Get watermark information. 5163 5164 This method makes a synchronous HTTP request by default. To make an 5165 asynchronous HTTP request, please define a `callback` function 5166 to be invoked when receiving the response. 5167 >>> def callback_function(response): 5168 >>> pprint(response) 5169 >>> 5170 >>> thread = api.get_watermark_with_http_info(account_id, callback=callback_function) 5171 5172 :param callback function: The callback function 5173 for asynchronous request. (optional) 5174 :param str account_id: The external account number (int) or account ID Guid. (required) 5175 :return: Watermark 5176 If the method is called asynchronously, 5177 returns the request thread. 5178 """ 5179 5180 all_params = ['account_id'] 5181 all_params.append('callback') 5182 all_params.append('_return_http_data_only') 5183 all_params.append('_preload_content') 5184 all_params.append('_request_timeout') 5185 5186 params = locals() 5187 for key, val in iteritems(params['kwargs']): 5188 if key not in all_params: 5189 raise TypeError( 5190 "Got an unexpected keyword argument '%s'" 5191 " to method get_watermark" % key 5192 ) 5193 params[key] = val 5194 del params['kwargs'] 5195 # verify the required parameter 'account_id' is set 5196 if ('account_id' not in params) or (params['account_id'] is None): 5197 raise ValueError("Missing the required parameter `account_id` when calling `get_watermark`") 5198 5199 5200 collection_formats = {} 5201 5202 resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json') 5203 path_params = {} 5204 if 'account_id' in params: 5205 path_params['accountId'] = params['account_id'] 5206 5207 query_params = {} 5208 5209 header_params = {} 5210 5211 form_params = [] 5212 local_var_files = {} 5213 5214 body_params = None 5215 # HTTP header `Accept` 5216 header_params['Accept'] = self.api_client.\ 5217 select_header_accept(['application/json']) 5218 5219 # Authentication setting 5220 auth_settings = [] 5221 5222 return self.api_client.call_api(resource_path, 'GET', 5223 path_params, 5224 query_params, 5225 header_params, 5226 body=body_params, 5227 post_params=form_params, 5228 files=local_var_files, 5229 response_type='Watermark', 5230 auth_settings=auth_settings, 5231 callback=params.get('callback'), 5232 _return_http_data_only=params.get('_return_http_data_only'), 5233 _preload_content=params.get('_preload_content', True), 5234 _request_timeout=params.get('_request_timeout'), 5235 collection_formats=collection_formats) 5236 5237 def get_watermark_preview(self, account_id, **kwargs): 5238 """ 5239 Get watermark preview. 5240 5241 This method makes a synchronous HTTP request by default. To make an 5242 asynchronous HTTP request, please define a `callback` function 5243 to be invoked when receiving the response. 5244 >>> def callback_function(response): 5245 >>> pprint(response) 5246 >>> 5247 >>> thread = api.get_watermark_preview(account_id, callback=callback_function) 5248 5249 :param callback function: The callback function 5250 for asynchronous request. (optional) 5251 :param str account_id: The external account number (int) or account ID Guid. (required) 5252 :param Watermark watermark: 5253 :return: Watermark 5254 If the method is called asynchronously, 5255 returns the request thread. 5256 """ 5257 kwargs['_return_http_data_only'] = True 5258 if kwargs.get('callback'): 5259 return self.get_watermark_preview_with_http_info(account_id, **kwargs) 5260 else: 5261 (data) = self.get_watermark_preview_with_http_info(account_id, **kwargs) 5262 return data 5263 5264 def get_watermark_preview_with_http_info(self, account_id, **kwargs): 5265 """ 5266 Get watermark preview. 5267 5268 This method makes a synchronous HTTP request by default. To make an 5269 asynchronous HTTP request, please define a `callback` function 5270 to be invoked when receiving the response. 5271 >>> def callback_function(response): 5272 >>> pprint(response) 5273 >>> 5274 >>> thread = api.get_watermark_preview_with_http_info(account_id, callback=callback_function) 5275 5276 :param callback function: The callback function 5277 for asynchronous request. (optional) 5278 :param str account_id: The external account number (int) or account ID Guid. (required) 5279 :param Watermark watermark: 5280 :return: Watermark 5281 If the method is called asynchronously, 5282 returns the request thread. 5283 """ 5284 5285 all_params = ['account_id', 'watermark'] 5286 all_params.append('callback') 5287 all_params.append('_return_http_data_only') 5288 all_params.append('_preload_content') 5289 all_params.append('_request_timeout') 5290 5291 params = locals() 5292 for key, val in iteritems(params['kwargs']): 5293 if key not in all_params: 5294 raise TypeError( 5295 "Got an unexpected keyword argument '%s'" 5296 " to method get_watermark_preview" % key 5297 ) 5298 params[key] = val 5299 del params['kwargs'] 5300 # verify the required parameter 'account_id' is set 5301 if ('account_id' not in params) or (params['account_id'] is None): 5302 raise ValueError("Missing the required parameter `account_id` when calling `get_watermark_preview`") 5303 5304 5305 collection_formats = {} 5306 5307 resource_path = '/v2.1/accounts/{accountId}/watermark/preview'.replace('{format}', 'json') 5308 path_params = {} 5309 if 'account_id' in params: 5310 path_params['accountId'] = params['account_id'] 5311 5312 query_params = {} 5313 5314 header_params = {} 5315 5316 form_params = [] 5317 local_var_files = {} 5318 5319 body_params = None 5320 if 'watermark' in params: 5321 body_params = params['watermark'] 5322 # HTTP header `Accept` 5323 header_params['Accept'] = self.api_client.\ 5324 select_header_accept(['application/json']) 5325 5326 # Authentication setting 5327 auth_settings = [] 5328 5329 return self.api_client.call_api(resource_path, 'PUT', 5330 path_params, 5331 query_params, 5332 header_params, 5333 body=body_params, 5334 post_params=form_params, 5335 files=local_var_files, 5336 response_type='Watermark', 5337 auth_settings=auth_settings, 5338 callback=params.get('callback'), 5339 _return_http_data_only=params.get('_return_http_data_only'), 5340 _preload_content=params.get('_preload_content', True), 5341 _request_timeout=params.get('_request_timeout'), 5342 collection_formats=collection_formats) 5343 5344 def list_brands(self, account_id, **kwargs): 5345 """ 5346 Gets a list of brand profiles. 5347 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. 5348 This method makes a synchronous HTTP request by default. To make an 5349 asynchronous HTTP request, please define a `callback` function 5350 to be invoked when receiving the response. 5351 >>> def callback_function(response): 5352 >>> pprint(response) 5353 >>> 5354 >>> thread = api.list_brands(account_id, callback=callback_function) 5355 5356 :param callback function: The callback function 5357 for asynchronous request. (optional) 5358 :param str account_id: The external account number (int) or account ID Guid. (required) 5359 :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set. 5360 :param str include_logos: When set to **true**, returns the logos associated with the brand. 5361 :return: BrandsResponse 5362 If the method is called asynchronously, 5363 returns the request thread. 5364 """ 5365 kwargs['_return_http_data_only'] = True 5366 if kwargs.get('callback'): 5367 return self.list_brands_with_http_info(account_id, **kwargs) 5368 else: 5369 (data) = self.list_brands_with_http_info(account_id, **kwargs) 5370 return data 5371 5372 def list_brands_with_http_info(self, account_id, **kwargs): 5373 """ 5374 Gets a list of brand profiles. 5375 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. 5376 This method makes a synchronous HTTP request by default. To make an 5377 asynchronous HTTP request, please define a `callback` function 5378 to be invoked when receiving the response. 5379 >>> def callback_function(response): 5380 >>> pprint(response) 5381 >>> 5382 >>> thread = api.list_brands_with_http_info(account_id, callback=callback_function) 5383 5384 :param callback function: The callback function 5385 for asynchronous request. (optional) 5386 :param str account_id: The external account number (int) or account ID Guid. (required) 5387 :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set. 5388 :param str include_logos: When set to **true**, returns the logos associated with the brand. 5389 :return: BrandsResponse 5390 If the method is called asynchronously, 5391 returns the request thread. 5392 """ 5393 5394 all_params = ['account_id', 'exclude_distributor_brand', 'include_logos'] 5395 all_params.append('callback') 5396 all_params.append('_return_http_data_only') 5397 all_params.append('_preload_content') 5398 all_params.append('_request_timeout') 5399 5400 params = locals() 5401 for key, val in iteritems(params['kwargs']): 5402 if key not in all_params: 5403 raise TypeError( 5404 "Got an unexpected keyword argument '%s'" 5405 " to method list_brands" % key 5406 ) 5407 params[key] = val 5408 del params['kwargs'] 5409 # verify the required parameter 'account_id' is set 5410 if ('account_id' not in params) or (params['account_id'] is None): 5411 raise ValueError("Missing the required parameter `account_id` when calling `list_brands`") 5412 5413 5414 collection_formats = {} 5415 5416 resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json') 5417 path_params = {} 5418 if 'account_id' in params: 5419 path_params['accountId'] = params['account_id'] 5420 5421 query_params = {} 5422 if 'exclude_distributor_brand' in params: 5423 query_params['exclude_distributor_brand'] = params['exclude_distributor_brand'] 5424 if 'include_logos' in params: 5425 query_params['include_logos'] = params['include_logos'] 5426 5427 header_params = {} 5428 5429 form_params = [] 5430 local_var_files = {} 5431 5432 body_params = None 5433 # HTTP header `Accept` 5434 header_params['Accept'] = self.api_client.\ 5435 select_header_accept(['application/json']) 5436 5437 # Authentication setting 5438 auth_settings = [] 5439 5440 return self.api_client.call_api(resource_path, 'GET', 5441 path_params, 5442 query_params, 5443 header_params, 5444 body=body_params, 5445 post_params=form_params, 5446 files=local_var_files, 5447 response_type='BrandsResponse', 5448 auth_settings=auth_settings, 5449 callback=params.get('callback'), 5450 _return_http_data_only=params.get('_return_http_data_only'), 5451 _preload_content=params.get('_preload_content', True), 5452 _request_timeout=params.get('_request_timeout'), 5453 collection_formats=collection_formats) 5454 5455 def list_custom_fields(self, account_id, **kwargs): 5456 """ 5457 Gets a list of custom fields associated with the account. 5458 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. 5459 This method makes a synchronous HTTP request by default. To make an 5460 asynchronous HTTP request, please define a `callback` function 5461 to be invoked when receiving the response. 5462 >>> def callback_function(response): 5463 >>> pprint(response) 5464 >>> 5465 >>> thread = api.list_custom_fields(account_id, callback=callback_function) 5466 5467 :param callback function: The callback function 5468 for asynchronous request. (optional) 5469 :param str account_id: The external account number (int) or account ID Guid. (required) 5470 :return: CustomFields 5471 If the method is called asynchronously, 5472 returns the request thread. 5473 """ 5474 kwargs['_return_http_data_only'] = True 5475 if kwargs.get('callback'): 5476 return self.list_custom_fields_with_http_info(account_id, **kwargs) 5477 else: 5478 (data) = self.list_custom_fields_with_http_info(account_id, **kwargs) 5479 return data 5480 5481 def list_custom_fields_with_http_info(self, account_id, **kwargs): 5482 """ 5483 Gets a list of custom fields associated with the account. 5484 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. 5485 This method makes a synchronous HTTP request by default. To make an 5486 asynchronous HTTP request, please define a `callback` function 5487 to be invoked when receiving the response. 5488 >>> def callback_function(response): 5489 >>> pprint(response) 5490 >>> 5491 >>> thread = api.list_custom_fields_with_http_info(account_id, callback=callback_function) 5492 5493 :param callback function: The callback function 5494 for asynchronous request. (optional) 5495 :param str account_id: The external account number (int) or account ID Guid. (required) 5496 :return: CustomFields 5497 If the method is called asynchronously, 5498 returns the request thread. 5499 """ 5500 5501 all_params = ['account_id'] 5502 all_params.append('callback') 5503 all_params.append('_return_http_data_only') 5504 all_params.append('_preload_content') 5505 all_params.append('_request_timeout') 5506 5507 params = locals() 5508 for key, val in iteritems(params['kwargs']): 5509 if key not in all_params: 5510 raise TypeError( 5511 "Got an unexpected keyword argument '%s'" 5512 " to method list_custom_fields" % key 5513 ) 5514 params[key] = val 5515 del params['kwargs'] 5516 # verify the required parameter 'account_id' is set 5517 if ('account_id' not in params) or (params['account_id'] is None): 5518 raise ValueError("Missing the required parameter `account_id` when calling `list_custom_fields`") 5519 5520 5521 collection_formats = {} 5522 5523 resource_path = '/v2.1/accounts/{accountId}/custom_fields'.replace('{format}', 'json') 5524 path_params = {} 5525 if 'account_id' in params: 5526 path_params['accountId'] = params['account_id'] 5527 5528 query_params = {} 5529 5530 header_params = {} 5531 5532 form_params = [] 5533 local_var_files = {} 5534 5535 body_params = None 5536 # HTTP header `Accept` 5537 header_params['Accept'] = self.api_client.\ 5538 select_header_accept(['application/json']) 5539 5540 # Authentication setting 5541 auth_settings = [] 5542 5543 return self.api_client.call_api(resource_path, 'GET', 5544 path_params, 5545 query_params, 5546 header_params, 5547 body=body_params, 5548 post_params=form_params, 5549 files=local_var_files, 5550 response_type='CustomFields', 5551 auth_settings=auth_settings, 5552 callback=params.get('callback'), 5553 _return_http_data_only=params.get('_return_http_data_only'), 5554 _preload_content=params.get('_preload_content', True), 5555 _request_timeout=params.get('_request_timeout'), 5556 collection_formats=collection_formats) 5557 5558 def list_permissions(self, account_id, **kwargs): 5559 """ 5560 Gets a list of permission profiles. 5561 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. 5562 This method makes a synchronous HTTP request by default. To make an 5563 asynchronous HTTP request, please define a `callback` function 5564 to be invoked when receiving the response. 5565 >>> def callback_function(response): 5566 >>> pprint(response) 5567 >>> 5568 >>> thread = api.list_permissions(account_id, callback=callback_function) 5569 5570 :param callback function: The callback function 5571 for asynchronous request. (optional) 5572 :param str account_id: The external account number (int) or account ID Guid. (required) 5573 :param str include: 5574 :return: PermissionProfileInformation 5575 If the method is called asynchronously, 5576 returns the request thread. 5577 """ 5578 kwargs['_return_http_data_only'] = True 5579 if kwargs.get('callback'): 5580 return self.list_permissions_with_http_info(account_id, **kwargs) 5581 else: 5582 (data) = self.list_permissions_with_http_info(account_id, **kwargs) 5583 return data 5584 5585 def list_permissions_with_http_info(self, account_id, **kwargs): 5586 """ 5587 Gets a list of permission profiles. 5588 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. 5589 This method makes a synchronous HTTP request by default. To make an 5590 asynchronous HTTP request, please define a `callback` function 5591 to be invoked when receiving the response. 5592 >>> def callback_function(response): 5593 >>> pprint(response) 5594 >>> 5595 >>> thread = api.list_permissions_with_http_info(account_id, callback=callback_function) 5596 5597 :param callback function: The callback function 5598 for asynchronous request. (optional) 5599 :param str account_id: The external account number (int) or account ID Guid. (required) 5600 :param str include: 5601 :return: PermissionProfileInformation 5602 If the method is called asynchronously, 5603 returns the request thread. 5604 """ 5605 5606 all_params = ['account_id', 'include'] 5607 all_params.append('callback') 5608 all_params.append('_return_http_data_only') 5609 all_params.append('_preload_content') 5610 all_params.append('_request_timeout') 5611 5612 params = locals() 5613 for key, val in iteritems(params['kwargs']): 5614 if key not in all_params: 5615 raise TypeError( 5616 "Got an unexpected keyword argument '%s'" 5617 " to method list_permissions" % key 5618 ) 5619 params[key] = val 5620 del params['kwargs'] 5621 # verify the required parameter 'account_id' is set 5622 if ('account_id' not in params) or (params['account_id'] is None): 5623 raise ValueError("Missing the required parameter `account_id` when calling `list_permissions`") 5624 5625 5626 collection_formats = {} 5627 5628 resource_path = '/v2.1/accounts/{accountId}/permission_profiles'.replace('{format}', 'json') 5629 path_params = {} 5630 if 'account_id' in params: 5631 path_params['accountId'] = params['account_id'] 5632 5633 query_params = {} 5634 if 'include' in params: 5635 query_params['include'] = params['include'] 5636 5637 header_params = {} 5638 5639 form_params = [] 5640 local_var_files = {} 5641 5642 body_params = None 5643 # HTTP header `Accept` 5644 header_params['Accept'] = self.api_client.\ 5645 select_header_accept(['application/json']) 5646 5647 # Authentication setting 5648 auth_settings = [] 5649 5650 return self.api_client.call_api(resource_path, 'GET', 5651 path_params, 5652 query_params, 5653 header_params, 5654 body=body_params, 5655 post_params=form_params, 5656 files=local_var_files, 5657 response_type='PermissionProfileInformation', 5658 auth_settings=auth_settings, 5659 callback=params.get('callback'), 5660 _return_http_data_only=params.get('_return_http_data_only'), 5661 _preload_content=params.get('_preload_content', True), 5662 _request_timeout=params.get('_request_timeout'), 5663 collection_formats=collection_formats) 5664 5665 def list_recipient_names_by_email(self, account_id, **kwargs): 5666 """ 5667 Gets recipient names associated with an email address. 5668 Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string. 5669 This method makes a synchronous HTTP request by default. To make an 5670 asynchronous HTTP request, please define a `callback` function 5671 to be invoked when receiving the response. 5672 >>> def callback_function(response): 5673 >>> pprint(response) 5674 >>> 5675 >>> thread = api.list_recipient_names_by_email(account_id, callback=callback_function) 5676 5677 :param callback function: The callback function 5678 for asynchronous request. (optional) 5679 :param str account_id: The external account number (int) or account ID Guid. (required) 5680 :param str email: The email address for the user 5681 :return: RecipientNamesResponse 5682 If the method is called asynchronously, 5683 returns the request thread. 5684 """ 5685 kwargs['_return_http_data_only'] = True 5686 if kwargs.get('callback'): 5687 return self.list_recipient_names_by_email_with_http_info(account_id, **kwargs) 5688 else: 5689 (data) = self.list_recipient_names_by_email_with_http_info(account_id, **kwargs) 5690 return data 5691 5692 def list_recipient_names_by_email_with_http_info(self, account_id, **kwargs): 5693 """ 5694 Gets recipient names associated with an email address. 5695 Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string. 5696 This method makes a synchronous HTTP request by default. To make an 5697 asynchronous HTTP request, please define a `callback` function 5698 to be invoked when receiving the response. 5699 >>> def callback_function(response): 5700 >>> pprint(response) 5701 >>> 5702 >>> thread = api.list_recipient_names_by_email_with_http_info(account_id, callback=callback_function) 5703 5704 :param callback function: The callback function 5705 for asynchronous request. (optional) 5706 :param str account_id: The external account number (int) or account ID Guid. (required) 5707 :param str email: The email address for the user 5708 :return: RecipientNamesResponse 5709 If the method is called asynchronously, 5710 returns the request thread. 5711 """ 5712 5713 all_params = ['account_id', 'email'] 5714 all_params.append('callback') 5715 all_params.append('_return_http_data_only') 5716 all_params.append('_preload_content') 5717 all_params.append('_request_timeout') 5718 5719 params = locals() 5720 for key, val in iteritems(params['kwargs']): 5721 if key not in all_params: 5722 raise TypeError( 5723 "Got an unexpected keyword argument '%s'" 5724 " to method list_recipient_names_by_email" % key 5725 ) 5726 params[key] = val 5727 del params['kwargs'] 5728 # verify the required parameter 'account_id' is set 5729 if ('account_id' not in params) or (params['account_id'] is None): 5730 raise ValueError("Missing the required parameter `account_id` when calling `list_recipient_names_by_email`") 5731 5732 5733 collection_formats = {} 5734 5735 resource_path = '/v2.1/accounts/{accountId}/recipient_names'.replace('{format}', 'json') 5736 path_params = {} 5737 if 'account_id' in params: 5738 path_params['accountId'] = params['account_id'] 5739 5740 query_params = {} 5741 if 'email' in params: 5742 query_params['email'] = params['email'] 5743 5744 header_params = {} 5745 5746 form_params = [] 5747 local_var_files = {} 5748 5749 body_params = None 5750 # HTTP header `Accept` 5751 header_params['Accept'] = self.api_client.\ 5752 select_header_accept(['application/json']) 5753 5754 # Authentication setting 5755 auth_settings = [] 5756 5757 return self.api_client.call_api(resource_path, 'GET', 5758 path_params, 5759 query_params, 5760 header_params, 5761 body=body_params, 5762 post_params=form_params, 5763 files=local_var_files, 5764 response_type='RecipientNamesResponse', 5765 auth_settings=auth_settings, 5766 callback=params.get('callback'), 5767 _return_http_data_only=params.get('_return_http_data_only'), 5768 _preload_content=params.get('_preload_content', True), 5769 _request_timeout=params.get('_request_timeout'), 5770 collection_formats=collection_formats) 5771 5772 def list_settings(self, account_id, **kwargs): 5773 """ 5774 Gets account settings information. 5775 Retrieves the account settings information for the specified account. 5776 This method makes a synchronous HTTP request by default. To make an 5777 asynchronous HTTP request, please define a `callback` function 5778 to be invoked when receiving the response. 5779 >>> def callback_function(response): 5780 >>> pprint(response) 5781 >>> 5782 >>> thread = api.list_settings(account_id, callback=callback_function) 5783 5784 :param callback function: The callback function 5785 for asynchronous request. (optional) 5786 :param str account_id: The external account number (int) or account ID Guid. (required) 5787 :return: AccountSettingsInformation 5788 If the method is called asynchronously, 5789 returns the request thread. 5790 """ 5791 kwargs['_return_http_data_only'] = True 5792 if kwargs.get('callback'): 5793 return self.list_settings_with_http_info(account_id, **kwargs) 5794 else: 5795 (data) = self.list_settings_with_http_info(account_id, **kwargs) 5796 return data 5797 5798 def list_settings_with_http_info(self, account_id, **kwargs): 5799 """ 5800 Gets account settings information. 5801 Retrieves the account settings information for the specified account. 5802 This method makes a synchronous HTTP request by default. To make an 5803 asynchronous HTTP request, please define a `callback` function 5804 to be invoked when receiving the response. 5805 >>> def callback_function(response): 5806 >>> pprint(response) 5807 >>> 5808 >>> thread = api.list_settings_with_http_info(account_id, callback=callback_function) 5809 5810 :param callback function: The callback function 5811 for asynchronous request. (optional) 5812 :param str account_id: The external account number (int) or account ID Guid. (required) 5813 :return: AccountSettingsInformation 5814 If the method is called asynchronously, 5815 returns the request thread. 5816 """ 5817 5818 all_params = ['account_id'] 5819 all_params.append('callback') 5820 all_params.append('_return_http_data_only') 5821 all_params.append('_preload_content') 5822 all_params.append('_request_timeout') 5823 5824 params = locals() 5825 for key, val in iteritems(params['kwargs']): 5826 if key not in all_params: 5827 raise TypeError( 5828 "Got an unexpected keyword argument '%s'" 5829 " to method list_settings" % key 5830 ) 5831 params[key] = val 5832 del params['kwargs'] 5833 # verify the required parameter 'account_id' is set 5834 if ('account_id' not in params) or (params['account_id'] is None): 5835 raise ValueError("Missing the required parameter `account_id` when calling `list_settings`") 5836 5837 5838 collection_formats = {} 5839 5840 resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json') 5841 path_params = {} 5842 if 'account_id' in params: 5843 path_params['accountId'] = params['account_id'] 5844 5845 query_params = {} 5846 5847 header_params = {} 5848 5849 form_params = [] 5850 local_var_files = {} 5851 5852 body_params = None 5853 # HTTP header `Accept` 5854 header_params['Accept'] = self.api_client.\ 5855 select_header_accept(['application/json']) 5856 5857 # Authentication setting 5858 auth_settings = [] 5859 5860 return self.api_client.call_api(resource_path, 'GET', 5861 path_params, 5862 query_params, 5863 header_params, 5864 body=body_params, 5865 post_params=form_params, 5866 files=local_var_files, 5867 response_type='AccountSettingsInformation', 5868 auth_settings=auth_settings, 5869 callback=params.get('callback'), 5870 _return_http_data_only=params.get('_return_http_data_only'), 5871 _preload_content=params.get('_preload_content', True), 5872 _request_timeout=params.get('_request_timeout'), 5873 collection_formats=collection_formats) 5874 5875 def list_shared_access(self, account_id, **kwargs): 5876 """ 5877 Reserved: Gets the shared item status for one or more users. 5878 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. 5879 This method makes a synchronous HTTP request by default. To make an 5880 asynchronous HTTP request, please define a `callback` function 5881 to be invoked when receiving the response. 5882 >>> def callback_function(response): 5883 >>> pprint(response) 5884 >>> 5885 >>> thread = api.list_shared_access(account_id, callback=callback_function) 5886 5887 :param callback function: The callback function 5888 for asynchronous request. (optional) 5889 :param str account_id: The external account number (int) or account ID Guid. (required) 5890 :param str count: Specifies maximum number of results included in the response. If no value is specified, this defaults to 1000. 5891 :param str envelopes_not_shared_user_status: 5892 :param str folder_ids: 5893 :param str item_type: Specifies the type of shared item being requested. The accepted values are: -envelopes: returns information about envelope sharing between users. 5894 :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. 5895 :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 5896 :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. 5897 :param str user_ids: A comma separated list of userIds for whom the shared item information is being requested. 5898 :return: AccountSharedAccess 5899 If the method is called asynchronously, 5900 returns the request thread. 5901 """ 5902 kwargs['_return_http_data_only'] = True 5903 if kwargs.get('callback'): 5904 return self.list_shared_access_with_http_info(account_id, **kwargs) 5905 else: 5906 (data) = self.list_shared_access_with_http_info(account_id, **kwargs) 5907 return data 5908 5909 def list_shared_access_with_http_info(self, account_id, **kwargs): 5910 """ 5911 Reserved: Gets the shared item status for one or more users. 5912 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. 5913 This method makes a synchronous HTTP request by default. To make an 5914 asynchronous HTTP request, please define a `callback` function 5915 to be invoked when receiving the response. 5916 >>> def callback_function(response): 5917 >>> pprint(response) 5918 >>> 5919 >>> thread = api.list_shared_access_with_http_info(account_id, callback=callback_function) 5920 5921 :param callback function: The callback function 5922 for asynchronous request. (optional) 5923 :param str account_id: The external account number (int) or account ID Guid. (required) 5924 :param str count: Specifies maximum number of results included in the response. If no value is specified, this defaults to 1000. 5925 :param str envelopes_not_shared_user_status: 5926 :param str folder_ids: 5927 :param str item_type: Specifies the type of shared item being requested. The accepted values are: -envelopes: returns information about envelope sharing between users. 5928 :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. 5929 :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 5930 :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. 5931 :param str user_ids: A comma separated list of userIds for whom the shared item information is being requested. 5932 :return: AccountSharedAccess 5933 If the method is called asynchronously, 5934 returns the request thread. 5935 """ 5936 5937 all_params = ['account_id', 'count', 'envelopes_not_shared_user_status', 'folder_ids', 'item_type', 'search_text', 'shared', 'start_position', 'user_ids'] 5938 all_params.append('callback') 5939 all_params.append('_return_http_data_only') 5940 all_params.append('_preload_content') 5941 all_params.append('_request_timeout') 5942 5943 params = locals() 5944 for key, val in iteritems(params['kwargs']): 5945 if key not in all_params: 5946 raise TypeError( 5947 "Got an unexpected keyword argument '%s'" 5948 " to method list_shared_access" % key 5949 ) 5950 params[key] = val 5951 del params['kwargs'] 5952 # verify the required parameter 'account_id' is set 5953 if ('account_id' not in params) or (params['account_id'] is None): 5954 raise ValueError("Missing the required parameter `account_id` when calling `list_shared_access`") 5955 5956 5957 collection_formats = {} 5958 5959 resource_path = '/v2.1/accounts/{accountId}/shared_access'.replace('{format}', 'json') 5960 path_params = {} 5961 if 'account_id' in params: 5962 path_params['accountId'] = params['account_id'] 5963 5964 query_params = {} 5965 if 'count' in params: 5966 query_params['count'] = params['count'] 5967 if 'envelopes_not_shared_user_status' in params: 5968 query_params['envelopes_not_shared_user_status'] = params['envelopes_not_shared_user_status'] 5969 if 'folder_ids' in params: 5970 query_params['folder_ids'] = params['folder_ids'] 5971 if 'item_type' in params: 5972 query_params['item_type'] = params['item_type'] 5973 if 'search_text' in params: 5974 query_params['search_text'] = params['search_text'] 5975 if 'shared' in params: 5976 query_params['shared'] = params['shared'] 5977 if 'start_position' in params: 5978 query_params['start_position'] = params['start_position'] 5979 if 'user_ids' in params: 5980 query_params['user_ids'] = params['user_ids'] 5981 5982 header_params = {} 5983 5984 form_params = [] 5985 local_var_files = {} 5986 5987 body_params = None 5988 # HTTP header `Accept` 5989 header_params['Accept'] = self.api_client.\ 5990 select_header_accept(['application/json']) 5991 5992 # Authentication setting 5993 auth_settings = [] 5994 5995 return self.api_client.call_api(resource_path, 'GET', 5996 path_params, 5997 query_params, 5998 header_params, 5999 body=body_params, 6000 post_params=form_params, 6001 files=local_var_files, 6002 response_type='AccountSharedAccess', 6003 auth_settings=auth_settings, 6004 callback=params.get('callback'), 6005 _return_http_data_only=params.get('_return_http_data_only'), 6006 _preload_content=params.get('_preload_content', True), 6007 _request_timeout=params.get('_request_timeout'), 6008 collection_formats=collection_formats) 6009 6010 def list_signature_providers(self, account_id, **kwargs): 6011 """ 6012 Returns Account available signature providers for specified account. 6013 Returns a list of signature providers that the specified account can use. 6014 This method makes a synchronous HTTP request by default. To make an 6015 asynchronous HTTP request, please define a `callback` function 6016 to be invoked when receiving the response. 6017 >>> def callback_function(response): 6018 >>> pprint(response) 6019 >>> 6020 >>> thread = api.list_signature_providers(account_id, callback=callback_function) 6021 6022 :param callback function: The callback function 6023 for asynchronous request. (optional) 6024 :param str account_id: The external account number (int) or account ID Guid. (required) 6025 :return: AccountSignatureProviders 6026 If the method is called asynchronously, 6027 returns the request thread. 6028 """ 6029 kwargs['_return_http_data_only'] = True 6030 if kwargs.get('callback'): 6031 return self.list_signature_providers_with_http_info(account_id, **kwargs) 6032 else: 6033 (data) = self.list_signature_providers_with_http_info(account_id, **kwargs) 6034 return data 6035 6036 def list_signature_providers_with_http_info(self, account_id, **kwargs): 6037 """ 6038 Returns Account available signature providers for specified account. 6039 Returns a list of signature providers that the specified account can use. 6040 This method makes a synchronous HTTP request by default. To make an 6041 asynchronous HTTP request, please define a `callback` function 6042 to be invoked when receiving the response. 6043 >>> def callback_function(response): 6044 >>> pprint(response) 6045 >>> 6046 >>> thread = api.list_signature_providers_with_http_info(account_id, callback=callback_function) 6047 6048 :param callback function: The callback function 6049 for asynchronous request. (optional) 6050 :param str account_id: The external account number (int) or account ID Guid. (required) 6051 :return: AccountSignatureProviders 6052 If the method is called asynchronously, 6053 returns the request thread. 6054 """ 6055 6056 all_params = ['account_id'] 6057 all_params.append('callback') 6058 all_params.append('_return_http_data_only') 6059 all_params.append('_preload_content') 6060 all_params.append('_request_timeout') 6061 6062 params = locals() 6063 for key, val in iteritems(params['kwargs']): 6064 if key not in all_params: 6065 raise TypeError( 6066 "Got an unexpected keyword argument '%s'" 6067 " to method list_signature_providers" % key 6068 ) 6069 params[key] = val 6070 del params['kwargs'] 6071 # verify the required parameter 'account_id' is set 6072 if ('account_id' not in params) or (params['account_id'] is None): 6073 raise ValueError("Missing the required parameter `account_id` when calling `list_signature_providers`") 6074 6075 6076 collection_formats = {} 6077 6078 resource_path = '/v2.1/accounts/{accountId}/signatureProviders'.replace('{format}', 'json') 6079 path_params = {} 6080 if 'account_id' in params: 6081 path_params['accountId'] = params['account_id'] 6082 6083 query_params = {} 6084 6085 header_params = {} 6086 6087 form_params = [] 6088 local_var_files = {} 6089 6090 body_params = None 6091 # HTTP header `Accept` 6092 header_params['Accept'] = self.api_client.\ 6093 select_header_accept(['application/json']) 6094 6095 # Authentication setting 6096 auth_settings = [] 6097 6098 return self.api_client.call_api(resource_path, 'GET', 6099 path_params, 6100 query_params, 6101 header_params, 6102 body=body_params, 6103 post_params=form_params, 6104 files=local_var_files, 6105 response_type='AccountSignatureProviders', 6106 auth_settings=auth_settings, 6107 callback=params.get('callback'), 6108 _return_http_data_only=params.get('_return_http_data_only'), 6109 _preload_content=params.get('_preload_content', True), 6110 _request_timeout=params.get('_request_timeout'), 6111 collection_formats=collection_formats) 6112 6113 def list_unsupported_file_types(self, account_id, **kwargs): 6114 """ 6115 Gets a list of unsupported file types. 6116 Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system. 6117 This method makes a synchronous HTTP request by default. To make an 6118 asynchronous HTTP request, please define a `callback` function 6119 to be invoked when receiving the response. 6120 >>> def callback_function(response): 6121 >>> pprint(response) 6122 >>> 6123 >>> thread = api.list_unsupported_file_types(account_id, callback=callback_function) 6124 6125 :param callback function: The callback function 6126 for asynchronous request. (optional) 6127 :param str account_id: The external account number (int) or account ID Guid. (required) 6128 :return: FileTypeList 6129 If the method is called asynchronously, 6130 returns the request thread. 6131 """ 6132 kwargs['_return_http_data_only'] = True 6133 if kwargs.get('callback'): 6134 return self.list_unsupported_file_types_with_http_info(account_id, **kwargs) 6135 else: 6136 (data) = self.list_unsupported_file_types_with_http_info(account_id, **kwargs) 6137 return data 6138 6139 def list_unsupported_file_types_with_http_info(self, account_id, **kwargs): 6140 """ 6141 Gets a list of unsupported file types. 6142 Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system. 6143 This method makes a synchronous HTTP request by default. To make an 6144 asynchronous HTTP request, please define a `callback` function 6145 to be invoked when receiving the response. 6146 >>> def callback_function(response): 6147 >>> pprint(response) 6148 >>> 6149 >>> thread = api.list_unsupported_file_types_with_http_info(account_id, callback=callback_function) 6150 6151 :param callback function: The callback function 6152 for asynchronous request. (optional) 6153 :param str account_id: The external account number (int) or account ID Guid. (required) 6154 :return: FileTypeList 6155 If the method is called asynchronously, 6156 returns the request thread. 6157 """ 6158 6159 all_params = ['account_id'] 6160 all_params.append('callback') 6161 all_params.append('_return_http_data_only') 6162 all_params.append('_preload_content') 6163 all_params.append('_request_timeout') 6164 6165 params = locals() 6166 for key, val in iteritems(params['kwargs']): 6167 if key not in all_params: 6168 raise TypeError( 6169 "Got an unexpected keyword argument '%s'" 6170 " to method list_unsupported_file_types" % key 6171 ) 6172 params[key] = val 6173 del params['kwargs'] 6174 # verify the required parameter 'account_id' is set 6175 if ('account_id' not in params) or (params['account_id'] is None): 6176 raise ValueError("Missing the required parameter `account_id` when calling `list_unsupported_file_types`") 6177 6178 6179 collection_formats = {} 6180 6181 resource_path = '/v2.1/accounts/{accountId}/unsupported_file_types'.replace('{format}', 'json') 6182 path_params = {} 6183 if 'account_id' in params: 6184 path_params['accountId'] = params['account_id'] 6185 6186 query_params = {} 6187 6188 header_params = {} 6189 6190 form_params = [] 6191 local_var_files = {} 6192 6193 body_params = None 6194 # HTTP header `Accept` 6195 header_params['Accept'] = self.api_client.\ 6196 select_header_accept(['application/json']) 6197 6198 # Authentication setting 6199 auth_settings = [] 6200 6201 return self.api_client.call_api(resource_path, 'GET', 6202 path_params, 6203 query_params, 6204 header_params, 6205 body=body_params, 6206 post_params=form_params, 6207 files=local_var_files, 6208 response_type='FileTypeList', 6209 auth_settings=auth_settings, 6210 callback=params.get('callback'), 6211 _return_http_data_only=params.get('_return_http_data_only'), 6212 _preload_content=params.get('_preload_content', True), 6213 _request_timeout=params.get('_request_timeout'), 6214 collection_formats=collection_formats) 6215 6216 def un_favorite_template(self, account_id, **kwargs): 6217 """ 6218 Unfavorite a template 6219 6220 This method makes a synchronous HTTP request by default. To make an 6221 asynchronous HTTP request, please define a `callback` function 6222 to be invoked when receiving the response. 6223 >>> def callback_function(response): 6224 >>> pprint(response) 6225 >>> 6226 >>> thread = api.un_favorite_template(account_id, callback=callback_function) 6227 6228 :param callback function: The callback function 6229 for asynchronous request. (optional) 6230 :param str account_id: The external account number (int) or account ID Guid. (required) 6231 :param FavoriteTemplatesInfo favorite_templates_info: 6232 :return: FavoriteTemplatesInfo 6233 If the method is called asynchronously, 6234 returns the request thread. 6235 """ 6236 kwargs['_return_http_data_only'] = True 6237 if kwargs.get('callback'): 6238 return self.un_favorite_template_with_http_info(account_id, **kwargs) 6239 else: 6240 (data) = self.un_favorite_template_with_http_info(account_id, **kwargs) 6241 return data 6242 6243 def un_favorite_template_with_http_info(self, account_id, **kwargs): 6244 """ 6245 Unfavorite a template 6246 6247 This method makes a synchronous HTTP request by default. To make an 6248 asynchronous HTTP request, please define a `callback` function 6249 to be invoked when receiving the response. 6250 >>> def callback_function(response): 6251 >>> pprint(response) 6252 >>> 6253 >>> thread = api.un_favorite_template_with_http_info(account_id, callback=callback_function) 6254 6255 :param callback function: The callback function 6256 for asynchronous request. (optional) 6257 :param str account_id: The external account number (int) or account ID Guid. (required) 6258 :param FavoriteTemplatesInfo favorite_templates_info: 6259 :return: FavoriteTemplatesInfo 6260 If the method is called asynchronously, 6261 returns the request thread. 6262 """ 6263 6264 all_params = ['account_id', 'favorite_templates_info'] 6265 all_params.append('callback') 6266 all_params.append('_return_http_data_only') 6267 all_params.append('_preload_content') 6268 all_params.append('_request_timeout') 6269 6270 params = locals() 6271 for key, val in iteritems(params['kwargs']): 6272 if key not in all_params: 6273 raise TypeError( 6274 "Got an unexpected keyword argument '%s'" 6275 " to method un_favorite_template" % key 6276 ) 6277 params[key] = val 6278 del params['kwargs'] 6279 # verify the required parameter 'account_id' is set 6280 if ('account_id' not in params) or (params['account_id'] is None): 6281 raise ValueError("Missing the required parameter `account_id` when calling `un_favorite_template`") 6282 6283 6284 collection_formats = {} 6285 6286 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 6287 path_params = {} 6288 if 'account_id' in params: 6289 path_params['accountId'] = params['account_id'] 6290 6291 query_params = {} 6292 6293 header_params = {} 6294 6295 form_params = [] 6296 local_var_files = {} 6297 6298 body_params = None 6299 if 'favorite_templates_info' in params: 6300 body_params = params['favorite_templates_info'] 6301 # HTTP header `Accept` 6302 header_params['Accept'] = self.api_client.\ 6303 select_header_accept(['application/json']) 6304 6305 # Authentication setting 6306 auth_settings = [] 6307 6308 return self.api_client.call_api(resource_path, 'DELETE', 6309 path_params, 6310 query_params, 6311 header_params, 6312 body=body_params, 6313 post_params=form_params, 6314 files=local_var_files, 6315 response_type='FavoriteTemplatesInfo', 6316 auth_settings=auth_settings, 6317 callback=params.get('callback'), 6318 _return_http_data_only=params.get('_return_http_data_only'), 6319 _preload_content=params.get('_preload_content', True), 6320 _request_timeout=params.get('_request_timeout'), 6321 collection_formats=collection_formats) 6322 6323 def update_account_signature(self, account_id, **kwargs): 6324 """ 6325 Updates a account signature. 6326 6327 This method makes a synchronous HTTP request by default. To make an 6328 asynchronous HTTP request, please define a `callback` function 6329 to be invoked when receiving the response. 6330 >>> def callback_function(response): 6331 >>> pprint(response) 6332 >>> 6333 >>> thread = api.update_account_signature(account_id, callback=callback_function) 6334 6335 :param callback function: The callback function 6336 for asynchronous request. (optional) 6337 :param str account_id: The external account number (int) or account ID Guid. (required) 6338 :param AccountSignaturesInformation account_signatures_information: 6339 :return: AccountSignaturesInformation 6340 If the method is called asynchronously, 6341 returns the request thread. 6342 """ 6343 kwargs['_return_http_data_only'] = True 6344 if kwargs.get('callback'): 6345 return self.update_account_signature_with_http_info(account_id, **kwargs) 6346 else: 6347 (data) = self.update_account_signature_with_http_info(account_id, **kwargs) 6348 return data 6349 6350 def update_account_signature_with_http_info(self, account_id, **kwargs): 6351 """ 6352 Updates a account signature. 6353 6354 This method makes a synchronous HTTP request by default. To make an 6355 asynchronous HTTP request, please define a `callback` function 6356 to be invoked when receiving the response. 6357 >>> def callback_function(response): 6358 >>> pprint(response) 6359 >>> 6360 >>> thread = api.update_account_signature_with_http_info(account_id, callback=callback_function) 6361 6362 :param callback function: The callback function 6363 for asynchronous request. (optional) 6364 :param str account_id: The external account number (int) or account ID Guid. (required) 6365 :param AccountSignaturesInformation account_signatures_information: 6366 :return: AccountSignaturesInformation 6367 If the method is called asynchronously, 6368 returns the request thread. 6369 """ 6370 6371 all_params = ['account_id', 'account_signatures_information'] 6372 all_params.append('callback') 6373 all_params.append('_return_http_data_only') 6374 all_params.append('_preload_content') 6375 all_params.append('_request_timeout') 6376 6377 params = locals() 6378 for key, val in iteritems(params['kwargs']): 6379 if key not in all_params: 6380 raise TypeError( 6381 "Got an unexpected keyword argument '%s'" 6382 " to method update_account_signature" % key 6383 ) 6384 params[key] = val 6385 del params['kwargs'] 6386 # verify the required parameter 'account_id' is set 6387 if ('account_id' not in params) or (params['account_id'] is None): 6388 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature`") 6389 6390 6391 collection_formats = {} 6392 6393 resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json') 6394 path_params = {} 6395 if 'account_id' in params: 6396 path_params['accountId'] = params['account_id'] 6397 6398 query_params = {} 6399 6400 header_params = {} 6401 6402 form_params = [] 6403 local_var_files = {} 6404 6405 body_params = None 6406 if 'account_signatures_information' in params: 6407 body_params = params['account_signatures_information'] 6408 # HTTP header `Accept` 6409 header_params['Accept'] = self.api_client.\ 6410 select_header_accept(['application/json']) 6411 6412 # Authentication setting 6413 auth_settings = [] 6414 6415 return self.api_client.call_api(resource_path, 'PUT', 6416 path_params, 6417 query_params, 6418 header_params, 6419 body=body_params, 6420 post_params=form_params, 6421 files=local_var_files, 6422 response_type='AccountSignaturesInformation', 6423 auth_settings=auth_settings, 6424 callback=params.get('callback'), 6425 _return_http_data_only=params.get('_return_http_data_only'), 6426 _preload_content=params.get('_preload_content', True), 6427 _request_timeout=params.get('_request_timeout'), 6428 collection_formats=collection_formats) 6429 6430 def update_account_signature_by_id(self, account_id, signature_id, **kwargs): 6431 """ 6432 Updates a account signature. 6433 6434 This method makes a synchronous HTTP request by default. To make an 6435 asynchronous HTTP request, please define a `callback` function 6436 to be invoked when receiving the response. 6437 >>> def callback_function(response): 6438 >>> pprint(response) 6439 >>> 6440 >>> thread = api.update_account_signature_by_id(account_id, signature_id, callback=callback_function) 6441 6442 :param callback function: The callback function 6443 for asynchronous request. (optional) 6444 :param str account_id: The external account number (int) or account ID Guid. (required) 6445 :param str signature_id: The ID of the signature being accessed. (required) 6446 :param str close_existing_signature: 6447 :param AccountSignatureDefinition account_signature_definition: 6448 :return: AccountSignature 6449 If the method is called asynchronously, 6450 returns the request thread. 6451 """ 6452 kwargs['_return_http_data_only'] = True 6453 if kwargs.get('callback'): 6454 return self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs) 6455 else: 6456 (data) = self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs) 6457 return data 6458 6459 def update_account_signature_by_id_with_http_info(self, account_id, signature_id, **kwargs): 6460 """ 6461 Updates a account signature. 6462 6463 This method makes a synchronous HTTP request by default. To make an 6464 asynchronous HTTP request, please define a `callback` function 6465 to be invoked when receiving the response. 6466 >>> def callback_function(response): 6467 >>> pprint(response) 6468 >>> 6469 >>> thread = api.update_account_signature_by_id_with_http_info(account_id, signature_id, callback=callback_function) 6470 6471 :param callback function: The callback function 6472 for asynchronous request. (optional) 6473 :param str account_id: The external account number (int) or account ID Guid. (required) 6474 :param str signature_id: The ID of the signature being accessed. (required) 6475 :param str close_existing_signature: 6476 :param AccountSignatureDefinition account_signature_definition: 6477 :return: AccountSignature 6478 If the method is called asynchronously, 6479 returns the request thread. 6480 """ 6481 6482 all_params = ['account_id', 'signature_id', 'close_existing_signature', 'account_signature_definition'] 6483 all_params.append('callback') 6484 all_params.append('_return_http_data_only') 6485 all_params.append('_preload_content') 6486 all_params.append('_request_timeout') 6487 6488 params = locals() 6489 for key, val in iteritems(params['kwargs']): 6490 if key not in all_params: 6491 raise TypeError( 6492 "Got an unexpected keyword argument '%s'" 6493 " to method update_account_signature_by_id" % key 6494 ) 6495 params[key] = val 6496 del params['kwargs'] 6497 # verify the required parameter 'account_id' is set 6498 if ('account_id' not in params) or (params['account_id'] is None): 6499 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_by_id`") 6500 # verify the required parameter 'signature_id' is set 6501 if ('signature_id' not in params) or (params['signature_id'] is None): 6502 raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_by_id`") 6503 6504 6505 collection_formats = {} 6506 6507 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 6508 path_params = {} 6509 if 'account_id' in params: 6510 path_params['accountId'] = params['account_id'] 6511 if 'signature_id' in params: 6512 path_params['signatureId'] = params['signature_id'] 6513 6514 query_params = {} 6515 if 'close_existing_signature' in params: 6516 query_params['close_existing_signature'] = params['close_existing_signature'] 6517 6518 header_params = {} 6519 6520 form_params = [] 6521 local_var_files = {} 6522 6523 body_params = None 6524 if 'account_signature_definition' in params: 6525 body_params = params['account_signature_definition'] 6526 # HTTP header `Accept` 6527 header_params['Accept'] = self.api_client.\ 6528 select_header_accept(['application/json']) 6529 6530 # Authentication setting 6531 auth_settings = [] 6532 6533 return self.api_client.call_api(resource_path, 'PUT', 6534 path_params, 6535 query_params, 6536 header_params, 6537 body=body_params, 6538 post_params=form_params, 6539 files=local_var_files, 6540 response_type='AccountSignature', 6541 auth_settings=auth_settings, 6542 callback=params.get('callback'), 6543 _return_http_data_only=params.get('_return_http_data_only'), 6544 _preload_content=params.get('_preload_content', True), 6545 _request_timeout=params.get('_request_timeout'), 6546 collection_formats=collection_formats) 6547 6548 def update_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 6549 """ 6550 Sets a signature, initials, or stamps image. 6551 6552 This method makes a synchronous HTTP request by default. To make an 6553 asynchronous HTTP request, please define a `callback` function 6554 to be invoked when receiving the response. 6555 >>> def callback_function(response): 6556 >>> pprint(response) 6557 >>> 6558 >>> thread = api.update_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 6559 6560 :param callback function: The callback function 6561 for asynchronous request. (optional) 6562 :param str account_id: The external account number (int) or account ID Guid. (required) 6563 :param str image_type: One of **signature_image** or **initials_image**. (required) 6564 :param str signature_id: The ID of the signature being accessed. (required) 6565 :param str transparent_png: 6566 :return: AccountSignature 6567 If the method is called asynchronously, 6568 returns the request thread. 6569 """ 6570 kwargs['_return_http_data_only'] = True 6571 if kwargs.get('callback'): 6572 return self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 6573 else: 6574 (data) = self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 6575 return data 6576 6577 def update_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 6578 """ 6579 Sets a signature, initials, or stamps image. 6580 6581 This method makes a synchronous HTTP request by default. To make an 6582 asynchronous HTTP request, please define a `callback` function 6583 to be invoked when receiving the response. 6584 >>> def callback_function(response): 6585 >>> pprint(response) 6586 >>> 6587 >>> thread = api.update_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 6588 6589 :param callback function: The callback function 6590 for asynchronous request. (optional) 6591 :param str account_id: The external account number (int) or account ID Guid. (required) 6592 :param str image_type: One of **signature_image** or **initials_image**. (required) 6593 :param str signature_id: The ID of the signature being accessed. (required) 6594 :param str transparent_png: 6595 :return: AccountSignature 6596 If the method is called asynchronously, 6597 returns the request thread. 6598 """ 6599 6600 all_params = ['account_id', 'image_type', 'signature_id', 'transparent_png'] 6601 all_params.append('callback') 6602 all_params.append('_return_http_data_only') 6603 all_params.append('_preload_content') 6604 all_params.append('_request_timeout') 6605 6606 params = locals() 6607 for key, val in iteritems(params['kwargs']): 6608 if key not in all_params: 6609 raise TypeError( 6610 "Got an unexpected keyword argument '%s'" 6611 " to method update_account_signature_image" % key 6612 ) 6613 params[key] = val 6614 del params['kwargs'] 6615 # verify the required parameter 'account_id' is set 6616 if ('account_id' not in params) or (params['account_id'] is None): 6617 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_image`") 6618 # verify the required parameter 'image_type' is set 6619 if ('image_type' not in params) or (params['image_type'] is None): 6620 raise ValueError("Missing the required parameter `image_type` when calling `update_account_signature_image`") 6621 # verify the required parameter 'signature_id' is set 6622 if ('signature_id' not in params) or (params['signature_id'] is None): 6623 raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_image`") 6624 6625 6626 collection_formats = {} 6627 6628 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 6629 path_params = {} 6630 if 'account_id' in params: 6631 path_params['accountId'] = params['account_id'] 6632 if 'image_type' in params: 6633 path_params['imageType'] = params['image_type'] 6634 if 'signature_id' in params: 6635 path_params['signatureId'] = params['signature_id'] 6636 6637 query_params = {} 6638 if 'transparent_png' in params: 6639 query_params['transparent_png'] = params['transparent_png'] 6640 6641 header_params = {} 6642 6643 form_params = [] 6644 local_var_files = {} 6645 6646 body_params = None 6647 # HTTP header `Accept` 6648 header_params['Accept'] = self.api_client.\ 6649 select_header_accept(['application/json']) 6650 6651 # HTTP header `Content-Type` 6652 header_params['Content-Type'] = self.api_client.\ 6653 select_header_content_type(['image/gif']) 6654 6655 # Authentication setting 6656 auth_settings = [] 6657 6658 return self.api_client.call_api(resource_path, 'PUT', 6659 path_params, 6660 query_params, 6661 header_params, 6662 body=body_params, 6663 post_params=form_params, 6664 files=local_var_files, 6665 response_type='AccountSignature', 6666 auth_settings=auth_settings, 6667 callback=params.get('callback'), 6668 _return_http_data_only=params.get('_return_http_data_only'), 6669 _preload_content=params.get('_preload_content', True), 6670 _request_timeout=params.get('_request_timeout'), 6671 collection_formats=collection_formats) 6672 6673 def update_account_tab_settings(self, account_id, **kwargs): 6674 """ 6675 Modifies tab settings for specified account 6676 This method modifies the tab types and tab functionality that is enabled for an account. 6677 This method makes a synchronous HTTP request by default. To make an 6678 asynchronous HTTP request, please define a `callback` function 6679 to be invoked when receiving the response. 6680 >>> def callback_function(response): 6681 >>> pprint(response) 6682 >>> 6683 >>> thread = api.update_account_tab_settings(account_id, callback=callback_function) 6684 6685 :param callback function: The callback function 6686 for asynchronous request. (optional) 6687 :param str account_id: The external account number (int) or account ID Guid. (required) 6688 :param TabAccountSettings tab_account_settings: 6689 :return: TabAccountSettings 6690 If the method is called asynchronously, 6691 returns the request thread. 6692 """ 6693 kwargs['_return_http_data_only'] = True 6694 if kwargs.get('callback'): 6695 return self.update_account_tab_settings_with_http_info(account_id, **kwargs) 6696 else: 6697 (data) = self.update_account_tab_settings_with_http_info(account_id, **kwargs) 6698 return data 6699 6700 def update_account_tab_settings_with_http_info(self, account_id, **kwargs): 6701 """ 6702 Modifies tab settings for specified account 6703 This method modifies the tab types and tab functionality that is enabled for an account. 6704 This method makes a synchronous HTTP request by default. To make an 6705 asynchronous HTTP request, please define a `callback` function 6706 to be invoked when receiving the response. 6707 >>> def callback_function(response): 6708 >>> pprint(response) 6709 >>> 6710 >>> thread = api.update_account_tab_settings_with_http_info(account_id, callback=callback_function) 6711 6712 :param callback function: The callback function 6713 for asynchronous request. (optional) 6714 :param str account_id: The external account number (int) or account ID Guid. (required) 6715 :param TabAccountSettings tab_account_settings: 6716 :return: TabAccountSettings 6717 If the method is called asynchronously, 6718 returns the request thread. 6719 """ 6720 6721 all_params = ['account_id', 'tab_account_settings'] 6722 all_params.append('callback') 6723 all_params.append('_return_http_data_only') 6724 all_params.append('_preload_content') 6725 all_params.append('_request_timeout') 6726 6727 params = locals() 6728 for key, val in iteritems(params['kwargs']): 6729 if key not in all_params: 6730 raise TypeError( 6731 "Got an unexpected keyword argument '%s'" 6732 " to method update_account_tab_settings" % key 6733 ) 6734 params[key] = val 6735 del params['kwargs'] 6736 # verify the required parameter 'account_id' is set 6737 if ('account_id' not in params) or (params['account_id'] is None): 6738 raise ValueError("Missing the required parameter `account_id` when calling `update_account_tab_settings`") 6739 6740 6741 collection_formats = {} 6742 6743 resource_path = '/v2.1/accounts/{accountId}/settings/tabs'.replace('{format}', 'json') 6744 path_params = {} 6745 if 'account_id' in params: 6746 path_params['accountId'] = params['account_id'] 6747 6748 query_params = {} 6749 6750 header_params = {} 6751 6752 form_params = [] 6753 local_var_files = {} 6754 6755 body_params = None 6756 if 'tab_account_settings' in params: 6757 body_params = params['tab_account_settings'] 6758 # HTTP header `Accept` 6759 header_params['Accept'] = self.api_client.\ 6760 select_header_accept(['application/json']) 6761 6762 # Authentication setting 6763 auth_settings = [] 6764 6765 return self.api_client.call_api(resource_path, 'PUT', 6766 path_params, 6767 query_params, 6768 header_params, 6769 body=body_params, 6770 post_params=form_params, 6771 files=local_var_files, 6772 response_type='TabAccountSettings', 6773 auth_settings=auth_settings, 6774 callback=params.get('callback'), 6775 _return_http_data_only=params.get('_return_http_data_only'), 6776 _preload_content=params.get('_preload_content', True), 6777 _request_timeout=params.get('_request_timeout'), 6778 collection_formats=collection_formats) 6779 6780 def update_brand(self, account_id, brand_id, **kwargs): 6781 """ 6782 Updates an existing brand. 6783 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**). 6784 This method makes a synchronous HTTP request by default. To make an 6785 asynchronous HTTP request, please define a `callback` function 6786 to be invoked when receiving the response. 6787 >>> def callback_function(response): 6788 >>> pprint(response) 6789 >>> 6790 >>> thread = api.update_brand(account_id, brand_id, callback=callback_function) 6791 6792 :param callback function: The callback function 6793 for asynchronous request. (optional) 6794 :param str account_id: The external account number (int) or account ID Guid. (required) 6795 :param str brand_id: The unique identifier of a brand. (required) 6796 :param str replace_brand: 6797 :param Brand brand: 6798 :return: Brand 6799 If the method is called asynchronously, 6800 returns the request thread. 6801 """ 6802 kwargs['_return_http_data_only'] = True 6803 if kwargs.get('callback'): 6804 return self.update_brand_with_http_info(account_id, brand_id, **kwargs) 6805 else: 6806 (data) = self.update_brand_with_http_info(account_id, brand_id, **kwargs) 6807 return data 6808 6809 def update_brand_with_http_info(self, account_id, brand_id, **kwargs): 6810 """ 6811 Updates an existing brand. 6812 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**). 6813 This method makes a synchronous HTTP request by default. To make an 6814 asynchronous HTTP request, please define a `callback` function 6815 to be invoked when receiving the response. 6816 >>> def callback_function(response): 6817 >>> pprint(response) 6818 >>> 6819 >>> thread = api.update_brand_with_http_info(account_id, brand_id, callback=callback_function) 6820 6821 :param callback function: The callback function 6822 for asynchronous request. (optional) 6823 :param str account_id: The external account number (int) or account ID Guid. (required) 6824 :param str brand_id: The unique identifier of a brand. (required) 6825 :param str replace_brand: 6826 :param Brand brand: 6827 :return: Brand 6828 If the method is called asynchronously, 6829 returns the request thread. 6830 """ 6831 6832 all_params = ['account_id', 'brand_id', 'replace_brand', 'brand'] 6833 all_params.append('callback') 6834 all_params.append('_return_http_data_only') 6835 all_params.append('_preload_content') 6836 all_params.append('_request_timeout') 6837 6838 params = locals() 6839 for key, val in iteritems(params['kwargs']): 6840 if key not in all_params: 6841 raise TypeError( 6842 "Got an unexpected keyword argument '%s'" 6843 " to method update_brand" % key 6844 ) 6845 params[key] = val 6846 del params['kwargs'] 6847 # verify the required parameter 'account_id' is set 6848 if ('account_id' not in params) or (params['account_id'] is None): 6849 raise ValueError("Missing the required parameter `account_id` when calling `update_brand`") 6850 # verify the required parameter 'brand_id' is set 6851 if ('brand_id' not in params) or (params['brand_id'] is None): 6852 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand`") 6853 6854 6855 collection_formats = {} 6856 6857 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 6858 path_params = {} 6859 if 'account_id' in params: 6860 path_params['accountId'] = params['account_id'] 6861 if 'brand_id' in params: 6862 path_params['brandId'] = params['brand_id'] 6863 6864 query_params = {} 6865 if 'replace_brand' in params: 6866 query_params['replace_brand'] = params['replace_brand'] 6867 6868 header_params = {} 6869 6870 form_params = [] 6871 local_var_files = {} 6872 6873 body_params = None 6874 if 'brand' in params: 6875 body_params = params['brand'] 6876 # HTTP header `Accept` 6877 header_params['Accept'] = self.api_client.\ 6878 select_header_accept(['application/json']) 6879 6880 # Authentication setting 6881 auth_settings = [] 6882 6883 return self.api_client.call_api(resource_path, 'PUT', 6884 path_params, 6885 query_params, 6886 header_params, 6887 body=body_params, 6888 post_params=form_params, 6889 files=local_var_files, 6890 response_type='Brand', 6891 auth_settings=auth_settings, 6892 callback=params.get('callback'), 6893 _return_http_data_only=params.get('_return_http_data_only'), 6894 _preload_content=params.get('_preload_content', True), 6895 _request_timeout=params.get('_request_timeout'), 6896 collection_formats=collection_formats) 6897 6898 def update_brand_logo_by_type(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs): 6899 """ 6900 Put one branding logo. 6901 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**). 6902 This method makes a synchronous HTTP request by default. To make an 6903 asynchronous HTTP request, please define a `callback` function 6904 to be invoked when receiving the response. 6905 >>> def callback_function(response): 6906 >>> pprint(response) 6907 >>> 6908 >>> thread = api.update_brand_logo_by_type(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function) 6909 6910 :param callback function: The callback function 6911 for asynchronous request. (optional) 6912 :param str account_id: The external account number (int) or account ID GUID. (required) 6913 :param str brand_id: The ID of the brand. (required) 6914 :param str logo_type: The type of logo. Valid values are: - `primary` - `secondary` - `email` (required) 6915 :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) 6916 :return: None 6917 If the method is called asynchronously, 6918 returns the request thread. 6919 """ 6920 kwargs['_return_http_data_only'] = True 6921 if kwargs.get('callback'): 6922 return self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs) 6923 else: 6924 (data) = self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs) 6925 return data 6926 6927 def update_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs): 6928 """ 6929 Put one branding logo. 6930 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**). 6931 This method makes a synchronous HTTP request by default. To make an 6932 asynchronous HTTP request, please define a `callback` function 6933 to be invoked when receiving the response. 6934 >>> def callback_function(response): 6935 >>> pprint(response) 6936 >>> 6937 >>> thread = api.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function) 6938 6939 :param callback function: The callback function 6940 for asynchronous request. (optional) 6941 :param str account_id: The external account number (int) or account ID GUID. (required) 6942 :param str brand_id: The ID of the brand. (required) 6943 :param str logo_type: The type of logo. Valid values are: - `primary` - `secondary` - `email` (required) 6944 :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) 6945 :return: None 6946 If the method is called asynchronously, 6947 returns the request thread. 6948 """ 6949 6950 all_params = ['account_id', 'brand_id', 'logo_type', 'logo_file_bytes'] 6951 all_params.append('callback') 6952 all_params.append('_return_http_data_only') 6953 all_params.append('_preload_content') 6954 all_params.append('_request_timeout') 6955 6956 params = locals() 6957 for key, val in iteritems(params['kwargs']): 6958 if key not in all_params: 6959 raise TypeError( 6960 "Got an unexpected keyword argument '%s'" 6961 " to method update_brand_logo_by_type" % key 6962 ) 6963 params[key] = val 6964 del params['kwargs'] 6965 # verify the required parameter 'account_id' is set 6966 if ('account_id' not in params) or (params['account_id'] is None): 6967 raise ValueError("Missing the required parameter `account_id` when calling `update_brand_logo_by_type`") 6968 # verify the required parameter 'brand_id' is set 6969 if ('brand_id' not in params) or (params['brand_id'] is None): 6970 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_logo_by_type`") 6971 # verify the required parameter 'logo_type' is set 6972 if ('logo_type' not in params) or (params['logo_type'] is None): 6973 raise ValueError("Missing the required parameter `logo_type` when calling `update_brand_logo_by_type`") 6974 # verify the required parameter 'logo_file_bytes' is set 6975 if ('logo_file_bytes' not in params) or (params['logo_file_bytes'] is None): 6976 raise ValueError("Missing the required parameter `logo_file_bytes` when calling `update_brand_logo_by_type`") 6977 6978 6979 collection_formats = {} 6980 6981 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 6982 path_params = {} 6983 if 'account_id' in params: 6984 path_params['accountId'] = params['account_id'] 6985 if 'brand_id' in params: 6986 path_params['brandId'] = params['brand_id'] 6987 if 'logo_type' in params: 6988 path_params['logoType'] = params['logo_type'] 6989 6990 query_params = {} 6991 6992 header_params = {} 6993 6994 form_params = [] 6995 local_var_files = {} 6996 6997 body_params = None 6998 if 'logo_file_bytes' in params: 6999 body_params = params['logo_file_bytes'] 7000 # HTTP header `Accept` 7001 header_params['Accept'] = self.api_client.\ 7002 select_header_accept(['application/json']) 7003 7004 # HTTP header `Content-Type` 7005 header_params['Content-Type'] = self.api_client.\ 7006 select_header_content_type(['image/png']) 7007 7008 # Authentication setting 7009 auth_settings = [] 7010 7011 return self.api_client.call_api(resource_path, 'PUT', 7012 path_params, 7013 query_params, 7014 header_params, 7015 body=body_params, 7016 post_params=form_params, 7017 files=local_var_files, 7018 response_type=None, 7019 auth_settings=auth_settings, 7020 callback=params.get('callback'), 7021 _return_http_data_only=params.get('_return_http_data_only'), 7022 _preload_content=params.get('_preload_content', True), 7023 _request_timeout=params.get('_request_timeout'), 7024 collection_formats=collection_formats) 7025 7026 def update_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, file_xml, **kwargs): 7027 """ 7028 Uploads a branding resource file. 7029 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. 7030 This method makes a synchronous HTTP request by default. To make an 7031 asynchronous HTTP request, please define a `callback` function 7032 to be invoked when receiving the response. 7033 >>> def callback_function(response): 7034 >>> pprint(response) 7035 >>> 7036 >>> thread = api.update_brand_resources_by_content_type(account_id, brand_id, resource_content_type, file_xml, callback=callback_function) 7037 7038 :param callback function: The callback function 7039 for asynchronous request. (optional) 7040 :param str account_id: The external account number (int) or account ID GUID. (required) 7041 :param str brand_id: The ID of the brand. (required) 7042 :param str resource_content_type: The type of brand resource file that you are updating. Valid values are: - `sending` - `signing` - `email` - `signing_captive` (required) 7043 :param file file_xml: Brand resource XML file. (required) 7044 :return: BrandResources 7045 If the method is called asynchronously, 7046 returns the request thread. 7047 """ 7048 kwargs['_return_http_data_only'] = True 7049 if kwargs.get('callback'): 7050 return self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs) 7051 else: 7052 (data) = self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs) 7053 return data 7054 7055 def update_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, file_xml, **kwargs): 7056 """ 7057 Uploads a branding resource file. 7058 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. 7059 This method makes a synchronous HTTP request by default. To make an 7060 asynchronous HTTP request, please define a `callback` function 7061 to be invoked when receiving the response. 7062 >>> def callback_function(response): 7063 >>> pprint(response) 7064 >>> 7065 >>> thread = api.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, callback=callback_function) 7066 7067 :param callback function: The callback function 7068 for asynchronous request. (optional) 7069 :param str account_id: The external account number (int) or account ID GUID. (required) 7070 :param str brand_id: The ID of the brand. (required) 7071 :param str resource_content_type: The type of brand resource file that you are updating. Valid values are: - `sending` - `signing` - `email` - `signing_captive` (required) 7072 :param file file_xml: Brand resource XML file. (required) 7073 :return: BrandResources 7074 If the method is called asynchronously, 7075 returns the request thread. 7076 """ 7077 7078 all_params = ['account_id', 'brand_id', 'resource_content_type', 'file_xml'] 7079 all_params.append('callback') 7080 all_params.append('_return_http_data_only') 7081 all_params.append('_preload_content') 7082 all_params.append('_request_timeout') 7083 7084 params = locals() 7085 for key, val in iteritems(params['kwargs']): 7086 if key not in all_params: 7087 raise TypeError( 7088 "Got an unexpected keyword argument '%s'" 7089 " to method update_brand_resources_by_content_type" % key 7090 ) 7091 params[key] = val 7092 del params['kwargs'] 7093 # verify the required parameter 'account_id' is set 7094 if ('account_id' not in params) or (params['account_id'] is None): 7095 raise ValueError("Missing the required parameter `account_id` when calling `update_brand_resources_by_content_type`") 7096 # verify the required parameter 'brand_id' is set 7097 if ('brand_id' not in params) or (params['brand_id'] is None): 7098 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_resources_by_content_type`") 7099 # verify the required parameter 'resource_content_type' is set 7100 if ('resource_content_type' not in params) or (params['resource_content_type'] is None): 7101 raise ValueError("Missing the required parameter `resource_content_type` when calling `update_brand_resources_by_content_type`") 7102 # verify the required parameter 'file_xml' is set 7103 if ('file_xml' not in params) or (params['file_xml'] is None): 7104 raise ValueError("Missing the required parameter `file_xml` when calling `update_brand_resources_by_content_type`") 7105 7106 7107 collection_formats = {} 7108 7109 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources/{resourceContentType}'.replace('{format}', 'json') 7110 path_params = {} 7111 if 'account_id' in params: 7112 path_params['accountId'] = params['account_id'] 7113 if 'brand_id' in params: 7114 path_params['brandId'] = params['brand_id'] 7115 if 'resource_content_type' in params: 7116 path_params['resourceContentType'] = params['resource_content_type'] 7117 7118 query_params = {} 7119 7120 header_params = {} 7121 7122 form_params = [] 7123 local_var_files = {} 7124 if 'file_xml' in params: 7125 local_var_files['file.xml'] = params['file_xml'] 7126 7127 body_params = None 7128 # HTTP header `Accept` 7129 header_params['Accept'] = self.api_client.\ 7130 select_header_accept(['application/json']) 7131 7132 # HTTP header `Content-Type` 7133 header_params['Content-Type'] = self.api_client.\ 7134 select_header_content_type(['multipart/form-data']) 7135 7136 # Authentication setting 7137 auth_settings = [] 7138 7139 return self.api_client.call_api(resource_path, 'PUT', 7140 path_params, 7141 query_params, 7142 header_params, 7143 body=body_params, 7144 post_params=form_params, 7145 files=local_var_files, 7146 response_type='BrandResources', 7147 auth_settings=auth_settings, 7148 callback=params.get('callback'), 7149 _return_http_data_only=params.get('_return_http_data_only'), 7150 _preload_content=params.get('_preload_content', True), 7151 _request_timeout=params.get('_request_timeout'), 7152 collection_formats=collection_formats) 7153 7154 def update_consumer_disclosure(self, account_id, lang_code, **kwargs): 7155 """ 7156 Update Consumer Disclosure. 7157 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. 7158 This method makes a synchronous HTTP request by default. To make an 7159 asynchronous HTTP request, please define a `callback` function 7160 to be invoked when receiving the response. 7161 >>> def callback_function(response): 7162 >>> pprint(response) 7163 >>> 7164 >>> thread = api.update_consumer_disclosure(account_id, lang_code, callback=callback_function) 7165 7166 :param callback function: The callback function 7167 for asynchronous request. (optional) 7168 :param str account_id: The external account number (int) or account ID Guid. (required) 7169 :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) 7170 :param str include_metadata: 7171 :param ConsumerDisclosure consumer_disclosure: 7172 :return: ConsumerDisclosure 7173 If the method is called asynchronously, 7174 returns the request thread. 7175 """ 7176 kwargs['_return_http_data_only'] = True 7177 if kwargs.get('callback'): 7178 return self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 7179 else: 7180 (data) = self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 7181 return data 7182 7183 def update_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs): 7184 """ 7185 Update Consumer Disclosure. 7186 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. 7187 This method makes a synchronous HTTP request by default. To make an 7188 asynchronous HTTP request, please define a `callback` function 7189 to be invoked when receiving the response. 7190 >>> def callback_function(response): 7191 >>> pprint(response) 7192 >>> 7193 >>> thread = api.update_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function) 7194 7195 :param callback function: The callback function 7196 for asynchronous request. (optional) 7197 :param str account_id: The external account number (int) or account ID Guid. (required) 7198 :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) 7199 :param str include_metadata: 7200 :param ConsumerDisclosure consumer_disclosure: 7201 :return: ConsumerDisclosure 7202 If the method is called asynchronously, 7203 returns the request thread. 7204 """ 7205 7206 all_params = ['account_id', 'lang_code', 'include_metadata', 'consumer_disclosure'] 7207 all_params.append('callback') 7208 all_params.append('_return_http_data_only') 7209 all_params.append('_preload_content') 7210 all_params.append('_request_timeout') 7211 7212 params = locals() 7213 for key, val in iteritems(params['kwargs']): 7214 if key not in all_params: 7215 raise TypeError( 7216 "Got an unexpected keyword argument '%s'" 7217 " to method update_consumer_disclosure" % key 7218 ) 7219 params[key] = val 7220 del params['kwargs'] 7221 # verify the required parameter 'account_id' is set 7222 if ('account_id' not in params) or (params['account_id'] is None): 7223 raise ValueError("Missing the required parameter `account_id` when calling `update_consumer_disclosure`") 7224 # verify the required parameter 'lang_code' is set 7225 if ('lang_code' not in params) or (params['lang_code'] is None): 7226 raise ValueError("Missing the required parameter `lang_code` when calling `update_consumer_disclosure`") 7227 7228 7229 collection_formats = {} 7230 7231 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 7232 path_params = {} 7233 if 'account_id' in params: 7234 path_params['accountId'] = params['account_id'] 7235 if 'lang_code' in params: 7236 path_params['langCode'] = params['lang_code'] 7237 7238 query_params = {} 7239 if 'include_metadata' in params: 7240 query_params['include_metadata'] = params['include_metadata'] 7241 7242 header_params = {} 7243 7244 form_params = [] 7245 local_var_files = {} 7246 7247 body_params = None 7248 if 'consumer_disclosure' in params: 7249 body_params = params['consumer_disclosure'] 7250 # HTTP header `Accept` 7251 header_params['Accept'] = self.api_client.\ 7252 select_header_accept(['application/json']) 7253 7254 # Authentication setting 7255 auth_settings = [] 7256 7257 return self.api_client.call_api(resource_path, 'PUT', 7258 path_params, 7259 query_params, 7260 header_params, 7261 body=body_params, 7262 post_params=form_params, 7263 files=local_var_files, 7264 response_type='ConsumerDisclosure', 7265 auth_settings=auth_settings, 7266 callback=params.get('callback'), 7267 _return_http_data_only=params.get('_return_http_data_only'), 7268 _preload_content=params.get('_preload_content', True), 7269 _request_timeout=params.get('_request_timeout'), 7270 collection_formats=collection_formats) 7271 7272 def update_custom_field(self, account_id, custom_field_id, **kwargs): 7273 """ 7274 Updates an existing account custom field. 7275 This method updates an existing account custom field. 7276 This method makes a synchronous HTTP request by default. To make an 7277 asynchronous HTTP request, please define a `callback` function 7278 to be invoked when receiving the response. 7279 >>> def callback_function(response): 7280 >>> pprint(response) 7281 >>> 7282 >>> thread = api.update_custom_field(account_id, custom_field_id, callback=callback_function) 7283 7284 :param callback function: The callback function 7285 for asynchronous request. (optional) 7286 :param str account_id: The external account number (int) or account ID Guid. (required) 7287 :param str custom_field_id: (required) 7288 :param str apply_to_templates: 7289 :param CustomField custom_field: 7290 :return: CustomFields 7291 If the method is called asynchronously, 7292 returns the request thread. 7293 """ 7294 kwargs['_return_http_data_only'] = True 7295 if kwargs.get('callback'): 7296 return self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 7297 else: 7298 (data) = self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 7299 return data 7300 7301 def update_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs): 7302 """ 7303 Updates an existing account custom field. 7304 This method updates an existing account custom field. 7305 This method makes a synchronous HTTP request by default. To make an 7306 asynchronous HTTP request, please define a `callback` function 7307 to be invoked when receiving the response. 7308 >>> def callback_function(response): 7309 >>> pprint(response) 7310 >>> 7311 >>> thread = api.update_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function) 7312 7313 :param callback function: The callback function 7314 for asynchronous request. (optional) 7315 :param str account_id: The external account number (int) or account ID Guid. (required) 7316 :param str custom_field_id: (required) 7317 :param str apply_to_templates: 7318 :param CustomField custom_field: 7319 :return: CustomFields 7320 If the method is called asynchronously, 7321 returns the request thread. 7322 """ 7323 7324 all_params = ['account_id', 'custom_field_id', 'apply_to_templates', 'custom_field'] 7325 all_params.append('callback') 7326 all_params.append('_return_http_data_only') 7327 all_params.append('_preload_content') 7328 all_params.append('_request_timeout') 7329 7330 params = locals() 7331 for key, val in iteritems(params['kwargs']): 7332 if key not in all_params: 7333 raise TypeError( 7334 "Got an unexpected keyword argument '%s'" 7335 " to method update_custom_field" % key 7336 ) 7337 params[key] = val 7338 del params['kwargs'] 7339 # verify the required parameter 'account_id' is set 7340 if ('account_id' not in params) or (params['account_id'] is None): 7341 raise ValueError("Missing the required parameter `account_id` when calling `update_custom_field`") 7342 # verify the required parameter 'custom_field_id' is set 7343 if ('custom_field_id' not in params) or (params['custom_field_id'] is None): 7344 raise ValueError("Missing the required parameter `custom_field_id` when calling `update_custom_field`") 7345 7346 7347 collection_formats = {} 7348 7349 resource_path = '/v2.1/accounts/{accountId}/custom_fields/{customFieldId}'.replace('{format}', 'json') 7350 path_params = {} 7351 if 'account_id' in params: 7352 path_params['accountId'] = params['account_id'] 7353 if 'custom_field_id' in params: 7354 path_params['customFieldId'] = params['custom_field_id'] 7355 7356 query_params = {} 7357 if 'apply_to_templates' in params: 7358 query_params['apply_to_templates'] = params['apply_to_templates'] 7359 7360 header_params = {} 7361 7362 form_params = [] 7363 local_var_files = {} 7364 7365 body_params = None 7366 if 'custom_field' in params: 7367 body_params = params['custom_field'] 7368 # HTTP header `Accept` 7369 header_params['Accept'] = self.api_client.\ 7370 select_header_accept(['application/json']) 7371 7372 # Authentication setting 7373 auth_settings = [] 7374 7375 return self.api_client.call_api(resource_path, 'PUT', 7376 path_params, 7377 query_params, 7378 header_params, 7379 body=body_params, 7380 post_params=form_params, 7381 files=local_var_files, 7382 response_type='CustomFields', 7383 auth_settings=auth_settings, 7384 callback=params.get('callback'), 7385 _return_http_data_only=params.get('_return_http_data_only'), 7386 _preload_content=params.get('_preload_content', True), 7387 _request_timeout=params.get('_request_timeout'), 7388 collection_formats=collection_formats) 7389 7390 def update_e_note_configuration(self, account_id, **kwargs): 7391 """ 7392 Updates configuration information for the eNote eOriginal integration. 7393 7394 This method makes a synchronous HTTP request by default. To make an 7395 asynchronous HTTP request, please define a `callback` function 7396 to be invoked when receiving the response. 7397 >>> def callback_function(response): 7398 >>> pprint(response) 7399 >>> 7400 >>> thread = api.update_e_note_configuration(account_id, callback=callback_function) 7401 7402 :param callback function: The callback function 7403 for asynchronous request. (optional) 7404 :param str account_id: The external account number (int) or account ID Guid. (required) 7405 :param ENoteConfiguration e_note_configuration: 7406 :return: ENoteConfiguration 7407 If the method is called asynchronously, 7408 returns the request thread. 7409 """ 7410 kwargs['_return_http_data_only'] = True 7411 if kwargs.get('callback'): 7412 return self.update_e_note_configuration_with_http_info(account_id, **kwargs) 7413 else: 7414 (data) = self.update_e_note_configuration_with_http_info(account_id, **kwargs) 7415 return data 7416 7417 def update_e_note_configuration_with_http_info(self, account_id, **kwargs): 7418 """ 7419 Updates configuration information for the eNote eOriginal integration. 7420 7421 This method makes a synchronous HTTP request by default. To make an 7422 asynchronous HTTP request, please define a `callback` function 7423 to be invoked when receiving the response. 7424 >>> def callback_function(response): 7425 >>> pprint(response) 7426 >>> 7427 >>> thread = api.update_e_note_configuration_with_http_info(account_id, callback=callback_function) 7428 7429 :param callback function: The callback function 7430 for asynchronous request. (optional) 7431 :param str account_id: The external account number (int) or account ID Guid. (required) 7432 :param ENoteConfiguration e_note_configuration: 7433 :return: ENoteConfiguration 7434 If the method is called asynchronously, 7435 returns the request thread. 7436 """ 7437 7438 all_params = ['account_id', 'e_note_configuration'] 7439 all_params.append('callback') 7440 all_params.append('_return_http_data_only') 7441 all_params.append('_preload_content') 7442 all_params.append('_request_timeout') 7443 7444 params = locals() 7445 for key, val in iteritems(params['kwargs']): 7446 if key not in all_params: 7447 raise TypeError( 7448 "Got an unexpected keyword argument '%s'" 7449 " to method update_e_note_configuration" % key 7450 ) 7451 params[key] = val 7452 del params['kwargs'] 7453 # verify the required parameter 'account_id' is set 7454 if ('account_id' not in params) or (params['account_id'] is None): 7455 raise ValueError("Missing the required parameter `account_id` when calling `update_e_note_configuration`") 7456 7457 7458 collection_formats = {} 7459 7460 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 7461 path_params = {} 7462 if 'account_id' in params: 7463 path_params['accountId'] = params['account_id'] 7464 7465 query_params = {} 7466 7467 header_params = {} 7468 7469 form_params = [] 7470 local_var_files = {} 7471 7472 body_params = None 7473 if 'e_note_configuration' in params: 7474 body_params = params['e_note_configuration'] 7475 # HTTP header `Accept` 7476 header_params['Accept'] = self.api_client.\ 7477 select_header_accept(['application/json']) 7478 7479 # Authentication setting 7480 auth_settings = [] 7481 7482 return self.api_client.call_api(resource_path, 'PUT', 7483 path_params, 7484 query_params, 7485 header_params, 7486 body=body_params, 7487 post_params=form_params, 7488 files=local_var_files, 7489 response_type='ENoteConfiguration', 7490 auth_settings=auth_settings, 7491 callback=params.get('callback'), 7492 _return_http_data_only=params.get('_return_http_data_only'), 7493 _preload_content=params.get('_preload_content', True), 7494 _request_timeout=params.get('_request_timeout'), 7495 collection_formats=collection_formats) 7496 7497 def update_envelope_purge_configuration(self, account_id, **kwargs): 7498 """ 7499 Updates envelope purge configuration. 7500 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). 7501 This method makes a synchronous HTTP request by default. To make an 7502 asynchronous HTTP request, please define a `callback` function 7503 to be invoked when receiving the response. 7504 >>> def callback_function(response): 7505 >>> pprint(response) 7506 >>> 7507 >>> thread = api.update_envelope_purge_configuration(account_id, callback=callback_function) 7508 7509 :param callback function: The callback function 7510 for asynchronous request. (optional) 7511 :param str account_id: The external account number (int) or account ID Guid. (required) 7512 :param EnvelopePurgeConfiguration envelope_purge_configuration: 7513 :return: EnvelopePurgeConfiguration 7514 If the method is called asynchronously, 7515 returns the request thread. 7516 """ 7517 kwargs['_return_http_data_only'] = True 7518 if kwargs.get('callback'): 7519 return self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs) 7520 else: 7521 (data) = self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs) 7522 return data 7523 7524 def update_envelope_purge_configuration_with_http_info(self, account_id, **kwargs): 7525 """ 7526 Updates envelope purge configuration. 7527 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). 7528 This method makes a synchronous HTTP request by default. To make an 7529 asynchronous HTTP request, please define a `callback` function 7530 to be invoked when receiving the response. 7531 >>> def callback_function(response): 7532 >>> pprint(response) 7533 >>> 7534 >>> thread = api.update_envelope_purge_configuration_with_http_info(account_id, callback=callback_function) 7535 7536 :param callback function: The callback function 7537 for asynchronous request. (optional) 7538 :param str account_id: The external account number (int) or account ID Guid. (required) 7539 :param EnvelopePurgeConfiguration envelope_purge_configuration: 7540 :return: EnvelopePurgeConfiguration 7541 If the method is called asynchronously, 7542 returns the request thread. 7543 """ 7544 7545 all_params = ['account_id', 'envelope_purge_configuration'] 7546 all_params.append('callback') 7547 all_params.append('_return_http_data_only') 7548 all_params.append('_preload_content') 7549 all_params.append('_request_timeout') 7550 7551 params = locals() 7552 for key, val in iteritems(params['kwargs']): 7553 if key not in all_params: 7554 raise TypeError( 7555 "Got an unexpected keyword argument '%s'" 7556 " to method update_envelope_purge_configuration" % key 7557 ) 7558 params[key] = val 7559 del params['kwargs'] 7560 # verify the required parameter 'account_id' is set 7561 if ('account_id' not in params) or (params['account_id'] is None): 7562 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_purge_configuration`") 7563 7564 7565 collection_formats = {} 7566 7567 resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json') 7568 path_params = {} 7569 if 'account_id' in params: 7570 path_params['accountId'] = params['account_id'] 7571 7572 query_params = {} 7573 7574 header_params = {} 7575 7576 form_params = [] 7577 local_var_files = {} 7578 7579 body_params = None 7580 if 'envelope_purge_configuration' in params: 7581 body_params = params['envelope_purge_configuration'] 7582 # HTTP header `Accept` 7583 header_params['Accept'] = self.api_client.\ 7584 select_header_accept(['application/json']) 7585 7586 # Authentication setting 7587 auth_settings = [] 7588 7589 return self.api_client.call_api(resource_path, 'PUT', 7590 path_params, 7591 query_params, 7592 header_params, 7593 body=body_params, 7594 post_params=form_params, 7595 files=local_var_files, 7596 response_type='EnvelopePurgeConfiguration', 7597 auth_settings=auth_settings, 7598 callback=params.get('callback'), 7599 _return_http_data_only=params.get('_return_http_data_only'), 7600 _preload_content=params.get('_preload_content', True), 7601 _request_timeout=params.get('_request_timeout'), 7602 collection_formats=collection_formats) 7603 7604 def update_favorite_template(self, account_id, **kwargs): 7605 """ 7606 Favorites a template 7607 7608 This method makes a synchronous HTTP request by default. To make an 7609 asynchronous HTTP request, please define a `callback` function 7610 to be invoked when receiving the response. 7611 >>> def callback_function(response): 7612 >>> pprint(response) 7613 >>> 7614 >>> thread = api.update_favorite_template(account_id, callback=callback_function) 7615 7616 :param callback function: The callback function 7617 for asynchronous request. (optional) 7618 :param str account_id: The external account number (int) or account ID Guid. (required) 7619 :param FavoriteTemplatesInfo favorite_templates_info: 7620 :return: FavoriteTemplatesInfo 7621 If the method is called asynchronously, 7622 returns the request thread. 7623 """ 7624 kwargs['_return_http_data_only'] = True 7625 if kwargs.get('callback'): 7626 return self.update_favorite_template_with_http_info(account_id, **kwargs) 7627 else: 7628 (data) = self.update_favorite_template_with_http_info(account_id, **kwargs) 7629 return data 7630 7631 def update_favorite_template_with_http_info(self, account_id, **kwargs): 7632 """ 7633 Favorites a template 7634 7635 This method makes a synchronous HTTP request by default. To make an 7636 asynchronous HTTP request, please define a `callback` function 7637 to be invoked when receiving the response. 7638 >>> def callback_function(response): 7639 >>> pprint(response) 7640 >>> 7641 >>> thread = api.update_favorite_template_with_http_info(account_id, callback=callback_function) 7642 7643 :param callback function: The callback function 7644 for asynchronous request. (optional) 7645 :param str account_id: The external account number (int) or account ID Guid. (required) 7646 :param FavoriteTemplatesInfo favorite_templates_info: 7647 :return: FavoriteTemplatesInfo 7648 If the method is called asynchronously, 7649 returns the request thread. 7650 """ 7651 7652 all_params = ['account_id', 'favorite_templates_info'] 7653 all_params.append('callback') 7654 all_params.append('_return_http_data_only') 7655 all_params.append('_preload_content') 7656 all_params.append('_request_timeout') 7657 7658 params = locals() 7659 for key, val in iteritems(params['kwargs']): 7660 if key not in all_params: 7661 raise TypeError( 7662 "Got an unexpected keyword argument '%s'" 7663 " to method update_favorite_template" % key 7664 ) 7665 params[key] = val 7666 del params['kwargs'] 7667 # verify the required parameter 'account_id' is set 7668 if ('account_id' not in params) or (params['account_id'] is None): 7669 raise ValueError("Missing the required parameter `account_id` when calling `update_favorite_template`") 7670 7671 7672 collection_formats = {} 7673 7674 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 7675 path_params = {} 7676 if 'account_id' in params: 7677 path_params['accountId'] = params['account_id'] 7678 7679 query_params = {} 7680 7681 header_params = {} 7682 7683 form_params = [] 7684 local_var_files = {} 7685 7686 body_params = None 7687 if 'favorite_templates_info' in params: 7688 body_params = params['favorite_templates_info'] 7689 # HTTP header `Accept` 7690 header_params['Accept'] = self.api_client.\ 7691 select_header_accept(['application/json']) 7692 7693 # Authentication setting 7694 auth_settings = [] 7695 7696 return self.api_client.call_api(resource_path, 'PUT', 7697 path_params, 7698 query_params, 7699 header_params, 7700 body=body_params, 7701 post_params=form_params, 7702 files=local_var_files, 7703 response_type='FavoriteTemplatesInfo', 7704 auth_settings=auth_settings, 7705 callback=params.get('callback'), 7706 _return_http_data_only=params.get('_return_http_data_only'), 7707 _preload_content=params.get('_preload_content', True), 7708 _request_timeout=params.get('_request_timeout'), 7709 collection_formats=collection_formats) 7710 7711 def update_notification_defaults(self, account_id, **kwargs): 7712 """ 7713 Updates default user level settings for a specified account 7714 This method changes the default settings for the email notifications that signers and senders receive about envelopes. 7715 This method makes a synchronous HTTP request by default. To make an 7716 asynchronous HTTP request, please define a `callback` function 7717 to be invoked when receiving the response. 7718 >>> def callback_function(response): 7719 >>> pprint(response) 7720 >>> 7721 >>> thread = api.update_notification_defaults(account_id, callback=callback_function) 7722 7723 :param callback function: The callback function 7724 for asynchronous request. (optional) 7725 :param str account_id: The external account number (int) or account ID Guid. (required) 7726 :param NotificationDefaults notification_defaults: 7727 :return: NotificationDefaults 7728 If the method is called asynchronously, 7729 returns the request thread. 7730 """ 7731 kwargs['_return_http_data_only'] = True 7732 if kwargs.get('callback'): 7733 return self.update_notification_defaults_with_http_info(account_id, **kwargs) 7734 else: 7735 (data) = self.update_notification_defaults_with_http_info(account_id, **kwargs) 7736 return data 7737 7738 def update_notification_defaults_with_http_info(self, account_id, **kwargs): 7739 """ 7740 Updates default user level settings for a specified account 7741 This method changes the default settings for the email notifications that signers and senders receive about envelopes. 7742 This method makes a synchronous HTTP request by default. To make an 7743 asynchronous HTTP request, please define a `callback` function 7744 to be invoked when receiving the response. 7745 >>> def callback_function(response): 7746 >>> pprint(response) 7747 >>> 7748 >>> thread = api.update_notification_defaults_with_http_info(account_id, callback=callback_function) 7749 7750 :param callback function: The callback function 7751 for asynchronous request. (optional) 7752 :param str account_id: The external account number (int) or account ID Guid. (required) 7753 :param NotificationDefaults notification_defaults: 7754 :return: NotificationDefaults 7755 If the method is called asynchronously, 7756 returns the request thread. 7757 """ 7758 7759 all_params = ['account_id', 'notification_defaults'] 7760 all_params.append('callback') 7761 all_params.append('_return_http_data_only') 7762 all_params.append('_preload_content') 7763 all_params.append('_request_timeout') 7764 7765 params = locals() 7766 for key, val in iteritems(params['kwargs']): 7767 if key not in all_params: 7768 raise TypeError( 7769 "Got an unexpected keyword argument '%s'" 7770 " to method update_notification_defaults" % key 7771 ) 7772 params[key] = val 7773 del params['kwargs'] 7774 # verify the required parameter 'account_id' is set 7775 if ('account_id' not in params) or (params['account_id'] is None): 7776 raise ValueError("Missing the required parameter `account_id` when calling `update_notification_defaults`") 7777 7778 7779 collection_formats = {} 7780 7781 resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json') 7782 path_params = {} 7783 if 'account_id' in params: 7784 path_params['accountId'] = params['account_id'] 7785 7786 query_params = {} 7787 7788 header_params = {} 7789 7790 form_params = [] 7791 local_var_files = {} 7792 7793 body_params = None 7794 if 'notification_defaults' in params: 7795 body_params = params['notification_defaults'] 7796 # HTTP header `Accept` 7797 header_params['Accept'] = self.api_client.\ 7798 select_header_accept(['application/json']) 7799 7800 # Authentication setting 7801 auth_settings = [] 7802 7803 return self.api_client.call_api(resource_path, 'PUT', 7804 path_params, 7805 query_params, 7806 header_params, 7807 body=body_params, 7808 post_params=form_params, 7809 files=local_var_files, 7810 response_type='NotificationDefaults', 7811 auth_settings=auth_settings, 7812 callback=params.get('callback'), 7813 _return_http_data_only=params.get('_return_http_data_only'), 7814 _preload_content=params.get('_preload_content', True), 7815 _request_timeout=params.get('_request_timeout'), 7816 collection_formats=collection_formats) 7817 7818 def update_password_rules(self, account_id, **kwargs): 7819 """ 7820 Update the password rules 7821 This method updates the password rules for an account. **Note:** To update the password rules for an account, you must be an account administrator. 7822 This method makes a synchronous HTTP request by default. To make an 7823 asynchronous HTTP request, please define a `callback` function 7824 to be invoked when receiving the response. 7825 >>> def callback_function(response): 7826 >>> pprint(response) 7827 >>> 7828 >>> thread = api.update_password_rules(account_id, callback=callback_function) 7829 7830 :param callback function: The callback function 7831 for asynchronous request. (optional) 7832 :param str account_id: The external account number (int) or account ID Guid. (required) 7833 :param AccountPasswordRules account_password_rules: 7834 :return: AccountPasswordRules 7835 If the method is called asynchronously, 7836 returns the request thread. 7837 """ 7838 kwargs['_return_http_data_only'] = True 7839 if kwargs.get('callback'): 7840 return self.update_password_rules_with_http_info(account_id, **kwargs) 7841 else: 7842 (data) = self.update_password_rules_with_http_info(account_id, **kwargs) 7843 return data 7844 7845 def update_password_rules_with_http_info(self, account_id, **kwargs): 7846 """ 7847 Update the password rules 7848 This method updates the password rules for an account. **Note:** To update the password rules for an account, you must be an account administrator. 7849 This method makes a synchronous HTTP request by default. To make an 7850 asynchronous HTTP request, please define a `callback` function 7851 to be invoked when receiving the response. 7852 >>> def callback_function(response): 7853 >>> pprint(response) 7854 >>> 7855 >>> thread = api.update_password_rules_with_http_info(account_id, callback=callback_function) 7856 7857 :param callback function: The callback function 7858 for asynchronous request. (optional) 7859 :param str account_id: The external account number (int) or account ID Guid. (required) 7860 :param AccountPasswordRules account_password_rules: 7861 :return: AccountPasswordRules 7862 If the method is called asynchronously, 7863 returns the request thread. 7864 """ 7865 7866 all_params = ['account_id', 'account_password_rules'] 7867 all_params.append('callback') 7868 all_params.append('_return_http_data_only') 7869 all_params.append('_preload_content') 7870 all_params.append('_request_timeout') 7871 7872 params = locals() 7873 for key, val in iteritems(params['kwargs']): 7874 if key not in all_params: 7875 raise TypeError( 7876 "Got an unexpected keyword argument '%s'" 7877 " to method update_password_rules" % key 7878 ) 7879 params[key] = val 7880 del params['kwargs'] 7881 # verify the required parameter 'account_id' is set 7882 if ('account_id' not in params) or (params['account_id'] is None): 7883 raise ValueError("Missing the required parameter `account_id` when calling `update_password_rules`") 7884 7885 7886 collection_formats = {} 7887 7888 resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json') 7889 path_params = {} 7890 if 'account_id' in params: 7891 path_params['accountId'] = params['account_id'] 7892 7893 query_params = {} 7894 7895 header_params = {} 7896 7897 form_params = [] 7898 local_var_files = {} 7899 7900 body_params = None 7901 if 'account_password_rules' in params: 7902 body_params = params['account_password_rules'] 7903 # HTTP header `Accept` 7904 header_params['Accept'] = self.api_client.\ 7905 select_header_accept(['application/json']) 7906 7907 # Authentication setting 7908 auth_settings = [] 7909 7910 return self.api_client.call_api(resource_path, 'PUT', 7911 path_params, 7912 query_params, 7913 header_params, 7914 body=body_params, 7915 post_params=form_params, 7916 files=local_var_files, 7917 response_type='AccountPasswordRules', 7918 auth_settings=auth_settings, 7919 callback=params.get('callback'), 7920 _return_http_data_only=params.get('_return_http_data_only'), 7921 _preload_content=params.get('_preload_content', True), 7922 _request_timeout=params.get('_request_timeout'), 7923 collection_formats=collection_formats) 7924 7925 def update_permission_profile(self, account_id, permission_profile_id, **kwargs): 7926 """ 7927 Updates a permission profile within the specified account. 7928 This method updates an account permission profile. ### Related topics - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 7929 This method makes a synchronous HTTP request by default. To make an 7930 asynchronous HTTP request, please define a `callback` function 7931 to be invoked when receiving the response. 7932 >>> def callback_function(response): 7933 >>> pprint(response) 7934 >>> 7935 >>> thread = api.update_permission_profile(account_id, permission_profile_id, callback=callback_function) 7936 7937 :param callback function: The callback function 7938 for asynchronous request. (optional) 7939 :param str account_id: The external account number (int) or account ID Guid. (required) 7940 :param str permission_profile_id: (required) 7941 :param str include: 7942 :param PermissionProfile permission_profile: 7943 :return: PermissionProfile 7944 If the method is called asynchronously, 7945 returns the request thread. 7946 """ 7947 kwargs['_return_http_data_only'] = True 7948 if kwargs.get('callback'): 7949 return self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 7950 else: 7951 (data) = self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 7952 return data 7953 7954 def update_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 7955 """ 7956 Updates a permission profile within the specified account. 7957 This method updates an account permission profile. ### Related topics - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 7958 This method makes a synchronous HTTP request by default. To make an 7959 asynchronous HTTP request, please define a `callback` function 7960 to be invoked when receiving the response. 7961 >>> def callback_function(response): 7962 >>> pprint(response) 7963 >>> 7964 >>> thread = api.update_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 7965 7966 :param callback function: The callback function 7967 for asynchronous request. (optional) 7968 :param str account_id: The external account number (int) or account ID Guid. (required) 7969 :param str permission_profile_id: (required) 7970 :param str include: 7971 :param PermissionProfile permission_profile: 7972 :return: PermissionProfile 7973 If the method is called asynchronously, 7974 returns the request thread. 7975 """ 7976 7977 all_params = ['account_id', 'permission_profile_id', 'include', 'permission_profile'] 7978 all_params.append('callback') 7979 all_params.append('_return_http_data_only') 7980 all_params.append('_preload_content') 7981 all_params.append('_request_timeout') 7982 7983 params = locals() 7984 for key, val in iteritems(params['kwargs']): 7985 if key not in all_params: 7986 raise TypeError( 7987 "Got an unexpected keyword argument '%s'" 7988 " to method update_permission_profile" % key 7989 ) 7990 params[key] = val 7991 del params['kwargs'] 7992 # verify the required parameter 'account_id' is set 7993 if ('account_id' not in params) or (params['account_id'] is None): 7994 raise ValueError("Missing the required parameter `account_id` when calling `update_permission_profile`") 7995 # verify the required parameter 'permission_profile_id' is set 7996 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 7997 raise ValueError("Missing the required parameter `permission_profile_id` when calling `update_permission_profile`") 7998 7999 8000 collection_formats = {} 8001 8002 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 8003 path_params = {} 8004 if 'account_id' in params: 8005 path_params['accountId'] = params['account_id'] 8006 if 'permission_profile_id' in params: 8007 path_params['permissionProfileId'] = params['permission_profile_id'] 8008 8009 query_params = {} 8010 if 'include' in params: 8011 query_params['include'] = params['include'] 8012 8013 header_params = {} 8014 8015 form_params = [] 8016 local_var_files = {} 8017 8018 body_params = None 8019 if 'permission_profile' in params: 8020 body_params = params['permission_profile'] 8021 # HTTP header `Accept` 8022 header_params['Accept'] = self.api_client.\ 8023 select_header_accept(['application/json']) 8024 8025 # Authentication setting 8026 auth_settings = [] 8027 8028 return self.api_client.call_api(resource_path, 'PUT', 8029 path_params, 8030 query_params, 8031 header_params, 8032 body=body_params, 8033 post_params=form_params, 8034 files=local_var_files, 8035 response_type='PermissionProfile', 8036 auth_settings=auth_settings, 8037 callback=params.get('callback'), 8038 _return_http_data_only=params.get('_return_http_data_only'), 8039 _preload_content=params.get('_preload_content', True), 8040 _request_timeout=params.get('_request_timeout'), 8041 collection_formats=collection_formats) 8042 8043 def update_settings(self, account_id, **kwargs): 8044 """ 8045 Updates the account settings for an account. 8046 Updates the account settings for the specified account. 8047 This method makes a synchronous HTTP request by default. To make an 8048 asynchronous HTTP request, please define a `callback` function 8049 to be invoked when receiving the response. 8050 >>> def callback_function(response): 8051 >>> pprint(response) 8052 >>> 8053 >>> thread = api.update_settings(account_id, callback=callback_function) 8054 8055 :param callback function: The callback function 8056 for asynchronous request. (optional) 8057 :param str account_id: The external account number (int) or account ID Guid. (required) 8058 :param AccountSettingsInformation account_settings_information: 8059 :return: None 8060 If the method is called asynchronously, 8061 returns the request thread. 8062 """ 8063 kwargs['_return_http_data_only'] = True 8064 if kwargs.get('callback'): 8065 return self.update_settings_with_http_info(account_id, **kwargs) 8066 else: 8067 (data) = self.update_settings_with_http_info(account_id, **kwargs) 8068 return data 8069 8070 def update_settings_with_http_info(self, account_id, **kwargs): 8071 """ 8072 Updates the account settings for an account. 8073 Updates the account settings for the specified account. 8074 This method makes a synchronous HTTP request by default. To make an 8075 asynchronous HTTP request, please define a `callback` function 8076 to be invoked when receiving the response. 8077 >>> def callback_function(response): 8078 >>> pprint(response) 8079 >>> 8080 >>> thread = api.update_settings_with_http_info(account_id, callback=callback_function) 8081 8082 :param callback function: The callback function 8083 for asynchronous request. (optional) 8084 :param str account_id: The external account number (int) or account ID Guid. (required) 8085 :param AccountSettingsInformation account_settings_information: 8086 :return: None 8087 If the method is called asynchronously, 8088 returns the request thread. 8089 """ 8090 8091 all_params = ['account_id', 'account_settings_information'] 8092 all_params.append('callback') 8093 all_params.append('_return_http_data_only') 8094 all_params.append('_preload_content') 8095 all_params.append('_request_timeout') 8096 8097 params = locals() 8098 for key, val in iteritems(params['kwargs']): 8099 if key not in all_params: 8100 raise TypeError( 8101 "Got an unexpected keyword argument '%s'" 8102 " to method update_settings" % key 8103 ) 8104 params[key] = val 8105 del params['kwargs'] 8106 # verify the required parameter 'account_id' is set 8107 if ('account_id' not in params) or (params['account_id'] is None): 8108 raise ValueError("Missing the required parameter `account_id` when calling `update_settings`") 8109 8110 8111 collection_formats = {} 8112 8113 resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json') 8114 path_params = {} 8115 if 'account_id' in params: 8116 path_params['accountId'] = params['account_id'] 8117 8118 query_params = {} 8119 8120 header_params = {} 8121 8122 form_params = [] 8123 local_var_files = {} 8124 8125 body_params = None 8126 if 'account_settings_information' in params: 8127 body_params = params['account_settings_information'] 8128 # HTTP header `Accept` 8129 header_params['Accept'] = self.api_client.\ 8130 select_header_accept(['application/json']) 8131 8132 # Authentication setting 8133 auth_settings = [] 8134 8135 return self.api_client.call_api(resource_path, 'PUT', 8136 path_params, 8137 query_params, 8138 header_params, 8139 body=body_params, 8140 post_params=form_params, 8141 files=local_var_files, 8142 response_type=None, 8143 auth_settings=auth_settings, 8144 callback=params.get('callback'), 8145 _return_http_data_only=params.get('_return_http_data_only'), 8146 _preload_content=params.get('_preload_content', True), 8147 _request_timeout=params.get('_request_timeout'), 8148 collection_formats=collection_formats) 8149 8150 def update_shared_access(self, account_id, **kwargs): 8151 """ 8152 Reserved: Sets the shared access information for users. 8153 Reserved: Sets the shared access information for one or more users. 8154 This method makes a synchronous HTTP request by default. To make an 8155 asynchronous HTTP request, please define a `callback` function 8156 to be invoked when receiving the response. 8157 >>> def callback_function(response): 8158 >>> pprint(response) 8159 >>> 8160 >>> thread = api.update_shared_access(account_id, callback=callback_function) 8161 8162 :param callback function: The callback function 8163 for asynchronous request. (optional) 8164 :param str account_id: The external account number (int) or account ID Guid. (required) 8165 :param str item_type: 8166 :param str preserve_existing_shared_access: 8167 :param str user_ids: 8168 :param AccountSharedAccess account_shared_access: 8169 :return: AccountSharedAccess 8170 If the method is called asynchronously, 8171 returns the request thread. 8172 """ 8173 kwargs['_return_http_data_only'] = True 8174 if kwargs.get('callback'): 8175 return self.update_shared_access_with_http_info(account_id, **kwargs) 8176 else: 8177 (data) = self.update_shared_access_with_http_info(account_id, **kwargs) 8178 return data 8179 8180 def update_shared_access_with_http_info(self, account_id, **kwargs): 8181 """ 8182 Reserved: Sets the shared access information for users. 8183 Reserved: Sets the shared access information for one or more users. 8184 This method makes a synchronous HTTP request by default. To make an 8185 asynchronous HTTP request, please define a `callback` function 8186 to be invoked when receiving the response. 8187 >>> def callback_function(response): 8188 >>> pprint(response) 8189 >>> 8190 >>> thread = api.update_shared_access_with_http_info(account_id, callback=callback_function) 8191 8192 :param callback function: The callback function 8193 for asynchronous request. (optional) 8194 :param str account_id: The external account number (int) or account ID Guid. (required) 8195 :param str item_type: 8196 :param str preserve_existing_shared_access: 8197 :param str user_ids: 8198 :param AccountSharedAccess account_shared_access: 8199 :return: AccountSharedAccess 8200 If the method is called asynchronously, 8201 returns the request thread. 8202 """ 8203 8204 all_params = ['account_id', 'item_type', 'preserve_existing_shared_access', 'user_ids', 'account_shared_access'] 8205 all_params.append('callback') 8206 all_params.append('_return_http_data_only') 8207 all_params.append('_preload_content') 8208 all_params.append('_request_timeout') 8209 8210 params = locals() 8211 for key, val in iteritems(params['kwargs']): 8212 if key not in all_params: 8213 raise TypeError( 8214 "Got an unexpected keyword argument '%s'" 8215 " to method update_shared_access" % key 8216 ) 8217 params[key] = val 8218 del params['kwargs'] 8219 # verify the required parameter 'account_id' is set 8220 if ('account_id' not in params) or (params['account_id'] is None): 8221 raise ValueError("Missing the required parameter `account_id` when calling `update_shared_access`") 8222 8223 8224 collection_formats = {} 8225 8226 resource_path = '/v2.1/accounts/{accountId}/shared_access'.replace('{format}', 'json') 8227 path_params = {} 8228 if 'account_id' in params: 8229 path_params['accountId'] = params['account_id'] 8230 8231 query_params = {} 8232 if 'item_type' in params: 8233 query_params['item_type'] = params['item_type'] 8234 if 'preserve_existing_shared_access' in params: 8235 query_params['preserve_existing_shared_access'] = params['preserve_existing_shared_access'] 8236 if 'user_ids' in params: 8237 query_params['user_ids'] = params['user_ids'] 8238 8239 header_params = {} 8240 8241 form_params = [] 8242 local_var_files = {} 8243 8244 body_params = None 8245 if 'account_shared_access' in params: 8246 body_params = params['account_shared_access'] 8247 # HTTP header `Accept` 8248 header_params['Accept'] = self.api_client.\ 8249 select_header_accept(['application/json']) 8250 8251 # Authentication setting 8252 auth_settings = [] 8253 8254 return self.api_client.call_api(resource_path, 'PUT', 8255 path_params, 8256 query_params, 8257 header_params, 8258 body=body_params, 8259 post_params=form_params, 8260 files=local_var_files, 8261 response_type='AccountSharedAccess', 8262 auth_settings=auth_settings, 8263 callback=params.get('callback'), 8264 _return_http_data_only=params.get('_return_http_data_only'), 8265 _preload_content=params.get('_preload_content', True), 8266 _request_timeout=params.get('_request_timeout'), 8267 collection_formats=collection_formats) 8268 8269 def update_user_authorization(self, account_id, authorization_id, user_id, **kwargs): 8270 """ 8271 Updates the user authorization 8272 This method makes a synchronous HTTP request by default. To make an 8273 asynchronous HTTP request, please define a `callback` function 8274 to be invoked when receiving the response. 8275 >>> def callback_function(response): 8276 >>> pprint(response) 8277 >>> 8278 >>> thread = api.update_user_authorization(account_id, authorization_id, user_id, callback=callback_function) 8279 8280 :param callback function: The callback function 8281 for asynchronous request. (optional) 8282 :param str account_id: The external account number (int) or account ID Guid. (required) 8283 :param str authorization_id: (required) 8284 :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) 8285 :param UserAuthorizationUpdateRequest user_authorization_update_request: 8286 :return: UserAuthorization 8287 If the method is called asynchronously, 8288 returns the request thread. 8289 """ 8290 kwargs['_return_http_data_only'] = True 8291 if kwargs.get('callback'): 8292 return self.update_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 8293 else: 8294 (data) = self.update_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 8295 return data 8296 8297 def update_user_authorization_with_http_info(self, account_id, authorization_id, user_id, **kwargs): 8298 """ 8299 Updates the user authorization 8300 This method makes a synchronous HTTP request by default. To make an 8301 asynchronous HTTP request, please define a `callback` function 8302 to be invoked when receiving the response. 8303 >>> def callback_function(response): 8304 >>> pprint(response) 8305 >>> 8306 >>> thread = api.update_user_authorization_with_http_info(account_id, authorization_id, user_id, callback=callback_function) 8307 8308 :param callback function: The callback function 8309 for asynchronous request. (optional) 8310 :param str account_id: The external account number (int) or account ID Guid. (required) 8311 :param str authorization_id: (required) 8312 :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) 8313 :param UserAuthorizationUpdateRequest user_authorization_update_request: 8314 :return: UserAuthorization 8315 If the method is called asynchronously, 8316 returns the request thread. 8317 """ 8318 8319 all_params = ['account_id', 'authorization_id', 'user_id', 'user_authorization_update_request'] 8320 all_params.append('callback') 8321 all_params.append('_return_http_data_only') 8322 all_params.append('_preload_content') 8323 all_params.append('_request_timeout') 8324 8325 params = locals() 8326 for key, val in iteritems(params['kwargs']): 8327 if key not in all_params: 8328 raise TypeError( 8329 "Got an unexpected keyword argument '%s'" 8330 " to method update_user_authorization" % key 8331 ) 8332 params[key] = val 8333 del params['kwargs'] 8334 # verify the required parameter 'account_id' is set 8335 if ('account_id' not in params) or (params['account_id'] is None): 8336 raise ValueError("Missing the required parameter `account_id` when calling `update_user_authorization`") 8337 # verify the required parameter 'authorization_id' is set 8338 if ('authorization_id' not in params) or (params['authorization_id'] is None): 8339 raise ValueError("Missing the required parameter `authorization_id` when calling `update_user_authorization`") 8340 # verify the required parameter 'user_id' is set 8341 if ('user_id' not in params) or (params['user_id'] is None): 8342 raise ValueError("Missing the required parameter `user_id` when calling `update_user_authorization`") 8343 8344 8345 collection_formats = {} 8346 8347 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorization/{authorizationId}'.replace('{format}', 'json') 8348 path_params = {} 8349 if 'account_id' in params: 8350 path_params['accountId'] = params['account_id'] 8351 if 'authorization_id' in params: 8352 path_params['authorizationId'] = params['authorization_id'] 8353 if 'user_id' in params: 8354 path_params['userId'] = params['user_id'] 8355 8356 query_params = {} 8357 8358 header_params = {} 8359 8360 form_params = [] 8361 local_var_files = {} 8362 8363 body_params = None 8364 if 'user_authorization_update_request' in params: 8365 body_params = params['user_authorization_update_request'] 8366 # HTTP header `Accept` 8367 header_params['Accept'] = self.api_client.\ 8368 select_header_accept(['application/json']) 8369 8370 # Authentication setting 8371 auth_settings = [] 8372 8373 return self.api_client.call_api(resource_path, 'PUT', 8374 path_params, 8375 query_params, 8376 header_params, 8377 body=body_params, 8378 post_params=form_params, 8379 files=local_var_files, 8380 response_type='UserAuthorization', 8381 auth_settings=auth_settings, 8382 callback=params.get('callback'), 8383 _return_http_data_only=params.get('_return_http_data_only'), 8384 _preload_content=params.get('_preload_content', True), 8385 _request_timeout=params.get('_request_timeout'), 8386 collection_formats=collection_formats) 8387 8388 def update_watermark(self, account_id, **kwargs): 8389 """ 8390 Update watermark information. 8391 8392 This method makes a synchronous HTTP request by default. To make an 8393 asynchronous HTTP request, please define a `callback` function 8394 to be invoked when receiving the response. 8395 >>> def callback_function(response): 8396 >>> pprint(response) 8397 >>> 8398 >>> thread = api.update_watermark(account_id, callback=callback_function) 8399 8400 :param callback function: The callback function 8401 for asynchronous request. (optional) 8402 :param str account_id: The external account number (int) or account ID Guid. (required) 8403 :param Watermark watermark: 8404 :return: Watermark 8405 If the method is called asynchronously, 8406 returns the request thread. 8407 """ 8408 kwargs['_return_http_data_only'] = True 8409 if kwargs.get('callback'): 8410 return self.update_watermark_with_http_info(account_id, **kwargs) 8411 else: 8412 (data) = self.update_watermark_with_http_info(account_id, **kwargs) 8413 return data 8414 8415 def update_watermark_with_http_info(self, account_id, **kwargs): 8416 """ 8417 Update watermark information. 8418 8419 This method makes a synchronous HTTP request by default. To make an 8420 asynchronous HTTP request, please define a `callback` function 8421 to be invoked when receiving the response. 8422 >>> def callback_function(response): 8423 >>> pprint(response) 8424 >>> 8425 >>> thread = api.update_watermark_with_http_info(account_id, callback=callback_function) 8426 8427 :param callback function: The callback function 8428 for asynchronous request. (optional) 8429 :param str account_id: The external account number (int) or account ID Guid. (required) 8430 :param Watermark watermark: 8431 :return: Watermark 8432 If the method is called asynchronously, 8433 returns the request thread. 8434 """ 8435 8436 all_params = ['account_id', 'watermark'] 8437 all_params.append('callback') 8438 all_params.append('_return_http_data_only') 8439 all_params.append('_preload_content') 8440 all_params.append('_request_timeout') 8441 8442 params = locals() 8443 for key, val in iteritems(params['kwargs']): 8444 if key not in all_params: 8445 raise TypeError( 8446 "Got an unexpected keyword argument '%s'" 8447 " to method update_watermark" % key 8448 ) 8449 params[key] = val 8450 del params['kwargs'] 8451 # verify the required parameter 'account_id' is set 8452 if ('account_id' not in params) or (params['account_id'] is None): 8453 raise ValueError("Missing the required parameter `account_id` when calling `update_watermark`") 8454 8455 8456 collection_formats = {} 8457 8458 resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json') 8459 path_params = {} 8460 if 'account_id' in params: 8461 path_params['accountId'] = params['account_id'] 8462 8463 query_params = {} 8464 8465 header_params = {} 8466 8467 form_params = [] 8468 local_var_files = {} 8469 8470 body_params = None 8471 if 'watermark' in params: 8472 body_params = params['watermark'] 8473 # HTTP header `Accept` 8474 header_params['Accept'] = self.api_client.\ 8475 select_header_accept(['application/json']) 8476 8477 # Authentication setting 8478 auth_settings = [] 8479 8480 return self.api_client.call_api(resource_path, 'PUT', 8481 path_params, 8482 query_params, 8483 header_params, 8484 body=body_params, 8485 post_params=form_params, 8486 files=local_var_files, 8487 response_type='Watermark', 8488 auth_settings=auth_settings, 8489 callback=params.get('callback'), 8490 _return_http_data_only=params.get('_return_http_data_only'), 8491 _preload_content=params.get('_preload_content', True), 8492 _request_timeout=params.get('_request_timeout'), 8493 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 :param str include_trial_eligibility: 2276 :return: AccountInformation 2277 If the method is called asynchronously, 2278 returns the request thread. 2279 """ 2280 kwargs['_return_http_data_only'] = True 2281 if kwargs.get('callback'): 2282 return self.get_account_information_with_http_info(account_id, **kwargs) 2283 else: 2284 (data) = self.get_account_information_with_http_info(account_id, **kwargs) 2285 return data 2286 2287 def get_account_information_with_http_info(self, account_id, **kwargs): 2288 """ 2289 Retrieves the account information for the specified account. 2290 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. 2291 This method makes a synchronous HTTP request by default. To make an 2292 asynchronous HTTP request, please define a `callback` function 2293 to be invoked when receiving the response. 2294 >>> def callback_function(response): 2295 >>> pprint(response) 2296 >>> 2297 >>> thread = api.get_account_information_with_http_info(account_id, callback=callback_function) 2298 2299 :param callback function: The callback function 2300 for asynchronous request. (optional) 2301 :param str account_id: The external account number (int) or account ID Guid. (required) 2302 :param str include_account_settings: When set to **true**, includes the account settings for the account in the response. 2303 :param str include_trial_eligibility: 2304 :return: AccountInformation 2305 If the method is called asynchronously, 2306 returns the request thread. 2307 """ 2308 2309 all_params = ['account_id', 'include_account_settings', 'include_trial_eligibility'] 2310 all_params.append('callback') 2311 all_params.append('_return_http_data_only') 2312 all_params.append('_preload_content') 2313 all_params.append('_request_timeout') 2314 2315 params = locals() 2316 for key, val in iteritems(params['kwargs']): 2317 if key not in all_params: 2318 raise TypeError( 2319 "Got an unexpected keyword argument '%s'" 2320 " to method get_account_information" % key 2321 ) 2322 params[key] = val 2323 del params['kwargs'] 2324 # verify the required parameter 'account_id' is set 2325 if ('account_id' not in params) or (params['account_id'] is None): 2326 raise ValueError("Missing the required parameter `account_id` when calling `get_account_information`") 2327 2328 2329 collection_formats = {} 2330 2331 resource_path = '/v2.1/accounts/{accountId}'.replace('{format}', 'json') 2332 path_params = {} 2333 if 'account_id' in params: 2334 path_params['accountId'] = params['account_id'] 2335 2336 query_params = {} 2337 if 'include_account_settings' in params: 2338 query_params['include_account_settings'] = params['include_account_settings'] 2339 if 'include_trial_eligibility' in params: 2340 query_params['include_trial_eligibility'] = params['include_trial_eligibility'] 2341 2342 header_params = {} 2343 2344 form_params = [] 2345 local_var_files = {} 2346 2347 body_params = None 2348 # HTTP header `Accept` 2349 header_params['Accept'] = self.api_client.\ 2350 select_header_accept(['application/json']) 2351 2352 # Authentication setting 2353 auth_settings = [] 2354 2355 return self.api_client.call_api(resource_path, 'GET', 2356 path_params, 2357 query_params, 2358 header_params, 2359 body=body_params, 2360 post_params=form_params, 2361 files=local_var_files, 2362 response_type='AccountInformation', 2363 auth_settings=auth_settings, 2364 callback=params.get('callback'), 2365 _return_http_data_only=params.get('_return_http_data_only'), 2366 _preload_content=params.get('_preload_content', True), 2367 _request_timeout=params.get('_request_timeout'), 2368 collection_formats=collection_formats) 2369 2370 def get_account_signature(self, account_id, signature_id, **kwargs): 2371 """ 2372 Returns information about a single signature by specifed signatureId. 2373 2374 This method makes a synchronous HTTP request by default. To make an 2375 asynchronous HTTP request, please define a `callback` function 2376 to be invoked when receiving the response. 2377 >>> def callback_function(response): 2378 >>> pprint(response) 2379 >>> 2380 >>> thread = api.get_account_signature(account_id, signature_id, callback=callback_function) 2381 2382 :param callback function: The callback function 2383 for asynchronous request. (optional) 2384 :param str account_id: The external account number (int) or account ID Guid. (required) 2385 :param str signature_id: The ID of the signature being accessed. (required) 2386 :return: AccountSignature 2387 If the method is called asynchronously, 2388 returns the request thread. 2389 """ 2390 kwargs['_return_http_data_only'] = True 2391 if kwargs.get('callback'): 2392 return self.get_account_signature_with_http_info(account_id, signature_id, **kwargs) 2393 else: 2394 (data) = self.get_account_signature_with_http_info(account_id, signature_id, **kwargs) 2395 return data 2396 2397 def get_account_signature_with_http_info(self, account_id, signature_id, **kwargs): 2398 """ 2399 Returns information about a single signature by specifed signatureId. 2400 2401 This method makes a synchronous HTTP request by default. To make an 2402 asynchronous HTTP request, please define a `callback` function 2403 to be invoked when receiving the response. 2404 >>> def callback_function(response): 2405 >>> pprint(response) 2406 >>> 2407 >>> thread = api.get_account_signature_with_http_info(account_id, signature_id, callback=callback_function) 2408 2409 :param callback function: The callback function 2410 for asynchronous request. (optional) 2411 :param str account_id: The external account number (int) or account ID Guid. (required) 2412 :param str signature_id: The ID of the signature being accessed. (required) 2413 :return: AccountSignature 2414 If the method is called asynchronously, 2415 returns the request thread. 2416 """ 2417 2418 all_params = ['account_id', 'signature_id'] 2419 all_params.append('callback') 2420 all_params.append('_return_http_data_only') 2421 all_params.append('_preload_content') 2422 all_params.append('_request_timeout') 2423 2424 params = locals() 2425 for key, val in iteritems(params['kwargs']): 2426 if key not in all_params: 2427 raise TypeError( 2428 "Got an unexpected keyword argument '%s'" 2429 " to method get_account_signature" % key 2430 ) 2431 params[key] = val 2432 del params['kwargs'] 2433 # verify the required parameter 'account_id' is set 2434 if ('account_id' not in params) or (params['account_id'] is None): 2435 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signature`") 2436 # verify the required parameter 'signature_id' is set 2437 if ('signature_id' not in params) or (params['signature_id'] is None): 2438 raise ValueError("Missing the required parameter `signature_id` when calling `get_account_signature`") 2439 2440 2441 collection_formats = {} 2442 2443 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 2444 path_params = {} 2445 if 'account_id' in params: 2446 path_params['accountId'] = params['account_id'] 2447 if 'signature_id' in params: 2448 path_params['signatureId'] = params['signature_id'] 2449 2450 query_params = {} 2451 2452 header_params = {} 2453 2454 form_params = [] 2455 local_var_files = {} 2456 2457 body_params = None 2458 # HTTP header `Accept` 2459 header_params['Accept'] = self.api_client.\ 2460 select_header_accept(['application/json']) 2461 2462 # Authentication setting 2463 auth_settings = [] 2464 2465 return self.api_client.call_api(resource_path, 'GET', 2466 path_params, 2467 query_params, 2468 header_params, 2469 body=body_params, 2470 post_params=form_params, 2471 files=local_var_files, 2472 response_type='AccountSignature', 2473 auth_settings=auth_settings, 2474 callback=params.get('callback'), 2475 _return_http_data_only=params.get('_return_http_data_only'), 2476 _preload_content=params.get('_preload_content', True), 2477 _request_timeout=params.get('_request_timeout'), 2478 collection_formats=collection_formats) 2479 2480 def get_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 2481 """ 2482 Returns a signature, initials, or stamps image. 2483 2484 This method makes a synchronous HTTP request by default. To make an 2485 asynchronous HTTP request, please define a `callback` function 2486 to be invoked when receiving the response. 2487 >>> def callback_function(response): 2488 >>> pprint(response) 2489 >>> 2490 >>> thread = api.get_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 2491 2492 :param callback function: The callback function 2493 for asynchronous request. (optional) 2494 :param str account_id: The external account number (int) or account ID Guid. (required) 2495 :param str image_type: One of **signature_image** or **initials_image**. (required) 2496 :param str signature_id: The ID of the signature being accessed. (required) 2497 :param str include_chrome: 2498 :return: file 2499 If the method is called asynchronously, 2500 returns the request thread. 2501 """ 2502 kwargs['_return_http_data_only'] = True 2503 if kwargs.get('callback'): 2504 return self.get_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 2505 else: 2506 (data) = self.get_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 2507 return data 2508 2509 def get_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 2510 """ 2511 Returns a signature, initials, or stamps image. 2512 2513 This method makes a synchronous HTTP request by default. To make an 2514 asynchronous HTTP request, please define a `callback` function 2515 to be invoked when receiving the response. 2516 >>> def callback_function(response): 2517 >>> pprint(response) 2518 >>> 2519 >>> thread = api.get_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 2520 2521 :param callback function: The callback function 2522 for asynchronous request. (optional) 2523 :param str account_id: The external account number (int) or account ID Guid. (required) 2524 :param str image_type: One of **signature_image** or **initials_image**. (required) 2525 :param str signature_id: The ID of the signature being accessed. (required) 2526 :param str include_chrome: 2527 :return: file 2528 If the method is called asynchronously, 2529 returns the request thread. 2530 """ 2531 2532 all_params = ['account_id', 'image_type', 'signature_id', 'include_chrome'] 2533 all_params.append('callback') 2534 all_params.append('_return_http_data_only') 2535 all_params.append('_preload_content') 2536 all_params.append('_request_timeout') 2537 2538 params = locals() 2539 for key, val in iteritems(params['kwargs']): 2540 if key not in all_params: 2541 raise TypeError( 2542 "Got an unexpected keyword argument '%s'" 2543 " to method get_account_signature_image" % key 2544 ) 2545 params[key] = val 2546 del params['kwargs'] 2547 # verify the required parameter 'account_id' is set 2548 if ('account_id' not in params) or (params['account_id'] is None): 2549 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signature_image`") 2550 # verify the required parameter 'image_type' is set 2551 if ('image_type' not in params) or (params['image_type'] is None): 2552 raise ValueError("Missing the required parameter `image_type` when calling `get_account_signature_image`") 2553 # verify the required parameter 'signature_id' is set 2554 if ('signature_id' not in params) or (params['signature_id'] is None): 2555 raise ValueError("Missing the required parameter `signature_id` when calling `get_account_signature_image`") 2556 2557 2558 collection_formats = {} 2559 2560 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 2561 path_params = {} 2562 if 'account_id' in params: 2563 path_params['accountId'] = params['account_id'] 2564 if 'image_type' in params: 2565 path_params['imageType'] = params['image_type'] 2566 if 'signature_id' in params: 2567 path_params['signatureId'] = params['signature_id'] 2568 2569 query_params = {} 2570 if 'include_chrome' in params: 2571 query_params['include_chrome'] = params['include_chrome'] 2572 2573 header_params = {} 2574 2575 form_params = [] 2576 local_var_files = {} 2577 2578 body_params = None 2579 # HTTP header `Accept` 2580 header_params['Accept'] = self.api_client.\ 2581 select_header_accept(['image/gif']) 2582 2583 # Authentication setting 2584 auth_settings = [] 2585 2586 return self.api_client.call_api(resource_path, 'GET', 2587 path_params, 2588 query_params, 2589 header_params, 2590 body=body_params, 2591 post_params=form_params, 2592 files=local_var_files, 2593 response_type='file', 2594 auth_settings=auth_settings, 2595 callback=params.get('callback'), 2596 _return_http_data_only=params.get('_return_http_data_only'), 2597 _preload_content=params.get('_preload_content', True), 2598 _request_timeout=params.get('_request_timeout'), 2599 collection_formats=collection_formats) 2600 2601 def get_account_signatures(self, account_id, **kwargs): 2602 """ 2603 Returns the managed signature definitions for the account 2604 2605 This method makes a synchronous HTTP request by default. To make an 2606 asynchronous HTTP request, please define a `callback` function 2607 to be invoked when receiving the response. 2608 >>> def callback_function(response): 2609 >>> pprint(response) 2610 >>> 2611 >>> thread = api.get_account_signatures(account_id, callback=callback_function) 2612 2613 :param callback function: The callback function 2614 for asynchronous request. (optional) 2615 :param str account_id: The external account number (int) or account ID Guid. (required) 2616 :param str stamp_format: 2617 :param str stamp_name: 2618 :param str stamp_type: 2619 :return: AccountSignaturesInformation 2620 If the method is called asynchronously, 2621 returns the request thread. 2622 """ 2623 kwargs['_return_http_data_only'] = True 2624 if kwargs.get('callback'): 2625 return self.get_account_signatures_with_http_info(account_id, **kwargs) 2626 else: 2627 (data) = self.get_account_signatures_with_http_info(account_id, **kwargs) 2628 return data 2629 2630 def get_account_signatures_with_http_info(self, account_id, **kwargs): 2631 """ 2632 Returns the managed signature definitions for the account 2633 2634 This method makes a synchronous HTTP request by default. To make an 2635 asynchronous HTTP request, please define a `callback` function 2636 to be invoked when receiving the response. 2637 >>> def callback_function(response): 2638 >>> pprint(response) 2639 >>> 2640 >>> thread = api.get_account_signatures_with_http_info(account_id, callback=callback_function) 2641 2642 :param callback function: The callback function 2643 for asynchronous request. (optional) 2644 :param str account_id: The external account number (int) or account ID Guid. (required) 2645 :param str stamp_format: 2646 :param str stamp_name: 2647 :param str stamp_type: 2648 :return: AccountSignaturesInformation 2649 If the method is called asynchronously, 2650 returns the request thread. 2651 """ 2652 2653 all_params = ['account_id', 'stamp_format', 'stamp_name', 'stamp_type'] 2654 all_params.append('callback') 2655 all_params.append('_return_http_data_only') 2656 all_params.append('_preload_content') 2657 all_params.append('_request_timeout') 2658 2659 params = locals() 2660 for key, val in iteritems(params['kwargs']): 2661 if key not in all_params: 2662 raise TypeError( 2663 "Got an unexpected keyword argument '%s'" 2664 " to method get_account_signatures" % key 2665 ) 2666 params[key] = val 2667 del params['kwargs'] 2668 # verify the required parameter 'account_id' is set 2669 if ('account_id' not in params) or (params['account_id'] is None): 2670 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signatures`") 2671 2672 2673 collection_formats = {} 2674 2675 resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json') 2676 path_params = {} 2677 if 'account_id' in params: 2678 path_params['accountId'] = params['account_id'] 2679 2680 query_params = {} 2681 if 'stamp_format' in params: 2682 query_params['stamp_format'] = params['stamp_format'] 2683 if 'stamp_name' in params: 2684 query_params['stamp_name'] = params['stamp_name'] 2685 if 'stamp_type' in params: 2686 query_params['stamp_type'] = params['stamp_type'] 2687 2688 header_params = {} 2689 2690 form_params = [] 2691 local_var_files = {} 2692 2693 body_params = None 2694 # HTTP header `Accept` 2695 header_params['Accept'] = self.api_client.\ 2696 select_header_accept(['application/json']) 2697 2698 # Authentication setting 2699 auth_settings = [] 2700 2701 return self.api_client.call_api(resource_path, 'GET', 2702 path_params, 2703 query_params, 2704 header_params, 2705 body=body_params, 2706 post_params=form_params, 2707 files=local_var_files, 2708 response_type='AccountSignaturesInformation', 2709 auth_settings=auth_settings, 2710 callback=params.get('callback'), 2711 _return_http_data_only=params.get('_return_http_data_only'), 2712 _preload_content=params.get('_preload_content', True), 2713 _request_timeout=params.get('_request_timeout'), 2714 collection_formats=collection_formats) 2715 2716 def get_account_tab_settings(self, account_id, **kwargs): 2717 """ 2718 Returns tab settings list for specified account 2719 This method returns information about the tab types and tab functionality that is currently enabled for an account. 2720 This method makes a synchronous HTTP request by default. To make an 2721 asynchronous HTTP request, please define a `callback` function 2722 to be invoked when receiving the response. 2723 >>> def callback_function(response): 2724 >>> pprint(response) 2725 >>> 2726 >>> thread = api.get_account_tab_settings(account_id, callback=callback_function) 2727 2728 :param callback function: The callback function 2729 for asynchronous request. (optional) 2730 :param str account_id: The external account number (int) or account ID Guid. (required) 2731 :return: TabAccountSettings 2732 If the method is called asynchronously, 2733 returns the request thread. 2734 """ 2735 kwargs['_return_http_data_only'] = True 2736 if kwargs.get('callback'): 2737 return self.get_account_tab_settings_with_http_info(account_id, **kwargs) 2738 else: 2739 (data) = self.get_account_tab_settings_with_http_info(account_id, **kwargs) 2740 return data 2741 2742 def get_account_tab_settings_with_http_info(self, account_id, **kwargs): 2743 """ 2744 Returns tab settings list for specified account 2745 This method returns information about the tab types and tab functionality that is currently enabled for an account. 2746 This method makes a synchronous HTTP request by default. To make an 2747 asynchronous HTTP request, please define a `callback` function 2748 to be invoked when receiving the response. 2749 >>> def callback_function(response): 2750 >>> pprint(response) 2751 >>> 2752 >>> thread = api.get_account_tab_settings_with_http_info(account_id, callback=callback_function) 2753 2754 :param callback function: The callback function 2755 for asynchronous request. (optional) 2756 :param str account_id: The external account number (int) or account ID Guid. (required) 2757 :return: TabAccountSettings 2758 If the method is called asynchronously, 2759 returns the request thread. 2760 """ 2761 2762 all_params = ['account_id'] 2763 all_params.append('callback') 2764 all_params.append('_return_http_data_only') 2765 all_params.append('_preload_content') 2766 all_params.append('_request_timeout') 2767 2768 params = locals() 2769 for key, val in iteritems(params['kwargs']): 2770 if key not in all_params: 2771 raise TypeError( 2772 "Got an unexpected keyword argument '%s'" 2773 " to method get_account_tab_settings" % key 2774 ) 2775 params[key] = val 2776 del params['kwargs'] 2777 # verify the required parameter 'account_id' is set 2778 if ('account_id' not in params) or (params['account_id'] is None): 2779 raise ValueError("Missing the required parameter `account_id` when calling `get_account_tab_settings`") 2780 2781 2782 collection_formats = {} 2783 2784 resource_path = '/v2.1/accounts/{accountId}/settings/tabs'.replace('{format}', 'json') 2785 path_params = {} 2786 if 'account_id' in params: 2787 path_params['accountId'] = params['account_id'] 2788 2789 query_params = {} 2790 2791 header_params = {} 2792 2793 form_params = [] 2794 local_var_files = {} 2795 2796 body_params = None 2797 # HTTP header `Accept` 2798 header_params['Accept'] = self.api_client.\ 2799 select_header_accept(['application/json']) 2800 2801 # Authentication setting 2802 auth_settings = [] 2803 2804 return self.api_client.call_api(resource_path, 'GET', 2805 path_params, 2806 query_params, 2807 header_params, 2808 body=body_params, 2809 post_params=form_params, 2810 files=local_var_files, 2811 response_type='TabAccountSettings', 2812 auth_settings=auth_settings, 2813 callback=params.get('callback'), 2814 _return_http_data_only=params.get('_return_http_data_only'), 2815 _preload_content=params.get('_preload_content', True), 2816 _request_timeout=params.get('_request_timeout'), 2817 collection_formats=collection_formats) 2818 2819 def get_agent_user_authorizations(self, account_id, user_id, **kwargs): 2820 """ 2821 Returns the agent user authorizations 2822 This method makes a synchronous HTTP request by default. To make an 2823 asynchronous HTTP request, please define a `callback` function 2824 to be invoked when receiving the response. 2825 >>> def callback_function(response): 2826 >>> pprint(response) 2827 >>> 2828 >>> thread = api.get_agent_user_authorizations(account_id, user_id, callback=callback_function) 2829 2830 :param callback function: The callback function 2831 for asynchronous request. (optional) 2832 :param str account_id: The external account number (int) or account ID Guid. (required) 2833 :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) 2834 :param str active_only: 2835 :param str count: 2836 :param str email_substring: Part (substring) of email we are searching for. 2837 :param str include_closed_users: 2838 :param str permissions: 2839 :param str start_position: 2840 :param str user_name_substring: 2841 :return: UserAuthorizations 2842 If the method is called asynchronously, 2843 returns the request thread. 2844 """ 2845 kwargs['_return_http_data_only'] = True 2846 if kwargs.get('callback'): 2847 return self.get_agent_user_authorizations_with_http_info(account_id, user_id, **kwargs) 2848 else: 2849 (data) = self.get_agent_user_authorizations_with_http_info(account_id, user_id, **kwargs) 2850 return data 2851 2852 def get_agent_user_authorizations_with_http_info(self, account_id, user_id, **kwargs): 2853 """ 2854 Returns the agent user authorizations 2855 This method makes a synchronous HTTP request by default. To make an 2856 asynchronous HTTP request, please define a `callback` function 2857 to be invoked when receiving the response. 2858 >>> def callback_function(response): 2859 >>> pprint(response) 2860 >>> 2861 >>> thread = api.get_agent_user_authorizations_with_http_info(account_id, user_id, callback=callback_function) 2862 2863 :param callback function: The callback function 2864 for asynchronous request. (optional) 2865 :param str account_id: The external account number (int) or account ID Guid. (required) 2866 :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) 2867 :param str active_only: 2868 :param str count: 2869 :param str email_substring: Part (substring) of email we are searching for. 2870 :param str include_closed_users: 2871 :param str permissions: 2872 :param str start_position: 2873 :param str user_name_substring: 2874 :return: UserAuthorizations 2875 If the method is called asynchronously, 2876 returns the request thread. 2877 """ 2878 2879 all_params = ['account_id', 'user_id', 'active_only', 'count', 'email_substring', 'include_closed_users', 'permissions', 'start_position', 'user_name_substring'] 2880 all_params.append('callback') 2881 all_params.append('_return_http_data_only') 2882 all_params.append('_preload_content') 2883 all_params.append('_request_timeout') 2884 2885 params = locals() 2886 for key, val in iteritems(params['kwargs']): 2887 if key not in all_params: 2888 raise TypeError( 2889 "Got an unexpected keyword argument '%s'" 2890 " to method get_agent_user_authorizations" % key 2891 ) 2892 params[key] = val 2893 del params['kwargs'] 2894 # verify the required parameter 'account_id' is set 2895 if ('account_id' not in params) or (params['account_id'] is None): 2896 raise ValueError("Missing the required parameter `account_id` when calling `get_agent_user_authorizations`") 2897 # verify the required parameter 'user_id' is set 2898 if ('user_id' not in params) or (params['user_id'] is None): 2899 raise ValueError("Missing the required parameter `user_id` when calling `get_agent_user_authorizations`") 2900 2901 2902 collection_formats = {} 2903 2904 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorizations/agent'.replace('{format}', 'json') 2905 path_params = {} 2906 if 'account_id' in params: 2907 path_params['accountId'] = params['account_id'] 2908 if 'user_id' in params: 2909 path_params['userId'] = params['user_id'] 2910 2911 query_params = {} 2912 if 'active_only' in params: 2913 query_params['active_only'] = params['active_only'] 2914 if 'count' in params: 2915 query_params['count'] = params['count'] 2916 if 'email_substring' in params: 2917 query_params['email_substring'] = params['email_substring'] 2918 if 'include_closed_users' in params: 2919 query_params['include_closed_users'] = params['include_closed_users'] 2920 if 'permissions' in params: 2921 query_params['permissions'] = params['permissions'] 2922 if 'start_position' in params: 2923 query_params['start_position'] = params['start_position'] 2924 if 'user_name_substring' in params: 2925 query_params['user_name_substring'] = params['user_name_substring'] 2926 2927 header_params = {} 2928 2929 form_params = [] 2930 local_var_files = {} 2931 2932 body_params = None 2933 # HTTP header `Accept` 2934 header_params['Accept'] = self.api_client.\ 2935 select_header_accept(['application/json']) 2936 2937 # Authentication setting 2938 auth_settings = [] 2939 2940 return self.api_client.call_api(resource_path, 'GET', 2941 path_params, 2942 query_params, 2943 header_params, 2944 body=body_params, 2945 post_params=form_params, 2946 files=local_var_files, 2947 response_type='UserAuthorizations', 2948 auth_settings=auth_settings, 2949 callback=params.get('callback'), 2950 _return_http_data_only=params.get('_return_http_data_only'), 2951 _preload_content=params.get('_preload_content', True), 2952 _request_timeout=params.get('_request_timeout'), 2953 collection_formats=collection_formats) 2954 2955 def get_all_payment_gateway_accounts(self, account_id, **kwargs): 2956 """ 2957 Get all payment gateway account for the provided accountId 2958 This method returns a list of payment gateway accounts and basic information about them. 2959 This method makes a synchronous HTTP request by default. To make an 2960 asynchronous HTTP request, please define a `callback` function 2961 to be invoked when receiving the response. 2962 >>> def callback_function(response): 2963 >>> pprint(response) 2964 >>> 2965 >>> thread = api.get_all_payment_gateway_accounts(account_id, callback=callback_function) 2966 2967 :param callback function: The callback function 2968 for asynchronous request. (optional) 2969 :param str account_id: The external account number (int) or account ID Guid. (required) 2970 :return: PaymentGatewayAccountsInfo 2971 If the method is called asynchronously, 2972 returns the request thread. 2973 """ 2974 kwargs['_return_http_data_only'] = True 2975 if kwargs.get('callback'): 2976 return self.get_all_payment_gateway_accounts_with_http_info(account_id, **kwargs) 2977 else: 2978 (data) = self.get_all_payment_gateway_accounts_with_http_info(account_id, **kwargs) 2979 return data 2980 2981 def get_all_payment_gateway_accounts_with_http_info(self, account_id, **kwargs): 2982 """ 2983 Get all payment gateway account for the provided accountId 2984 This method returns a list of payment gateway accounts and basic information about them. 2985 This method makes a synchronous HTTP request by default. To make an 2986 asynchronous HTTP request, please define a `callback` function 2987 to be invoked when receiving the response. 2988 >>> def callback_function(response): 2989 >>> pprint(response) 2990 >>> 2991 >>> thread = api.get_all_payment_gateway_accounts_with_http_info(account_id, callback=callback_function) 2992 2993 :param callback function: The callback function 2994 for asynchronous request. (optional) 2995 :param str account_id: The external account number (int) or account ID Guid. (required) 2996 :return: PaymentGatewayAccountsInfo 2997 If the method is called asynchronously, 2998 returns the request thread. 2999 """ 3000 3001 all_params = ['account_id'] 3002 all_params.append('callback') 3003 all_params.append('_return_http_data_only') 3004 all_params.append('_preload_content') 3005 all_params.append('_request_timeout') 3006 3007 params = locals() 3008 for key, val in iteritems(params['kwargs']): 3009 if key not in all_params: 3010 raise TypeError( 3011 "Got an unexpected keyword argument '%s'" 3012 " to method get_all_payment_gateway_accounts" % key 3013 ) 3014 params[key] = val 3015 del params['kwargs'] 3016 # verify the required parameter 'account_id' is set 3017 if ('account_id' not in params) or (params['account_id'] is None): 3018 raise ValueError("Missing the required parameter `account_id` when calling `get_all_payment_gateway_accounts`") 3019 3020 3021 collection_formats = {} 3022 3023 resource_path = '/v2.1/accounts/{accountId}/payment_gateway_accounts'.replace('{format}', 'json') 3024 path_params = {} 3025 if 'account_id' in params: 3026 path_params['accountId'] = params['account_id'] 3027 3028 query_params = {} 3029 3030 header_params = {} 3031 3032 form_params = [] 3033 local_var_files = {} 3034 3035 body_params = None 3036 # HTTP header `Accept` 3037 header_params['Accept'] = self.api_client.\ 3038 select_header_accept(['application/json']) 3039 3040 # Authentication setting 3041 auth_settings = [] 3042 3043 return self.api_client.call_api(resource_path, 'GET', 3044 path_params, 3045 query_params, 3046 header_params, 3047 body=body_params, 3048 post_params=form_params, 3049 files=local_var_files, 3050 response_type='PaymentGatewayAccountsInfo', 3051 auth_settings=auth_settings, 3052 callback=params.get('callback'), 3053 _return_http_data_only=params.get('_return_http_data_only'), 3054 _preload_content=params.get('_preload_content', True), 3055 _request_timeout=params.get('_request_timeout'), 3056 collection_formats=collection_formats) 3057 3058 def get_billing_charges(self, account_id, **kwargs): 3059 """ 3060 Gets list of recurring and usage charges for the account. 3061 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 3062 This method makes a synchronous HTTP request by default. To make an 3063 asynchronous HTTP request, please define a `callback` function 3064 to be invoked when receiving the response. 3065 >>> def callback_function(response): 3066 >>> pprint(response) 3067 >>> 3068 >>> thread = api.get_billing_charges(account_id, callback=callback_function) 3069 3070 :param callback function: The callback function 3071 for asynchronous request. (optional) 3072 :param str account_id: The external account number (int) or account ID Guid. (required) 3073 :param str include_charges: Specifies which billing charges to return. Valid values are: * envelopes * seats 3074 :return: BillingChargeResponse 3075 If the method is called asynchronously, 3076 returns the request thread. 3077 """ 3078 kwargs['_return_http_data_only'] = True 3079 if kwargs.get('callback'): 3080 return self.get_billing_charges_with_http_info(account_id, **kwargs) 3081 else: 3082 (data) = self.get_billing_charges_with_http_info(account_id, **kwargs) 3083 return data 3084 3085 def get_billing_charges_with_http_info(self, account_id, **kwargs): 3086 """ 3087 Gets list of recurring and usage charges for the account. 3088 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 3089 This method makes a synchronous HTTP request by default. To make an 3090 asynchronous HTTP request, please define a `callback` function 3091 to be invoked when receiving the response. 3092 >>> def callback_function(response): 3093 >>> pprint(response) 3094 >>> 3095 >>> thread = api.get_billing_charges_with_http_info(account_id, callback=callback_function) 3096 3097 :param callback function: The callback function 3098 for asynchronous request. (optional) 3099 :param str account_id: The external account number (int) or account ID Guid. (required) 3100 :param str include_charges: Specifies which billing charges to return. Valid values are: * envelopes * seats 3101 :return: BillingChargeResponse 3102 If the method is called asynchronously, 3103 returns the request thread. 3104 """ 3105 3106 all_params = ['account_id', 'include_charges'] 3107 all_params.append('callback') 3108 all_params.append('_return_http_data_only') 3109 all_params.append('_preload_content') 3110 all_params.append('_request_timeout') 3111 3112 params = locals() 3113 for key, val in iteritems(params['kwargs']): 3114 if key not in all_params: 3115 raise TypeError( 3116 "Got an unexpected keyword argument '%s'" 3117 " to method get_billing_charges" % key 3118 ) 3119 params[key] = val 3120 del params['kwargs'] 3121 # verify the required parameter 'account_id' is set 3122 if ('account_id' not in params) or (params['account_id'] is None): 3123 raise ValueError("Missing the required parameter `account_id` when calling `get_billing_charges`") 3124 3125 3126 collection_formats = {} 3127 3128 resource_path = '/v2.1/accounts/{accountId}/billing_charges'.replace('{format}', 'json') 3129 path_params = {} 3130 if 'account_id' in params: 3131 path_params['accountId'] = params['account_id'] 3132 3133 query_params = {} 3134 if 'include_charges' in params: 3135 query_params['include_charges'] = params['include_charges'] 3136 3137 header_params = {} 3138 3139 form_params = [] 3140 local_var_files = {} 3141 3142 body_params = None 3143 # HTTP header `Accept` 3144 header_params['Accept'] = self.api_client.\ 3145 select_header_accept(['application/json']) 3146 3147 # Authentication setting 3148 auth_settings = [] 3149 3150 return self.api_client.call_api(resource_path, 'GET', 3151 path_params, 3152 query_params, 3153 header_params, 3154 body=body_params, 3155 post_params=form_params, 3156 files=local_var_files, 3157 response_type='BillingChargeResponse', 3158 auth_settings=auth_settings, 3159 callback=params.get('callback'), 3160 _return_http_data_only=params.get('_return_http_data_only'), 3161 _preload_content=params.get('_preload_content', True), 3162 _request_timeout=params.get('_request_timeout'), 3163 collection_formats=collection_formats) 3164 3165 def get_brand(self, account_id, brand_id, **kwargs): 3166 """ 3167 Get information for a specific brand. 3168 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**). 3169 This method makes a synchronous HTTP request by default. To make an 3170 asynchronous HTTP request, please define a `callback` function 3171 to be invoked when receiving the response. 3172 >>> def callback_function(response): 3173 >>> pprint(response) 3174 >>> 3175 >>> thread = api.get_brand(account_id, brand_id, callback=callback_function) 3176 3177 :param callback function: The callback function 3178 for asynchronous request. (optional) 3179 :param str account_id: The external account number (int) or account ID Guid. (required) 3180 :param str brand_id: The unique identifier of a brand. (required) 3181 :param str include_external_references: 3182 :param str include_logos: 3183 :return: Brand 3184 If the method is called asynchronously, 3185 returns the request thread. 3186 """ 3187 kwargs['_return_http_data_only'] = True 3188 if kwargs.get('callback'): 3189 return self.get_brand_with_http_info(account_id, brand_id, **kwargs) 3190 else: 3191 (data) = self.get_brand_with_http_info(account_id, brand_id, **kwargs) 3192 return data 3193 3194 def get_brand_with_http_info(self, account_id, brand_id, **kwargs): 3195 """ 3196 Get information for a specific brand. 3197 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**). 3198 This method makes a synchronous HTTP request by default. To make an 3199 asynchronous HTTP request, please define a `callback` function 3200 to be invoked when receiving the response. 3201 >>> def callback_function(response): 3202 >>> pprint(response) 3203 >>> 3204 >>> thread = api.get_brand_with_http_info(account_id, brand_id, callback=callback_function) 3205 3206 :param callback function: The callback function 3207 for asynchronous request. (optional) 3208 :param str account_id: The external account number (int) or account ID Guid. (required) 3209 :param str brand_id: The unique identifier of a brand. (required) 3210 :param str include_external_references: 3211 :param str include_logos: 3212 :return: Brand 3213 If the method is called asynchronously, 3214 returns the request thread. 3215 """ 3216 3217 all_params = ['account_id', 'brand_id', 'include_external_references', 'include_logos'] 3218 all_params.append('callback') 3219 all_params.append('_return_http_data_only') 3220 all_params.append('_preload_content') 3221 all_params.append('_request_timeout') 3222 3223 params = locals() 3224 for key, val in iteritems(params['kwargs']): 3225 if key not in all_params: 3226 raise TypeError( 3227 "Got an unexpected keyword argument '%s'" 3228 " to method get_brand" % key 3229 ) 3230 params[key] = val 3231 del params['kwargs'] 3232 # verify the required parameter 'account_id' is set 3233 if ('account_id' not in params) or (params['account_id'] is None): 3234 raise ValueError("Missing the required parameter `account_id` when calling `get_brand`") 3235 # verify the required parameter 'brand_id' is set 3236 if ('brand_id' not in params) or (params['brand_id'] is None): 3237 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand`") 3238 3239 3240 collection_formats = {} 3241 3242 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 3243 path_params = {} 3244 if 'account_id' in params: 3245 path_params['accountId'] = params['account_id'] 3246 if 'brand_id' in params: 3247 path_params['brandId'] = params['brand_id'] 3248 3249 query_params = {} 3250 if 'include_external_references' in params: 3251 query_params['include_external_references'] = params['include_external_references'] 3252 if 'include_logos' in params: 3253 query_params['include_logos'] = params['include_logos'] 3254 3255 header_params = {} 3256 3257 form_params = [] 3258 local_var_files = {} 3259 3260 body_params = None 3261 # HTTP header `Accept` 3262 header_params['Accept'] = self.api_client.\ 3263 select_header_accept(['application/json']) 3264 3265 # Authentication setting 3266 auth_settings = [] 3267 3268 return self.api_client.call_api(resource_path, 'GET', 3269 path_params, 3270 query_params, 3271 header_params, 3272 body=body_params, 3273 post_params=form_params, 3274 files=local_var_files, 3275 response_type='Brand', 3276 auth_settings=auth_settings, 3277 callback=params.get('callback'), 3278 _return_http_data_only=params.get('_return_http_data_only'), 3279 _preload_content=params.get('_preload_content', True), 3280 _request_timeout=params.get('_request_timeout'), 3281 collection_formats=collection_formats) 3282 3283 def get_brand_export_file(self, account_id, brand_id, **kwargs): 3284 """ 3285 Export a specific brand. 3286 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**). 3287 This method makes a synchronous HTTP request by default. To make an 3288 asynchronous HTTP request, please define a `callback` function 3289 to be invoked when receiving the response. 3290 >>> def callback_function(response): 3291 >>> pprint(response) 3292 >>> 3293 >>> thread = api.get_brand_export_file(account_id, brand_id, callback=callback_function) 3294 3295 :param callback function: The callback function 3296 for asynchronous request. (optional) 3297 :param str account_id: The external account number (int) or account ID Guid. (required) 3298 :param str brand_id: The unique identifier of a brand. (required) 3299 :return: None 3300 If the method is called asynchronously, 3301 returns the request thread. 3302 """ 3303 kwargs['_return_http_data_only'] = True 3304 if kwargs.get('callback'): 3305 return self.get_brand_export_file_with_http_info(account_id, brand_id, **kwargs) 3306 else: 3307 (data) = self.get_brand_export_file_with_http_info(account_id, brand_id, **kwargs) 3308 return data 3309 3310 def get_brand_export_file_with_http_info(self, account_id, brand_id, **kwargs): 3311 """ 3312 Export a specific brand. 3313 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**). 3314 This method makes a synchronous HTTP request by default. To make an 3315 asynchronous HTTP request, please define a `callback` function 3316 to be invoked when receiving the response. 3317 >>> def callback_function(response): 3318 >>> pprint(response) 3319 >>> 3320 >>> thread = api.get_brand_export_file_with_http_info(account_id, brand_id, callback=callback_function) 3321 3322 :param callback function: The callback function 3323 for asynchronous request. (optional) 3324 :param str account_id: The external account number (int) or account ID Guid. (required) 3325 :param str brand_id: The unique identifier of a brand. (required) 3326 :return: None 3327 If the method is called asynchronously, 3328 returns the request thread. 3329 """ 3330 3331 all_params = ['account_id', 'brand_id'] 3332 all_params.append('callback') 3333 all_params.append('_return_http_data_only') 3334 all_params.append('_preload_content') 3335 all_params.append('_request_timeout') 3336 3337 params = locals() 3338 for key, val in iteritems(params['kwargs']): 3339 if key not in all_params: 3340 raise TypeError( 3341 "Got an unexpected keyword argument '%s'" 3342 " to method get_brand_export_file" % key 3343 ) 3344 params[key] = val 3345 del params['kwargs'] 3346 # verify the required parameter 'account_id' is set 3347 if ('account_id' not in params) or (params['account_id'] is None): 3348 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_export_file`") 3349 # verify the required parameter 'brand_id' is set 3350 if ('brand_id' not in params) or (params['brand_id'] is None): 3351 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_export_file`") 3352 3353 3354 collection_formats = {} 3355 3356 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/file'.replace('{format}', 'json') 3357 path_params = {} 3358 if 'account_id' in params: 3359 path_params['accountId'] = params['account_id'] 3360 if 'brand_id' in params: 3361 path_params['brandId'] = params['brand_id'] 3362 3363 query_params = {} 3364 3365 header_params = {} 3366 3367 form_params = [] 3368 local_var_files = {} 3369 3370 body_params = None 3371 # HTTP header `Accept` 3372 header_params['Accept'] = self.api_client.\ 3373 select_header_accept(['application/json']) 3374 3375 # Authentication setting 3376 auth_settings = [] 3377 3378 return self.api_client.call_api(resource_path, 'GET', 3379 path_params, 3380 query_params, 3381 header_params, 3382 body=body_params, 3383 post_params=form_params, 3384 files=local_var_files, 3385 response_type=None, 3386 auth_settings=auth_settings, 3387 callback=params.get('callback'), 3388 _return_http_data_only=params.get('_return_http_data_only'), 3389 _preload_content=params.get('_preload_content', True), 3390 _request_timeout=params.get('_request_timeout'), 3391 collection_formats=collection_formats) 3392 3393 def get_brand_logo_by_type(self, account_id, brand_id, logo_type, **kwargs): 3394 """ 3395 Obtains the specified image for a brand. 3396 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**). 3397 This method makes a synchronous HTTP request by default. To make an 3398 asynchronous HTTP request, please define a `callback` function 3399 to be invoked when receiving the response. 3400 >>> def callback_function(response): 3401 >>> pprint(response) 3402 >>> 3403 >>> thread = api.get_brand_logo_by_type(account_id, brand_id, logo_type, callback=callback_function) 3404 3405 :param callback function: The callback function 3406 for asynchronous request. (optional) 3407 :param str account_id: The external account number (int) or account ID Guid. (required) 3408 :param str brand_id: The unique identifier of a brand. (required) 3409 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 3410 :return: file 3411 If the method is called asynchronously, 3412 returns the request thread. 3413 """ 3414 kwargs['_return_http_data_only'] = True 3415 if kwargs.get('callback'): 3416 return self.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 3417 else: 3418 (data) = self.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 3419 return data 3420 3421 def get_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, **kwargs): 3422 """ 3423 Obtains the specified image for a brand. 3424 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**). 3425 This method makes a synchronous HTTP request by default. To make an 3426 asynchronous HTTP request, please define a `callback` function 3427 to be invoked when receiving the response. 3428 >>> def callback_function(response): 3429 >>> pprint(response) 3430 >>> 3431 >>> thread = api.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, callback=callback_function) 3432 3433 :param callback function: The callback function 3434 for asynchronous request. (optional) 3435 :param str account_id: The external account number (int) or account ID Guid. (required) 3436 :param str brand_id: The unique identifier of a brand. (required) 3437 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 3438 :return: file 3439 If the method is called asynchronously, 3440 returns the request thread. 3441 """ 3442 3443 all_params = ['account_id', 'brand_id', 'logo_type'] 3444 all_params.append('callback') 3445 all_params.append('_return_http_data_only') 3446 all_params.append('_preload_content') 3447 all_params.append('_request_timeout') 3448 3449 params = locals() 3450 for key, val in iteritems(params['kwargs']): 3451 if key not in all_params: 3452 raise TypeError( 3453 "Got an unexpected keyword argument '%s'" 3454 " to method get_brand_logo_by_type" % key 3455 ) 3456 params[key] = val 3457 del params['kwargs'] 3458 # verify the required parameter 'account_id' is set 3459 if ('account_id' not in params) or (params['account_id'] is None): 3460 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_logo_by_type`") 3461 # verify the required parameter 'brand_id' is set 3462 if ('brand_id' not in params) or (params['brand_id'] is None): 3463 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_logo_by_type`") 3464 # verify the required parameter 'logo_type' is set 3465 if ('logo_type' not in params) or (params['logo_type'] is None): 3466 raise ValueError("Missing the required parameter `logo_type` when calling `get_brand_logo_by_type`") 3467 3468 3469 collection_formats = {} 3470 3471 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 3472 path_params = {} 3473 if 'account_id' in params: 3474 path_params['accountId'] = params['account_id'] 3475 if 'brand_id' in params: 3476 path_params['brandId'] = params['brand_id'] 3477 if 'logo_type' in params: 3478 path_params['logoType'] = params['logo_type'] 3479 3480 query_params = {} 3481 3482 header_params = {} 3483 3484 form_params = [] 3485 local_var_files = {} 3486 3487 body_params = None 3488 # HTTP header `Accept` 3489 header_params['Accept'] = self.api_client.\ 3490 select_header_accept(['image/png']) 3491 3492 # Authentication setting 3493 auth_settings = [] 3494 3495 return self.api_client.call_api(resource_path, 'GET', 3496 path_params, 3497 query_params, 3498 header_params, 3499 body=body_params, 3500 post_params=form_params, 3501 files=local_var_files, 3502 response_type='file', 3503 auth_settings=auth_settings, 3504 callback=params.get('callback'), 3505 _return_http_data_only=params.get('_return_http_data_only'), 3506 _preload_content=params.get('_preload_content', True), 3507 _request_timeout=params.get('_request_timeout'), 3508 collection_formats=collection_formats) 3509 3510 def get_brand_resources(self, account_id, brand_id, **kwargs): 3511 """ 3512 Returns the specified account's list of branding resources (metadata). 3513 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**). 3514 This method makes a synchronous HTTP request by default. To make an 3515 asynchronous HTTP request, please define a `callback` function 3516 to be invoked when receiving the response. 3517 >>> def callback_function(response): 3518 >>> pprint(response) 3519 >>> 3520 >>> thread = api.get_brand_resources(account_id, brand_id, callback=callback_function) 3521 3522 :param callback function: The callback function 3523 for asynchronous request. (optional) 3524 :param str account_id: The external account number (int) or account ID Guid. (required) 3525 :param str brand_id: The unique identifier of a brand. (required) 3526 :return: BrandResourcesList 3527 If the method is called asynchronously, 3528 returns the request thread. 3529 """ 3530 kwargs['_return_http_data_only'] = True 3531 if kwargs.get('callback'): 3532 return self.get_brand_resources_with_http_info(account_id, brand_id, **kwargs) 3533 else: 3534 (data) = self.get_brand_resources_with_http_info(account_id, brand_id, **kwargs) 3535 return data 3536 3537 def get_brand_resources_with_http_info(self, account_id, brand_id, **kwargs): 3538 """ 3539 Returns the specified account's list of branding resources (metadata). 3540 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**). 3541 This method makes a synchronous HTTP request by default. To make an 3542 asynchronous HTTP request, please define a `callback` function 3543 to be invoked when receiving the response. 3544 >>> def callback_function(response): 3545 >>> pprint(response) 3546 >>> 3547 >>> thread = api.get_brand_resources_with_http_info(account_id, brand_id, callback=callback_function) 3548 3549 :param callback function: The callback function 3550 for asynchronous request. (optional) 3551 :param str account_id: The external account number (int) or account ID Guid. (required) 3552 :param str brand_id: The unique identifier of a brand. (required) 3553 :return: BrandResourcesList 3554 If the method is called asynchronously, 3555 returns the request thread. 3556 """ 3557 3558 all_params = ['account_id', 'brand_id'] 3559 all_params.append('callback') 3560 all_params.append('_return_http_data_only') 3561 all_params.append('_preload_content') 3562 all_params.append('_request_timeout') 3563 3564 params = locals() 3565 for key, val in iteritems(params['kwargs']): 3566 if key not in all_params: 3567 raise TypeError( 3568 "Got an unexpected keyword argument '%s'" 3569 " to method get_brand_resources" % key 3570 ) 3571 params[key] = val 3572 del params['kwargs'] 3573 # verify the required parameter 'account_id' is set 3574 if ('account_id' not in params) or (params['account_id'] is None): 3575 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_resources`") 3576 # verify the required parameter 'brand_id' is set 3577 if ('brand_id' not in params) or (params['brand_id'] is None): 3578 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_resources`") 3579 3580 3581 collection_formats = {} 3582 3583 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources'.replace('{format}', 'json') 3584 path_params = {} 3585 if 'account_id' in params: 3586 path_params['accountId'] = params['account_id'] 3587 if 'brand_id' in params: 3588 path_params['brandId'] = params['brand_id'] 3589 3590 query_params = {} 3591 3592 header_params = {} 3593 3594 form_params = [] 3595 local_var_files = {} 3596 3597 body_params = None 3598 # HTTP header `Accept` 3599 header_params['Accept'] = self.api_client.\ 3600 select_header_accept(['application/json']) 3601 3602 # Authentication setting 3603 auth_settings = [] 3604 3605 return self.api_client.call_api(resource_path, 'GET', 3606 path_params, 3607 query_params, 3608 header_params, 3609 body=body_params, 3610 post_params=form_params, 3611 files=local_var_files, 3612 response_type='BrandResourcesList', 3613 auth_settings=auth_settings, 3614 callback=params.get('callback'), 3615 _return_http_data_only=params.get('_return_http_data_only'), 3616 _preload_content=params.get('_preload_content', True), 3617 _request_timeout=params.get('_request_timeout'), 3618 collection_formats=collection_formats) 3619 3620 def get_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, **kwargs): 3621 """ 3622 Returns the specified branding resource file. 3623 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**). 3624 This method makes a synchronous HTTP request by default. To make an 3625 asynchronous HTTP request, please define a `callback` function 3626 to be invoked when receiving the response. 3627 >>> def callback_function(response): 3628 >>> pprint(response) 3629 >>> 3630 >>> thread = api.get_brand_resources_by_content_type(account_id, brand_id, resource_content_type, callback=callback_function) 3631 3632 :param callback function: The callback function 3633 for asynchronous request. (optional) 3634 :param str account_id: The external account number (int) or account ID Guid. (required) 3635 :param str brand_id: The unique identifier of a brand. (required) 3636 :param str resource_content_type: (required) 3637 :param str langcode: 3638 :param str return_master: 3639 :return: None 3640 If the method is called asynchronously, 3641 returns the request thread. 3642 """ 3643 kwargs['_return_http_data_only'] = True 3644 if kwargs.get('callback'): 3645 return self.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, **kwargs) 3646 else: 3647 (data) = self.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, **kwargs) 3648 return data 3649 3650 def get_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, **kwargs): 3651 """ 3652 Returns the specified branding resource file. 3653 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**). 3654 This method makes a synchronous HTTP request by default. To make an 3655 asynchronous HTTP request, please define a `callback` function 3656 to be invoked when receiving the response. 3657 >>> def callback_function(response): 3658 >>> pprint(response) 3659 >>> 3660 >>> thread = api.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, callback=callback_function) 3661 3662 :param callback function: The callback function 3663 for asynchronous request. (optional) 3664 :param str account_id: The external account number (int) or account ID Guid. (required) 3665 :param str brand_id: The unique identifier of a brand. (required) 3666 :param str resource_content_type: (required) 3667 :param str langcode: 3668 :param str return_master: 3669 :return: None 3670 If the method is called asynchronously, 3671 returns the request thread. 3672 """ 3673 3674 all_params = ['account_id', 'brand_id', 'resource_content_type', 'langcode', 'return_master'] 3675 all_params.append('callback') 3676 all_params.append('_return_http_data_only') 3677 all_params.append('_preload_content') 3678 all_params.append('_request_timeout') 3679 3680 params = locals() 3681 for key, val in iteritems(params['kwargs']): 3682 if key not in all_params: 3683 raise TypeError( 3684 "Got an unexpected keyword argument '%s'" 3685 " to method get_brand_resources_by_content_type" % key 3686 ) 3687 params[key] = val 3688 del params['kwargs'] 3689 # verify the required parameter 'account_id' is set 3690 if ('account_id' not in params) or (params['account_id'] is None): 3691 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_resources_by_content_type`") 3692 # verify the required parameter 'brand_id' is set 3693 if ('brand_id' not in params) or (params['brand_id'] is None): 3694 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_resources_by_content_type`") 3695 # verify the required parameter 'resource_content_type' is set 3696 if ('resource_content_type' not in params) or (params['resource_content_type'] is None): 3697 raise ValueError("Missing the required parameter `resource_content_type` when calling `get_brand_resources_by_content_type`") 3698 3699 3700 collection_formats = {} 3701 3702 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources/{resourceContentType}'.replace('{format}', 'json') 3703 path_params = {} 3704 if 'account_id' in params: 3705 path_params['accountId'] = params['account_id'] 3706 if 'brand_id' in params: 3707 path_params['brandId'] = params['brand_id'] 3708 if 'resource_content_type' in params: 3709 path_params['resourceContentType'] = params['resource_content_type'] 3710 3711 query_params = {} 3712 if 'langcode' in params: 3713 query_params['langcode'] = params['langcode'] 3714 if 'return_master' in params: 3715 query_params['return_master'] = params['return_master'] 3716 3717 header_params = {} 3718 3719 form_params = [] 3720 local_var_files = {} 3721 3722 body_params = None 3723 # HTTP header `Accept` 3724 header_params['Accept'] = self.api_client.\ 3725 select_header_accept(['application/json']) 3726 3727 # Authentication setting 3728 auth_settings = [] 3729 3730 return self.api_client.call_api(resource_path, 'GET', 3731 path_params, 3732 query_params, 3733 header_params, 3734 body=body_params, 3735 post_params=form_params, 3736 files=local_var_files, 3737 response_type=None, 3738 auth_settings=auth_settings, 3739 callback=params.get('callback'), 3740 _return_http_data_only=params.get('_return_http_data_only'), 3741 _preload_content=params.get('_preload_content', True), 3742 _request_timeout=params.get('_request_timeout'), 3743 collection_formats=collection_formats) 3744 3745 def get_consumer_disclosure(self, account_id, lang_code, **kwargs): 3746 """ 3747 Gets the Electronic Record and Signature Disclosure. 3748 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. 3749 This method makes a synchronous HTTP request by default. To make an 3750 asynchronous HTTP request, please define a `callback` function 3751 to be invoked when receiving the response. 3752 >>> def callback_function(response): 3753 >>> pprint(response) 3754 >>> 3755 >>> thread = api.get_consumer_disclosure(account_id, lang_code, callback=callback_function) 3756 3757 :param callback function: The callback function 3758 for asynchronous request. (optional) 3759 :param str account_id: The external account number (int) or account ID Guid. (required) 3760 :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) 3761 :return: ConsumerDisclosure 3762 If the method is called asynchronously, 3763 returns the request thread. 3764 """ 3765 kwargs['_return_http_data_only'] = True 3766 if kwargs.get('callback'): 3767 return self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 3768 else: 3769 (data) = self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 3770 return data 3771 3772 def get_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs): 3773 """ 3774 Gets the Electronic Record and Signature Disclosure. 3775 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. 3776 This method makes a synchronous HTTP request by default. To make an 3777 asynchronous HTTP request, please define a `callback` function 3778 to be invoked when receiving the response. 3779 >>> def callback_function(response): 3780 >>> pprint(response) 3781 >>> 3782 >>> thread = api.get_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function) 3783 3784 :param callback function: The callback function 3785 for asynchronous request. (optional) 3786 :param str account_id: The external account number (int) or account ID Guid. (required) 3787 :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) 3788 :return: ConsumerDisclosure 3789 If the method is called asynchronously, 3790 returns the request thread. 3791 """ 3792 3793 all_params = ['account_id', 'lang_code'] 3794 all_params.append('callback') 3795 all_params.append('_return_http_data_only') 3796 all_params.append('_preload_content') 3797 all_params.append('_request_timeout') 3798 3799 params = locals() 3800 for key, val in iteritems(params['kwargs']): 3801 if key not in all_params: 3802 raise TypeError( 3803 "Got an unexpected keyword argument '%s'" 3804 " to method get_consumer_disclosure" % key 3805 ) 3806 params[key] = val 3807 del params['kwargs'] 3808 # verify the required parameter 'account_id' is set 3809 if ('account_id' not in params) or (params['account_id'] is None): 3810 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure`") 3811 # verify the required parameter 'lang_code' is set 3812 if ('lang_code' not in params) or (params['lang_code'] is None): 3813 raise ValueError("Missing the required parameter `lang_code` when calling `get_consumer_disclosure`") 3814 3815 3816 collection_formats = {} 3817 3818 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 3819 path_params = {} 3820 if 'account_id' in params: 3821 path_params['accountId'] = params['account_id'] 3822 if 'lang_code' in params: 3823 path_params['langCode'] = params['lang_code'] 3824 3825 query_params = {} 3826 3827 header_params = {} 3828 3829 form_params = [] 3830 local_var_files = {} 3831 3832 body_params = None 3833 # HTTP header `Accept` 3834 header_params['Accept'] = self.api_client.\ 3835 select_header_accept(['application/json']) 3836 3837 # Authentication setting 3838 auth_settings = [] 3839 3840 return self.api_client.call_api(resource_path, 'GET', 3841 path_params, 3842 query_params, 3843 header_params, 3844 body=body_params, 3845 post_params=form_params, 3846 files=local_var_files, 3847 response_type='ConsumerDisclosure', 3848 auth_settings=auth_settings, 3849 callback=params.get('callback'), 3850 _return_http_data_only=params.get('_return_http_data_only'), 3851 _preload_content=params.get('_preload_content', True), 3852 _request_timeout=params.get('_request_timeout'), 3853 collection_formats=collection_formats) 3854 3855 def get_consumer_disclosure_default(self, account_id, **kwargs): 3856 """ 3857 Gets the Electronic Record and Signature Disclosure for the account. 3858 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. 3859 This method makes a synchronous HTTP request by default. To make an 3860 asynchronous HTTP request, please define a `callback` function 3861 to be invoked when receiving the response. 3862 >>> def callback_function(response): 3863 >>> pprint(response) 3864 >>> 3865 >>> thread = api.get_consumer_disclosure_default(account_id, callback=callback_function) 3866 3867 :param callback function: The callback function 3868 for asynchronous request. (optional) 3869 :param str account_id: The external account number (int) or account ID Guid. (required) 3870 :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. 3871 :return: ConsumerDisclosure 3872 If the method is called asynchronously, 3873 returns the request thread. 3874 """ 3875 kwargs['_return_http_data_only'] = True 3876 if kwargs.get('callback'): 3877 return self.get_consumer_disclosure_default_with_http_info(account_id, **kwargs) 3878 else: 3879 (data) = self.get_consumer_disclosure_default_with_http_info(account_id, **kwargs) 3880 return data 3881 3882 def get_consumer_disclosure_default_with_http_info(self, account_id, **kwargs): 3883 """ 3884 Gets the Electronic Record and Signature Disclosure for the account. 3885 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. 3886 This method makes a synchronous HTTP request by default. To make an 3887 asynchronous HTTP request, please define a `callback` function 3888 to be invoked when receiving the response. 3889 >>> def callback_function(response): 3890 >>> pprint(response) 3891 >>> 3892 >>> thread = api.get_consumer_disclosure_default_with_http_info(account_id, callback=callback_function) 3893 3894 :param callback function: The callback function 3895 for asynchronous request. (optional) 3896 :param str account_id: The external account number (int) or account ID Guid. (required) 3897 :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. 3898 :return: ConsumerDisclosure 3899 If the method is called asynchronously, 3900 returns the request thread. 3901 """ 3902 3903 all_params = ['account_id', 'lang_code'] 3904 all_params.append('callback') 3905 all_params.append('_return_http_data_only') 3906 all_params.append('_preload_content') 3907 all_params.append('_request_timeout') 3908 3909 params = locals() 3910 for key, val in iteritems(params['kwargs']): 3911 if key not in all_params: 3912 raise TypeError( 3913 "Got an unexpected keyword argument '%s'" 3914 " to method get_consumer_disclosure_default" % key 3915 ) 3916 params[key] = val 3917 del params['kwargs'] 3918 # verify the required parameter 'account_id' is set 3919 if ('account_id' not in params) or (params['account_id'] is None): 3920 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure_default`") 3921 3922 3923 collection_formats = {} 3924 3925 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure'.replace('{format}', 'json') 3926 path_params = {} 3927 if 'account_id' in params: 3928 path_params['accountId'] = params['account_id'] 3929 3930 query_params = {} 3931 if 'lang_code' in params: 3932 query_params['langCode'] = params['lang_code'] 3933 3934 header_params = {} 3935 3936 form_params = [] 3937 local_var_files = {} 3938 3939 body_params = None 3940 # HTTP header `Accept` 3941 header_params['Accept'] = self.api_client.\ 3942 select_header_accept(['application/json']) 3943 3944 # Authentication setting 3945 auth_settings = [] 3946 3947 return self.api_client.call_api(resource_path, 'GET', 3948 path_params, 3949 query_params, 3950 header_params, 3951 body=body_params, 3952 post_params=form_params, 3953 files=local_var_files, 3954 response_type='ConsumerDisclosure', 3955 auth_settings=auth_settings, 3956 callback=params.get('callback'), 3957 _return_http_data_only=params.get('_return_http_data_only'), 3958 _preload_content=params.get('_preload_content', True), 3959 _request_timeout=params.get('_request_timeout'), 3960 collection_formats=collection_formats) 3961 3962 def get_e_note_configuration(self, account_id, **kwargs): 3963 """ 3964 Returns the configuration information for the eNote eOriginal integration. 3965 3966 This method makes a synchronous HTTP request by default. To make an 3967 asynchronous HTTP request, please define a `callback` function 3968 to be invoked when receiving the response. 3969 >>> def callback_function(response): 3970 >>> pprint(response) 3971 >>> 3972 >>> thread = api.get_e_note_configuration(account_id, callback=callback_function) 3973 3974 :param callback function: The callback function 3975 for asynchronous request. (optional) 3976 :param str account_id: The external account number (int) or account ID Guid. (required) 3977 :return: ENoteConfiguration 3978 If the method is called asynchronously, 3979 returns the request thread. 3980 """ 3981 kwargs['_return_http_data_only'] = True 3982 if kwargs.get('callback'): 3983 return self.get_e_note_configuration_with_http_info(account_id, **kwargs) 3984 else: 3985 (data) = self.get_e_note_configuration_with_http_info(account_id, **kwargs) 3986 return data 3987 3988 def get_e_note_configuration_with_http_info(self, account_id, **kwargs): 3989 """ 3990 Returns the configuration information for the eNote eOriginal integration. 3991 3992 This method makes a synchronous HTTP request by default. To make an 3993 asynchronous HTTP request, please define a `callback` function 3994 to be invoked when receiving the response. 3995 >>> def callback_function(response): 3996 >>> pprint(response) 3997 >>> 3998 >>> thread = api.get_e_note_configuration_with_http_info(account_id, callback=callback_function) 3999 4000 :param callback function: The callback function 4001 for asynchronous request. (optional) 4002 :param str account_id: The external account number (int) or account ID Guid. (required) 4003 :return: ENoteConfiguration 4004 If the method is called asynchronously, 4005 returns the request thread. 4006 """ 4007 4008 all_params = ['account_id'] 4009 all_params.append('callback') 4010 all_params.append('_return_http_data_only') 4011 all_params.append('_preload_content') 4012 all_params.append('_request_timeout') 4013 4014 params = locals() 4015 for key, val in iteritems(params['kwargs']): 4016 if key not in all_params: 4017 raise TypeError( 4018 "Got an unexpected keyword argument '%s'" 4019 " to method get_e_note_configuration" % key 4020 ) 4021 params[key] = val 4022 del params['kwargs'] 4023 # verify the required parameter 'account_id' is set 4024 if ('account_id' not in params) or (params['account_id'] is None): 4025 raise ValueError("Missing the required parameter `account_id` when calling `get_e_note_configuration`") 4026 4027 4028 collection_formats = {} 4029 4030 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 4031 path_params = {} 4032 if 'account_id' in params: 4033 path_params['accountId'] = params['account_id'] 4034 4035 query_params = {} 4036 4037 header_params = {} 4038 4039 form_params = [] 4040 local_var_files = {} 4041 4042 body_params = None 4043 # HTTP header `Accept` 4044 header_params['Accept'] = self.api_client.\ 4045 select_header_accept(['application/json']) 4046 4047 # Authentication setting 4048 auth_settings = [] 4049 4050 return self.api_client.call_api(resource_path, 'GET', 4051 path_params, 4052 query_params, 4053 header_params, 4054 body=body_params, 4055 post_params=form_params, 4056 files=local_var_files, 4057 response_type='ENoteConfiguration', 4058 auth_settings=auth_settings, 4059 callback=params.get('callback'), 4060 _return_http_data_only=params.get('_return_http_data_only'), 4061 _preload_content=params.get('_preload_content', True), 4062 _request_timeout=params.get('_request_timeout'), 4063 collection_formats=collection_formats) 4064 4065 def get_envelope_purge_configuration(self, account_id, **kwargs): 4066 """ 4067 Select envelope purge configuration. 4068 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. 4069 This method makes a synchronous HTTP request by default. To make an 4070 asynchronous HTTP request, please define a `callback` function 4071 to be invoked when receiving the response. 4072 >>> def callback_function(response): 4073 >>> pprint(response) 4074 >>> 4075 >>> thread = api.get_envelope_purge_configuration(account_id, callback=callback_function) 4076 4077 :param callback function: The callback function 4078 for asynchronous request. (optional) 4079 :param str account_id: The external account number (int) or account ID Guid. (required) 4080 :return: EnvelopePurgeConfiguration 4081 If the method is called asynchronously, 4082 returns the request thread. 4083 """ 4084 kwargs['_return_http_data_only'] = True 4085 if kwargs.get('callback'): 4086 return self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs) 4087 else: 4088 (data) = self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs) 4089 return data 4090 4091 def get_envelope_purge_configuration_with_http_info(self, account_id, **kwargs): 4092 """ 4093 Select envelope purge configuration. 4094 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. 4095 This method makes a synchronous HTTP request by default. To make an 4096 asynchronous HTTP request, please define a `callback` function 4097 to be invoked when receiving the response. 4098 >>> def callback_function(response): 4099 >>> pprint(response) 4100 >>> 4101 >>> thread = api.get_envelope_purge_configuration_with_http_info(account_id, callback=callback_function) 4102 4103 :param callback function: The callback function 4104 for asynchronous request. (optional) 4105 :param str account_id: The external account number (int) or account ID Guid. (required) 4106 :return: EnvelopePurgeConfiguration 4107 If the method is called asynchronously, 4108 returns the request thread. 4109 """ 4110 4111 all_params = ['account_id'] 4112 all_params.append('callback') 4113 all_params.append('_return_http_data_only') 4114 all_params.append('_preload_content') 4115 all_params.append('_request_timeout') 4116 4117 params = locals() 4118 for key, val in iteritems(params['kwargs']): 4119 if key not in all_params: 4120 raise TypeError( 4121 "Got an unexpected keyword argument '%s'" 4122 " to method get_envelope_purge_configuration" % key 4123 ) 4124 params[key] = val 4125 del params['kwargs'] 4126 # verify the required parameter 'account_id' is set 4127 if ('account_id' not in params) or (params['account_id'] is None): 4128 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_purge_configuration`") 4129 4130 4131 collection_formats = {} 4132 4133 resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json') 4134 path_params = {} 4135 if 'account_id' in params: 4136 path_params['accountId'] = params['account_id'] 4137 4138 query_params = {} 4139 4140 header_params = {} 4141 4142 form_params = [] 4143 local_var_files = {} 4144 4145 body_params = None 4146 # HTTP header `Accept` 4147 header_params['Accept'] = self.api_client.\ 4148 select_header_accept(['application/json']) 4149 4150 # Authentication setting 4151 auth_settings = [] 4152 4153 return self.api_client.call_api(resource_path, 'GET', 4154 path_params, 4155 query_params, 4156 header_params, 4157 body=body_params, 4158 post_params=form_params, 4159 files=local_var_files, 4160 response_type='EnvelopePurgeConfiguration', 4161 auth_settings=auth_settings, 4162 callback=params.get('callback'), 4163 _return_http_data_only=params.get('_return_http_data_only'), 4164 _preload_content=params.get('_preload_content', True), 4165 _request_timeout=params.get('_request_timeout'), 4166 collection_formats=collection_formats) 4167 4168 def get_favorite_templates(self, account_id, **kwargs): 4169 """ 4170 Retrieves the list of favorited templates for this caller 4171 4172 This method makes a synchronous HTTP request by default. To make an 4173 asynchronous HTTP request, please define a `callback` function 4174 to be invoked when receiving the response. 4175 >>> def callback_function(response): 4176 >>> pprint(response) 4177 >>> 4178 >>> thread = api.get_favorite_templates(account_id, callback=callback_function) 4179 4180 :param callback function: The callback function 4181 for asynchronous request. (optional) 4182 :param str account_id: The external account number (int) or account ID Guid. (required) 4183 :return: FavoriteTemplatesInfo 4184 If the method is called asynchronously, 4185 returns the request thread. 4186 """ 4187 kwargs['_return_http_data_only'] = True 4188 if kwargs.get('callback'): 4189 return self.get_favorite_templates_with_http_info(account_id, **kwargs) 4190 else: 4191 (data) = self.get_favorite_templates_with_http_info(account_id, **kwargs) 4192 return data 4193 4194 def get_favorite_templates_with_http_info(self, account_id, **kwargs): 4195 """ 4196 Retrieves the list of favorited templates for this caller 4197 4198 This method makes a synchronous HTTP request by default. To make an 4199 asynchronous HTTP request, please define a `callback` function 4200 to be invoked when receiving the response. 4201 >>> def callback_function(response): 4202 >>> pprint(response) 4203 >>> 4204 >>> thread = api.get_favorite_templates_with_http_info(account_id, callback=callback_function) 4205 4206 :param callback function: The callback function 4207 for asynchronous request. (optional) 4208 :param str account_id: The external account number (int) or account ID Guid. (required) 4209 :return: FavoriteTemplatesInfo 4210 If the method is called asynchronously, 4211 returns the request thread. 4212 """ 4213 4214 all_params = ['account_id'] 4215 all_params.append('callback') 4216 all_params.append('_return_http_data_only') 4217 all_params.append('_preload_content') 4218 all_params.append('_request_timeout') 4219 4220 params = locals() 4221 for key, val in iteritems(params['kwargs']): 4222 if key not in all_params: 4223 raise TypeError( 4224 "Got an unexpected keyword argument '%s'" 4225 " to method get_favorite_templates" % key 4226 ) 4227 params[key] = val 4228 del params['kwargs'] 4229 # verify the required parameter 'account_id' is set 4230 if ('account_id' not in params) or (params['account_id'] is None): 4231 raise ValueError("Missing the required parameter `account_id` when calling `get_favorite_templates`") 4232 4233 4234 collection_formats = {} 4235 4236 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 4237 path_params = {} 4238 if 'account_id' in params: 4239 path_params['accountId'] = params['account_id'] 4240 4241 query_params = {} 4242 4243 header_params = {} 4244 4245 form_params = [] 4246 local_var_files = {} 4247 4248 body_params = None 4249 # HTTP header `Accept` 4250 header_params['Accept'] = self.api_client.\ 4251 select_header_accept(['application/json']) 4252 4253 # Authentication setting 4254 auth_settings = [] 4255 4256 return self.api_client.call_api(resource_path, 'GET', 4257 path_params, 4258 query_params, 4259 header_params, 4260 body=body_params, 4261 post_params=form_params, 4262 files=local_var_files, 4263 response_type='FavoriteTemplatesInfo', 4264 auth_settings=auth_settings, 4265 callback=params.get('callback'), 4266 _return_http_data_only=params.get('_return_http_data_only'), 4267 _preload_content=params.get('_preload_content', True), 4268 _request_timeout=params.get('_request_timeout'), 4269 collection_formats=collection_formats) 4270 4271 def get_notification_defaults(self, account_id, **kwargs): 4272 """ 4273 Returns default user level settings for a specified account 4274 This method returns the default settings for the email notifications that signers and senders receive about envelopes. 4275 This method makes a synchronous HTTP request by default. To make an 4276 asynchronous HTTP request, please define a `callback` function 4277 to be invoked when receiving the response. 4278 >>> def callback_function(response): 4279 >>> pprint(response) 4280 >>> 4281 >>> thread = api.get_notification_defaults(account_id, callback=callback_function) 4282 4283 :param callback function: The callback function 4284 for asynchronous request. (optional) 4285 :param str account_id: The external account number (int) or account ID Guid. (required) 4286 :return: NotificationDefaults 4287 If the method is called asynchronously, 4288 returns the request thread. 4289 """ 4290 kwargs['_return_http_data_only'] = True 4291 if kwargs.get('callback'): 4292 return self.get_notification_defaults_with_http_info(account_id, **kwargs) 4293 else: 4294 (data) = self.get_notification_defaults_with_http_info(account_id, **kwargs) 4295 return data 4296 4297 def get_notification_defaults_with_http_info(self, account_id, **kwargs): 4298 """ 4299 Returns default user level settings for a specified account 4300 This method returns the default settings for the email notifications that signers and senders receive about envelopes. 4301 This method makes a synchronous HTTP request by default. To make an 4302 asynchronous HTTP request, please define a `callback` function 4303 to be invoked when receiving the response. 4304 >>> def callback_function(response): 4305 >>> pprint(response) 4306 >>> 4307 >>> thread = api.get_notification_defaults_with_http_info(account_id, callback=callback_function) 4308 4309 :param callback function: The callback function 4310 for asynchronous request. (optional) 4311 :param str account_id: The external account number (int) or account ID Guid. (required) 4312 :return: NotificationDefaults 4313 If the method is called asynchronously, 4314 returns the request thread. 4315 """ 4316 4317 all_params = ['account_id'] 4318 all_params.append('callback') 4319 all_params.append('_return_http_data_only') 4320 all_params.append('_preload_content') 4321 all_params.append('_request_timeout') 4322 4323 params = locals() 4324 for key, val in iteritems(params['kwargs']): 4325 if key not in all_params: 4326 raise TypeError( 4327 "Got an unexpected keyword argument '%s'" 4328 " to method get_notification_defaults" % key 4329 ) 4330 params[key] = val 4331 del params['kwargs'] 4332 # verify the required parameter 'account_id' is set 4333 if ('account_id' not in params) or (params['account_id'] is None): 4334 raise ValueError("Missing the required parameter `account_id` when calling `get_notification_defaults`") 4335 4336 4337 collection_formats = {} 4338 4339 resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json') 4340 path_params = {} 4341 if 'account_id' in params: 4342 path_params['accountId'] = params['account_id'] 4343 4344 query_params = {} 4345 4346 header_params = {} 4347 4348 form_params = [] 4349 local_var_files = {} 4350 4351 body_params = None 4352 # HTTP header `Accept` 4353 header_params['Accept'] = self.api_client.\ 4354 select_header_accept(['application/json']) 4355 4356 # Authentication setting 4357 auth_settings = [] 4358 4359 return self.api_client.call_api(resource_path, 'GET', 4360 path_params, 4361 query_params, 4362 header_params, 4363 body=body_params, 4364 post_params=form_params, 4365 files=local_var_files, 4366 response_type='NotificationDefaults', 4367 auth_settings=auth_settings, 4368 callback=params.get('callback'), 4369 _return_http_data_only=params.get('_return_http_data_only'), 4370 _preload_content=params.get('_preload_content', True), 4371 _request_timeout=params.get('_request_timeout'), 4372 collection_formats=collection_formats) 4373 4374 def get_password_rules(self, account_id, **kwargs): 4375 """ 4376 Get the password rules 4377 This method retrieves the password rules for an account. 4378 This method makes a synchronous HTTP request by default. To make an 4379 asynchronous HTTP request, please define a `callback` function 4380 to be invoked when receiving the response. 4381 >>> def callback_function(response): 4382 >>> pprint(response) 4383 >>> 4384 >>> thread = api.get_password_rules(account_id, callback=callback_function) 4385 4386 :param callback function: The callback function 4387 for asynchronous request. (optional) 4388 :param str account_id: The external account number (int) or account ID Guid. (required) 4389 :return: AccountPasswordRules 4390 If the method is called asynchronously, 4391 returns the request thread. 4392 """ 4393 kwargs['_return_http_data_only'] = True 4394 if kwargs.get('callback'): 4395 return self.get_password_rules_with_http_info(account_id, **kwargs) 4396 else: 4397 (data) = self.get_password_rules_with_http_info(account_id, **kwargs) 4398 return data 4399 4400 def get_password_rules_with_http_info(self, account_id, **kwargs): 4401 """ 4402 Get the password rules 4403 This method retrieves the password rules for an account. 4404 This method makes a synchronous HTTP request by default. To make an 4405 asynchronous HTTP request, please define a `callback` function 4406 to be invoked when receiving the response. 4407 >>> def callback_function(response): 4408 >>> pprint(response) 4409 >>> 4410 >>> thread = api.get_password_rules_with_http_info(account_id, callback=callback_function) 4411 4412 :param callback function: The callback function 4413 for asynchronous request. (optional) 4414 :param str account_id: The external account number (int) or account ID Guid. (required) 4415 :return: AccountPasswordRules 4416 If the method is called asynchronously, 4417 returns the request thread. 4418 """ 4419 4420 all_params = ['account_id'] 4421 all_params.append('callback') 4422 all_params.append('_return_http_data_only') 4423 all_params.append('_preload_content') 4424 all_params.append('_request_timeout') 4425 4426 params = locals() 4427 for key, val in iteritems(params['kwargs']): 4428 if key not in all_params: 4429 raise TypeError( 4430 "Got an unexpected keyword argument '%s'" 4431 " to method get_password_rules" % key 4432 ) 4433 params[key] = val 4434 del params['kwargs'] 4435 # verify the required parameter 'account_id' is set 4436 if ('account_id' not in params) or (params['account_id'] is None): 4437 raise ValueError("Missing the required parameter `account_id` when calling `get_password_rules`") 4438 4439 4440 collection_formats = {} 4441 4442 resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json') 4443 path_params = {} 4444 if 'account_id' in params: 4445 path_params['accountId'] = params['account_id'] 4446 4447 query_params = {} 4448 4449 header_params = {} 4450 4451 form_params = [] 4452 local_var_files = {} 4453 4454 body_params = None 4455 # HTTP header `Accept` 4456 header_params['Accept'] = self.api_client.\ 4457 select_header_accept(['application/json']) 4458 4459 # Authentication setting 4460 auth_settings = [] 4461 4462 return self.api_client.call_api(resource_path, 'GET', 4463 path_params, 4464 query_params, 4465 header_params, 4466 body=body_params, 4467 post_params=form_params, 4468 files=local_var_files, 4469 response_type='AccountPasswordRules', 4470 auth_settings=auth_settings, 4471 callback=params.get('callback'), 4472 _return_http_data_only=params.get('_return_http_data_only'), 4473 _preload_content=params.get('_preload_content', True), 4474 _request_timeout=params.get('_request_timeout'), 4475 collection_formats=collection_formats) 4476 4477 def get_password_rules_0(self, **kwargs): 4478 """ 4479 Get membership account password rules 4480 4481 This method makes a synchronous HTTP request by default. To make an 4482 asynchronous HTTP request, please define a `callback` function 4483 to be invoked when receiving the response. 4484 >>> def callback_function(response): 4485 >>> pprint(response) 4486 >>> 4487 >>> thread = api.get_password_rules_0(callback=callback_function) 4488 4489 :param callback function: The callback function 4490 for asynchronous request. (optional) 4491 :return: UserPasswordRules 4492 If the method is called asynchronously, 4493 returns the request thread. 4494 """ 4495 kwargs['_return_http_data_only'] = True 4496 if kwargs.get('callback'): 4497 return self.get_password_rules_0_with_http_info(**kwargs) 4498 else: 4499 (data) = self.get_password_rules_0_with_http_info(**kwargs) 4500 return data 4501 4502 def get_password_rules_0_with_http_info(self, **kwargs): 4503 """ 4504 Get membership account password rules 4505 4506 This method makes a synchronous HTTP request by default. To make an 4507 asynchronous HTTP request, please define a `callback` function 4508 to be invoked when receiving the response. 4509 >>> def callback_function(response): 4510 >>> pprint(response) 4511 >>> 4512 >>> thread = api.get_password_rules_0_with_http_info(callback=callback_function) 4513 4514 :param callback function: The callback function 4515 for asynchronous request. (optional) 4516 :return: UserPasswordRules 4517 If the method is called asynchronously, 4518 returns the request thread. 4519 """ 4520 4521 all_params = [] 4522 all_params.append('callback') 4523 all_params.append('_return_http_data_only') 4524 all_params.append('_preload_content') 4525 all_params.append('_request_timeout') 4526 4527 params = locals() 4528 for key, val in iteritems(params['kwargs']): 4529 if key not in all_params: 4530 raise TypeError( 4531 "Got an unexpected keyword argument '%s'" 4532 " to method get_password_rules_0" % key 4533 ) 4534 params[key] = val 4535 del params['kwargs'] 4536 4537 collection_formats = {} 4538 4539 resource_path = '/v2.1/current_user/password_rules'.replace('{format}', 'json') 4540 path_params = {} 4541 4542 query_params = {} 4543 4544 header_params = {} 4545 4546 form_params = [] 4547 local_var_files = {} 4548 4549 body_params = None 4550 # HTTP header `Accept` 4551 header_params['Accept'] = self.api_client.\ 4552 select_header_accept(['application/json']) 4553 4554 # Authentication setting 4555 auth_settings = [] 4556 4557 return self.api_client.call_api(resource_path, 'GET', 4558 path_params, 4559 query_params, 4560 header_params, 4561 body=body_params, 4562 post_params=form_params, 4563 files=local_var_files, 4564 response_type='UserPasswordRules', 4565 auth_settings=auth_settings, 4566 callback=params.get('callback'), 4567 _return_http_data_only=params.get('_return_http_data_only'), 4568 _preload_content=params.get('_preload_content', True), 4569 _request_timeout=params.get('_request_timeout'), 4570 collection_formats=collection_formats) 4571 4572 def get_permission_profile(self, account_id, permission_profile_id, **kwargs): 4573 """ 4574 Returns a permissions profile in the specified account. 4575 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/) 4576 This method makes a synchronous HTTP request by default. To make an 4577 asynchronous HTTP request, please define a `callback` function 4578 to be invoked when receiving the response. 4579 >>> def callback_function(response): 4580 >>> pprint(response) 4581 >>> 4582 >>> thread = api.get_permission_profile(account_id, permission_profile_id, callback=callback_function) 4583 4584 :param callback function: The callback function 4585 for asynchronous request. (optional) 4586 :param str account_id: The external account number (int) or account ID Guid. (required) 4587 :param str permission_profile_id: (required) 4588 :param str include: 4589 :return: PermissionProfile 4590 If the method is called asynchronously, 4591 returns the request thread. 4592 """ 4593 kwargs['_return_http_data_only'] = True 4594 if kwargs.get('callback'): 4595 return self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 4596 else: 4597 (data) = self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 4598 return data 4599 4600 def get_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 4601 """ 4602 Returns a permissions profile in the specified account. 4603 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/) 4604 This method makes a synchronous HTTP request by default. To make an 4605 asynchronous HTTP request, please define a `callback` function 4606 to be invoked when receiving the response. 4607 >>> def callback_function(response): 4608 >>> pprint(response) 4609 >>> 4610 >>> thread = api.get_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 4611 4612 :param callback function: The callback function 4613 for asynchronous request. (optional) 4614 :param str account_id: The external account number (int) or account ID Guid. (required) 4615 :param str permission_profile_id: (required) 4616 :param str include: 4617 :return: PermissionProfile 4618 If the method is called asynchronously, 4619 returns the request thread. 4620 """ 4621 4622 all_params = ['account_id', 'permission_profile_id', 'include'] 4623 all_params.append('callback') 4624 all_params.append('_return_http_data_only') 4625 all_params.append('_preload_content') 4626 all_params.append('_request_timeout') 4627 4628 params = locals() 4629 for key, val in iteritems(params['kwargs']): 4630 if key not in all_params: 4631 raise TypeError( 4632 "Got an unexpected keyword argument '%s'" 4633 " to method get_permission_profile" % key 4634 ) 4635 params[key] = val 4636 del params['kwargs'] 4637 # verify the required parameter 'account_id' is set 4638 if ('account_id' not in params) or (params['account_id'] is None): 4639 raise ValueError("Missing the required parameter `account_id` when calling `get_permission_profile`") 4640 # verify the required parameter 'permission_profile_id' is set 4641 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 4642 raise ValueError("Missing the required parameter `permission_profile_id` when calling `get_permission_profile`") 4643 4644 4645 collection_formats = {} 4646 4647 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 4648 path_params = {} 4649 if 'account_id' in params: 4650 path_params['accountId'] = params['account_id'] 4651 if 'permission_profile_id' in params: 4652 path_params['permissionProfileId'] = params['permission_profile_id'] 4653 4654 query_params = {} 4655 if 'include' in params: 4656 query_params['include'] = params['include'] 4657 4658 header_params = {} 4659 4660 form_params = [] 4661 local_var_files = {} 4662 4663 body_params = None 4664 # HTTP header `Accept` 4665 header_params['Accept'] = self.api_client.\ 4666 select_header_accept(['application/json']) 4667 4668 # Authentication setting 4669 auth_settings = [] 4670 4671 return self.api_client.call_api(resource_path, 'GET', 4672 path_params, 4673 query_params, 4674 header_params, 4675 body=body_params, 4676 post_params=form_params, 4677 files=local_var_files, 4678 response_type='PermissionProfile', 4679 auth_settings=auth_settings, 4680 callback=params.get('callback'), 4681 _return_http_data_only=params.get('_return_http_data_only'), 4682 _preload_content=params.get('_preload_content', True), 4683 _request_timeout=params.get('_request_timeout'), 4684 collection_formats=collection_formats) 4685 4686 def get_principal_user_authorizations(self, account_id, user_id, **kwargs): 4687 """ 4688 Returns the principal user authorizations 4689 This method makes a synchronous HTTP request by default. To make an 4690 asynchronous HTTP request, please define a `callback` function 4691 to be invoked when receiving the response. 4692 >>> def callback_function(response): 4693 >>> pprint(response) 4694 >>> 4695 >>> thread = api.get_principal_user_authorizations(account_id, user_id, callback=callback_function) 4696 4697 :param callback function: The callback function 4698 for asynchronous request. (optional) 4699 :param str account_id: The external account number (int) or account ID Guid. (required) 4700 :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) 4701 :param str active_only: 4702 :param str count: 4703 :param str email_substring: Part (substring) of email we are searching for. 4704 :param str include_closed_users: 4705 :param str permissions: 4706 :param str start_position: 4707 :param str user_name_substring: 4708 :return: UserAuthorizations 4709 If the method is called asynchronously, 4710 returns the request thread. 4711 """ 4712 kwargs['_return_http_data_only'] = True 4713 if kwargs.get('callback'): 4714 return self.get_principal_user_authorizations_with_http_info(account_id, user_id, **kwargs) 4715 else: 4716 (data) = self.get_principal_user_authorizations_with_http_info(account_id, user_id, **kwargs) 4717 return data 4718 4719 def get_principal_user_authorizations_with_http_info(self, account_id, user_id, **kwargs): 4720 """ 4721 Returns the principal user authorizations 4722 This method makes a synchronous HTTP request by default. To make an 4723 asynchronous HTTP request, please define a `callback` function 4724 to be invoked when receiving the response. 4725 >>> def callback_function(response): 4726 >>> pprint(response) 4727 >>> 4728 >>> thread = api.get_principal_user_authorizations_with_http_info(account_id, user_id, callback=callback_function) 4729 4730 :param callback function: The callback function 4731 for asynchronous request. (optional) 4732 :param str account_id: The external account number (int) or account ID Guid. (required) 4733 :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) 4734 :param str active_only: 4735 :param str count: 4736 :param str email_substring: Part (substring) of email we are searching for. 4737 :param str include_closed_users: 4738 :param str permissions: 4739 :param str start_position: 4740 :param str user_name_substring: 4741 :return: UserAuthorizations 4742 If the method is called asynchronously, 4743 returns the request thread. 4744 """ 4745 4746 all_params = ['account_id', 'user_id', 'active_only', 'count', 'email_substring', 'include_closed_users', 'permissions', 'start_position', 'user_name_substring'] 4747 all_params.append('callback') 4748 all_params.append('_return_http_data_only') 4749 all_params.append('_preload_content') 4750 all_params.append('_request_timeout') 4751 4752 params = locals() 4753 for key, val in iteritems(params['kwargs']): 4754 if key not in all_params: 4755 raise TypeError( 4756 "Got an unexpected keyword argument '%s'" 4757 " to method get_principal_user_authorizations" % key 4758 ) 4759 params[key] = val 4760 del params['kwargs'] 4761 # verify the required parameter 'account_id' is set 4762 if ('account_id' not in params) or (params['account_id'] is None): 4763 raise ValueError("Missing the required parameter `account_id` when calling `get_principal_user_authorizations`") 4764 # verify the required parameter 'user_id' is set 4765 if ('user_id' not in params) or (params['user_id'] is None): 4766 raise ValueError("Missing the required parameter `user_id` when calling `get_principal_user_authorizations`") 4767 4768 4769 collection_formats = {} 4770 4771 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorizations'.replace('{format}', 'json') 4772 path_params = {} 4773 if 'account_id' in params: 4774 path_params['accountId'] = params['account_id'] 4775 if 'user_id' in params: 4776 path_params['userId'] = params['user_id'] 4777 4778 query_params = {} 4779 if 'active_only' in params: 4780 query_params['active_only'] = params['active_only'] 4781 if 'count' in params: 4782 query_params['count'] = params['count'] 4783 if 'email_substring' in params: 4784 query_params['email_substring'] = params['email_substring'] 4785 if 'include_closed_users' in params: 4786 query_params['include_closed_users'] = params['include_closed_users'] 4787 if 'permissions' in params: 4788 query_params['permissions'] = params['permissions'] 4789 if 'start_position' in params: 4790 query_params['start_position'] = params['start_position'] 4791 if 'user_name_substring' in params: 4792 query_params['user_name_substring'] = params['user_name_substring'] 4793 4794 header_params = {} 4795 4796 form_params = [] 4797 local_var_files = {} 4798 4799 body_params = None 4800 # HTTP header `Accept` 4801 header_params['Accept'] = self.api_client.\ 4802 select_header_accept(['application/json']) 4803 4804 # Authentication setting 4805 auth_settings = [] 4806 4807 return self.api_client.call_api(resource_path, 'GET', 4808 path_params, 4809 query_params, 4810 header_params, 4811 body=body_params, 4812 post_params=form_params, 4813 files=local_var_files, 4814 response_type='UserAuthorizations', 4815 auth_settings=auth_settings, 4816 callback=params.get('callback'), 4817 _return_http_data_only=params.get('_return_http_data_only'), 4818 _preload_content=params.get('_preload_content', True), 4819 _request_timeout=params.get('_request_timeout'), 4820 collection_formats=collection_formats) 4821 4822 def get_provisioning(self, **kwargs): 4823 """ 4824 Retrieves the account provisioning information for the account. 4825 Retrieves the account provisioning information for the account. 4826 This method makes a synchronous HTTP request by default. To make an 4827 asynchronous HTTP request, please define a `callback` function 4828 to be invoked when receiving the response. 4829 >>> def callback_function(response): 4830 >>> pprint(response) 4831 >>> 4832 >>> thread = api.get_provisioning(callback=callback_function) 4833 4834 :param callback function: The callback function 4835 for asynchronous request. (optional) 4836 :return: ProvisioningInformation 4837 If the method is called asynchronously, 4838 returns the request thread. 4839 """ 4840 kwargs['_return_http_data_only'] = True 4841 if kwargs.get('callback'): 4842 return self.get_provisioning_with_http_info(**kwargs) 4843 else: 4844 (data) = self.get_provisioning_with_http_info(**kwargs) 4845 return data 4846 4847 def get_provisioning_with_http_info(self, **kwargs): 4848 """ 4849 Retrieves the account provisioning information for the account. 4850 Retrieves the account provisioning information for the account. 4851 This method makes a synchronous HTTP request by default. To make an 4852 asynchronous HTTP request, please define a `callback` function 4853 to be invoked when receiving the response. 4854 >>> def callback_function(response): 4855 >>> pprint(response) 4856 >>> 4857 >>> thread = api.get_provisioning_with_http_info(callback=callback_function) 4858 4859 :param callback function: The callback function 4860 for asynchronous request. (optional) 4861 :return: ProvisioningInformation 4862 If the method is called asynchronously, 4863 returns the request thread. 4864 """ 4865 4866 all_params = [] 4867 all_params.append('callback') 4868 all_params.append('_return_http_data_only') 4869 all_params.append('_preload_content') 4870 all_params.append('_request_timeout') 4871 4872 params = locals() 4873 for key, val in iteritems(params['kwargs']): 4874 if key not in all_params: 4875 raise TypeError( 4876 "Got an unexpected keyword argument '%s'" 4877 " to method get_provisioning" % key 4878 ) 4879 params[key] = val 4880 del params['kwargs'] 4881 4882 collection_formats = {} 4883 4884 resource_path = '/v2.1/accounts/provisioning'.replace('{format}', 'json') 4885 path_params = {} 4886 4887 query_params = {} 4888 4889 header_params = {} 4890 4891 form_params = [] 4892 local_var_files = {} 4893 4894 body_params = None 4895 # HTTP header `Accept` 4896 header_params['Accept'] = self.api_client.\ 4897 select_header_accept(['application/json']) 4898 4899 # Authentication setting 4900 auth_settings = [] 4901 4902 return self.api_client.call_api(resource_path, 'GET', 4903 path_params, 4904 query_params, 4905 header_params, 4906 body=body_params, 4907 post_params=form_params, 4908 files=local_var_files, 4909 response_type='ProvisioningInformation', 4910 auth_settings=auth_settings, 4911 callback=params.get('callback'), 4912 _return_http_data_only=params.get('_return_http_data_only'), 4913 _preload_content=params.get('_preload_content', True), 4914 _request_timeout=params.get('_request_timeout'), 4915 collection_formats=collection_formats) 4916 4917 def get_supported_languages(self, account_id, **kwargs): 4918 """ 4919 Gets list of supported languages for recipient language setting. 4920 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). 4921 This method makes a synchronous HTTP request by default. To make an 4922 asynchronous HTTP request, please define a `callback` function 4923 to be invoked when receiving the response. 4924 >>> def callback_function(response): 4925 >>> pprint(response) 4926 >>> 4927 >>> thread = api.get_supported_languages(account_id, callback=callback_function) 4928 4929 :param callback function: The callback function 4930 for asynchronous request. (optional) 4931 :param str account_id: The external account number (int) or account ID Guid. (required) 4932 :return: SupportedLanguages 4933 If the method is called asynchronously, 4934 returns the request thread. 4935 """ 4936 kwargs['_return_http_data_only'] = True 4937 if kwargs.get('callback'): 4938 return self.get_supported_languages_with_http_info(account_id, **kwargs) 4939 else: 4940 (data) = self.get_supported_languages_with_http_info(account_id, **kwargs) 4941 return data 4942 4943 def get_supported_languages_with_http_info(self, account_id, **kwargs): 4944 """ 4945 Gets list of supported languages for recipient language setting. 4946 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). 4947 This method makes a synchronous HTTP request by default. To make an 4948 asynchronous HTTP request, please define a `callback` function 4949 to be invoked when receiving the response. 4950 >>> def callback_function(response): 4951 >>> pprint(response) 4952 >>> 4953 >>> thread = api.get_supported_languages_with_http_info(account_id, callback=callback_function) 4954 4955 :param callback function: The callback function 4956 for asynchronous request. (optional) 4957 :param str account_id: The external account number (int) or account ID Guid. (required) 4958 :return: SupportedLanguages 4959 If the method is called asynchronously, 4960 returns the request thread. 4961 """ 4962 4963 all_params = ['account_id'] 4964 all_params.append('callback') 4965 all_params.append('_return_http_data_only') 4966 all_params.append('_preload_content') 4967 all_params.append('_request_timeout') 4968 4969 params = locals() 4970 for key, val in iteritems(params['kwargs']): 4971 if key not in all_params: 4972 raise TypeError( 4973 "Got an unexpected keyword argument '%s'" 4974 " to method get_supported_languages" % key 4975 ) 4976 params[key] = val 4977 del params['kwargs'] 4978 # verify the required parameter 'account_id' is set 4979 if ('account_id' not in params) or (params['account_id'] is None): 4980 raise ValueError("Missing the required parameter `account_id` when calling `get_supported_languages`") 4981 4982 4983 collection_formats = {} 4984 4985 resource_path = '/v2.1/accounts/{accountId}/supported_languages'.replace('{format}', 'json') 4986 path_params = {} 4987 if 'account_id' in params: 4988 path_params['accountId'] = params['account_id'] 4989 4990 query_params = {} 4991 4992 header_params = {} 4993 4994 form_params = [] 4995 local_var_files = {} 4996 4997 body_params = None 4998 # HTTP header `Accept` 4999 header_params['Accept'] = self.api_client.\ 5000 select_header_accept(['application/json']) 5001 5002 # Authentication setting 5003 auth_settings = [] 5004 5005 return self.api_client.call_api(resource_path, 'GET', 5006 path_params, 5007 query_params, 5008 header_params, 5009 body=body_params, 5010 post_params=form_params, 5011 files=local_var_files, 5012 response_type='SupportedLanguages', 5013 auth_settings=auth_settings, 5014 callback=params.get('callback'), 5015 _return_http_data_only=params.get('_return_http_data_only'), 5016 _preload_content=params.get('_preload_content', True), 5017 _request_timeout=params.get('_request_timeout'), 5018 collection_formats=collection_formats) 5019 5020 def get_user_authorization(self, account_id, authorization_id, user_id, **kwargs): 5021 """ 5022 Returns the user authorization for a given authorization id 5023 This method makes a synchronous HTTP request by default. To make an 5024 asynchronous HTTP request, please define a `callback` function 5025 to be invoked when receiving the response. 5026 >>> def callback_function(response): 5027 >>> pprint(response) 5028 >>> 5029 >>> thread = api.get_user_authorization(account_id, authorization_id, user_id, callback=callback_function) 5030 5031 :param callback function: The callback function 5032 for asynchronous request. (optional) 5033 :param str account_id: The external account number (int) or account ID Guid. (required) 5034 :param str authorization_id: (required) 5035 :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) 5036 :return: UserAuthorization 5037 If the method is called asynchronously, 5038 returns the request thread. 5039 """ 5040 kwargs['_return_http_data_only'] = True 5041 if kwargs.get('callback'): 5042 return self.get_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 5043 else: 5044 (data) = self.get_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 5045 return data 5046 5047 def get_user_authorization_with_http_info(self, account_id, authorization_id, user_id, **kwargs): 5048 """ 5049 Returns the user authorization for a given authorization id 5050 This method makes a synchronous HTTP request by default. To make an 5051 asynchronous HTTP request, please define a `callback` function 5052 to be invoked when receiving the response. 5053 >>> def callback_function(response): 5054 >>> pprint(response) 5055 >>> 5056 >>> thread = api.get_user_authorization_with_http_info(account_id, authorization_id, user_id, callback=callback_function) 5057 5058 :param callback function: The callback function 5059 for asynchronous request. (optional) 5060 :param str account_id: The external account number (int) or account ID Guid. (required) 5061 :param str authorization_id: (required) 5062 :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) 5063 :return: UserAuthorization 5064 If the method is called asynchronously, 5065 returns the request thread. 5066 """ 5067 5068 all_params = ['account_id', 'authorization_id', 'user_id'] 5069 all_params.append('callback') 5070 all_params.append('_return_http_data_only') 5071 all_params.append('_preload_content') 5072 all_params.append('_request_timeout') 5073 5074 params = locals() 5075 for key, val in iteritems(params['kwargs']): 5076 if key not in all_params: 5077 raise TypeError( 5078 "Got an unexpected keyword argument '%s'" 5079 " to method get_user_authorization" % key 5080 ) 5081 params[key] = val 5082 del params['kwargs'] 5083 # verify the required parameter 'account_id' is set 5084 if ('account_id' not in params) or (params['account_id'] is None): 5085 raise ValueError("Missing the required parameter `account_id` when calling `get_user_authorization`") 5086 # verify the required parameter 'authorization_id' is set 5087 if ('authorization_id' not in params) or (params['authorization_id'] is None): 5088 raise ValueError("Missing the required parameter `authorization_id` when calling `get_user_authorization`") 5089 # verify the required parameter 'user_id' is set 5090 if ('user_id' not in params) or (params['user_id'] is None): 5091 raise ValueError("Missing the required parameter `user_id` when calling `get_user_authorization`") 5092 5093 5094 collection_formats = {} 5095 5096 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorization/{authorizationId}'.replace('{format}', 'json') 5097 path_params = {} 5098 if 'account_id' in params: 5099 path_params['accountId'] = params['account_id'] 5100 if 'authorization_id' in params: 5101 path_params['authorizationId'] = params['authorization_id'] 5102 if 'user_id' in params: 5103 path_params['userId'] = params['user_id'] 5104 5105 query_params = {} 5106 5107 header_params = {} 5108 5109 form_params = [] 5110 local_var_files = {} 5111 5112 body_params = None 5113 # HTTP header `Accept` 5114 header_params['Accept'] = self.api_client.\ 5115 select_header_accept(['application/json']) 5116 5117 # Authentication setting 5118 auth_settings = [] 5119 5120 return self.api_client.call_api(resource_path, 'GET', 5121 path_params, 5122 query_params, 5123 header_params, 5124 body=body_params, 5125 post_params=form_params, 5126 files=local_var_files, 5127 response_type='UserAuthorization', 5128 auth_settings=auth_settings, 5129 callback=params.get('callback'), 5130 _return_http_data_only=params.get('_return_http_data_only'), 5131 _preload_content=params.get('_preload_content', True), 5132 _request_timeout=params.get('_request_timeout'), 5133 collection_formats=collection_formats) 5134 5135 def get_watermark(self, account_id, **kwargs): 5136 """ 5137 Get watermark information. 5138 5139 This method makes a synchronous HTTP request by default. To make an 5140 asynchronous HTTP request, please define a `callback` function 5141 to be invoked when receiving the response. 5142 >>> def callback_function(response): 5143 >>> pprint(response) 5144 >>> 5145 >>> thread = api.get_watermark(account_id, callback=callback_function) 5146 5147 :param callback function: The callback function 5148 for asynchronous request. (optional) 5149 :param str account_id: The external account number (int) or account ID Guid. (required) 5150 :return: Watermark 5151 If the method is called asynchronously, 5152 returns the request thread. 5153 """ 5154 kwargs['_return_http_data_only'] = True 5155 if kwargs.get('callback'): 5156 return self.get_watermark_with_http_info(account_id, **kwargs) 5157 else: 5158 (data) = self.get_watermark_with_http_info(account_id, **kwargs) 5159 return data 5160 5161 def get_watermark_with_http_info(self, account_id, **kwargs): 5162 """ 5163 Get watermark information. 5164 5165 This method makes a synchronous HTTP request by default. To make an 5166 asynchronous HTTP request, please define a `callback` function 5167 to be invoked when receiving the response. 5168 >>> def callback_function(response): 5169 >>> pprint(response) 5170 >>> 5171 >>> thread = api.get_watermark_with_http_info(account_id, callback=callback_function) 5172 5173 :param callback function: The callback function 5174 for asynchronous request. (optional) 5175 :param str account_id: The external account number (int) or account ID Guid. (required) 5176 :return: Watermark 5177 If the method is called asynchronously, 5178 returns the request thread. 5179 """ 5180 5181 all_params = ['account_id'] 5182 all_params.append('callback') 5183 all_params.append('_return_http_data_only') 5184 all_params.append('_preload_content') 5185 all_params.append('_request_timeout') 5186 5187 params = locals() 5188 for key, val in iteritems(params['kwargs']): 5189 if key not in all_params: 5190 raise TypeError( 5191 "Got an unexpected keyword argument '%s'" 5192 " to method get_watermark" % key 5193 ) 5194 params[key] = val 5195 del params['kwargs'] 5196 # verify the required parameter 'account_id' is set 5197 if ('account_id' not in params) or (params['account_id'] is None): 5198 raise ValueError("Missing the required parameter `account_id` when calling `get_watermark`") 5199 5200 5201 collection_formats = {} 5202 5203 resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json') 5204 path_params = {} 5205 if 'account_id' in params: 5206 path_params['accountId'] = params['account_id'] 5207 5208 query_params = {} 5209 5210 header_params = {} 5211 5212 form_params = [] 5213 local_var_files = {} 5214 5215 body_params = None 5216 # HTTP header `Accept` 5217 header_params['Accept'] = self.api_client.\ 5218 select_header_accept(['application/json']) 5219 5220 # Authentication setting 5221 auth_settings = [] 5222 5223 return self.api_client.call_api(resource_path, 'GET', 5224 path_params, 5225 query_params, 5226 header_params, 5227 body=body_params, 5228 post_params=form_params, 5229 files=local_var_files, 5230 response_type='Watermark', 5231 auth_settings=auth_settings, 5232 callback=params.get('callback'), 5233 _return_http_data_only=params.get('_return_http_data_only'), 5234 _preload_content=params.get('_preload_content', True), 5235 _request_timeout=params.get('_request_timeout'), 5236 collection_formats=collection_formats) 5237 5238 def get_watermark_preview(self, account_id, **kwargs): 5239 """ 5240 Get watermark preview. 5241 5242 This method makes a synchronous HTTP request by default. To make an 5243 asynchronous HTTP request, please define a `callback` function 5244 to be invoked when receiving the response. 5245 >>> def callback_function(response): 5246 >>> pprint(response) 5247 >>> 5248 >>> thread = api.get_watermark_preview(account_id, callback=callback_function) 5249 5250 :param callback function: The callback function 5251 for asynchronous request. (optional) 5252 :param str account_id: The external account number (int) or account ID Guid. (required) 5253 :param Watermark watermark: 5254 :return: Watermark 5255 If the method is called asynchronously, 5256 returns the request thread. 5257 """ 5258 kwargs['_return_http_data_only'] = True 5259 if kwargs.get('callback'): 5260 return self.get_watermark_preview_with_http_info(account_id, **kwargs) 5261 else: 5262 (data) = self.get_watermark_preview_with_http_info(account_id, **kwargs) 5263 return data 5264 5265 def get_watermark_preview_with_http_info(self, account_id, **kwargs): 5266 """ 5267 Get watermark preview. 5268 5269 This method makes a synchronous HTTP request by default. To make an 5270 asynchronous HTTP request, please define a `callback` function 5271 to be invoked when receiving the response. 5272 >>> def callback_function(response): 5273 >>> pprint(response) 5274 >>> 5275 >>> thread = api.get_watermark_preview_with_http_info(account_id, callback=callback_function) 5276 5277 :param callback function: The callback function 5278 for asynchronous request. (optional) 5279 :param str account_id: The external account number (int) or account ID Guid. (required) 5280 :param Watermark watermark: 5281 :return: Watermark 5282 If the method is called asynchronously, 5283 returns the request thread. 5284 """ 5285 5286 all_params = ['account_id', 'watermark'] 5287 all_params.append('callback') 5288 all_params.append('_return_http_data_only') 5289 all_params.append('_preload_content') 5290 all_params.append('_request_timeout') 5291 5292 params = locals() 5293 for key, val in iteritems(params['kwargs']): 5294 if key not in all_params: 5295 raise TypeError( 5296 "Got an unexpected keyword argument '%s'" 5297 " to method get_watermark_preview" % key 5298 ) 5299 params[key] = val 5300 del params['kwargs'] 5301 # verify the required parameter 'account_id' is set 5302 if ('account_id' not in params) or (params['account_id'] is None): 5303 raise ValueError("Missing the required parameter `account_id` when calling `get_watermark_preview`") 5304 5305 5306 collection_formats = {} 5307 5308 resource_path = '/v2.1/accounts/{accountId}/watermark/preview'.replace('{format}', 'json') 5309 path_params = {} 5310 if 'account_id' in params: 5311 path_params['accountId'] = params['account_id'] 5312 5313 query_params = {} 5314 5315 header_params = {} 5316 5317 form_params = [] 5318 local_var_files = {} 5319 5320 body_params = None 5321 if 'watermark' in params: 5322 body_params = params['watermark'] 5323 # HTTP header `Accept` 5324 header_params['Accept'] = self.api_client.\ 5325 select_header_accept(['application/json']) 5326 5327 # Authentication setting 5328 auth_settings = [] 5329 5330 return self.api_client.call_api(resource_path, 'PUT', 5331 path_params, 5332 query_params, 5333 header_params, 5334 body=body_params, 5335 post_params=form_params, 5336 files=local_var_files, 5337 response_type='Watermark', 5338 auth_settings=auth_settings, 5339 callback=params.get('callback'), 5340 _return_http_data_only=params.get('_return_http_data_only'), 5341 _preload_content=params.get('_preload_content', True), 5342 _request_timeout=params.get('_request_timeout'), 5343 collection_formats=collection_formats) 5344 5345 def list_brands(self, account_id, **kwargs): 5346 """ 5347 Gets a list of brand profiles. 5348 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. 5349 This method makes a synchronous HTTP request by default. To make an 5350 asynchronous HTTP request, please define a `callback` function 5351 to be invoked when receiving the response. 5352 >>> def callback_function(response): 5353 >>> pprint(response) 5354 >>> 5355 >>> thread = api.list_brands(account_id, callback=callback_function) 5356 5357 :param callback function: The callback function 5358 for asynchronous request. (optional) 5359 :param str account_id: The external account number (int) or account ID Guid. (required) 5360 :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set. 5361 :param str include_logos: When set to **true**, returns the logos associated with the brand. 5362 :return: BrandsResponse 5363 If the method is called asynchronously, 5364 returns the request thread. 5365 """ 5366 kwargs['_return_http_data_only'] = True 5367 if kwargs.get('callback'): 5368 return self.list_brands_with_http_info(account_id, **kwargs) 5369 else: 5370 (data) = self.list_brands_with_http_info(account_id, **kwargs) 5371 return data 5372 5373 def list_brands_with_http_info(self, account_id, **kwargs): 5374 """ 5375 Gets a list of brand profiles. 5376 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. 5377 This method makes a synchronous HTTP request by default. To make an 5378 asynchronous HTTP request, please define a `callback` function 5379 to be invoked when receiving the response. 5380 >>> def callback_function(response): 5381 >>> pprint(response) 5382 >>> 5383 >>> thread = api.list_brands_with_http_info(account_id, callback=callback_function) 5384 5385 :param callback function: The callback function 5386 for asynchronous request. (optional) 5387 :param str account_id: The external account number (int) or account ID Guid. (required) 5388 :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set. 5389 :param str include_logos: When set to **true**, returns the logos associated with the brand. 5390 :return: BrandsResponse 5391 If the method is called asynchronously, 5392 returns the request thread. 5393 """ 5394 5395 all_params = ['account_id', 'exclude_distributor_brand', 'include_logos'] 5396 all_params.append('callback') 5397 all_params.append('_return_http_data_only') 5398 all_params.append('_preload_content') 5399 all_params.append('_request_timeout') 5400 5401 params = locals() 5402 for key, val in iteritems(params['kwargs']): 5403 if key not in all_params: 5404 raise TypeError( 5405 "Got an unexpected keyword argument '%s'" 5406 " to method list_brands" % key 5407 ) 5408 params[key] = val 5409 del params['kwargs'] 5410 # verify the required parameter 'account_id' is set 5411 if ('account_id' not in params) or (params['account_id'] is None): 5412 raise ValueError("Missing the required parameter `account_id` when calling `list_brands`") 5413 5414 5415 collection_formats = {} 5416 5417 resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json') 5418 path_params = {} 5419 if 'account_id' in params: 5420 path_params['accountId'] = params['account_id'] 5421 5422 query_params = {} 5423 if 'exclude_distributor_brand' in params: 5424 query_params['exclude_distributor_brand'] = params['exclude_distributor_brand'] 5425 if 'include_logos' in params: 5426 query_params['include_logos'] = params['include_logos'] 5427 5428 header_params = {} 5429 5430 form_params = [] 5431 local_var_files = {} 5432 5433 body_params = None 5434 # HTTP header `Accept` 5435 header_params['Accept'] = self.api_client.\ 5436 select_header_accept(['application/json']) 5437 5438 # Authentication setting 5439 auth_settings = [] 5440 5441 return self.api_client.call_api(resource_path, 'GET', 5442 path_params, 5443 query_params, 5444 header_params, 5445 body=body_params, 5446 post_params=form_params, 5447 files=local_var_files, 5448 response_type='BrandsResponse', 5449 auth_settings=auth_settings, 5450 callback=params.get('callback'), 5451 _return_http_data_only=params.get('_return_http_data_only'), 5452 _preload_content=params.get('_preload_content', True), 5453 _request_timeout=params.get('_request_timeout'), 5454 collection_formats=collection_formats) 5455 5456 def list_custom_fields(self, account_id, **kwargs): 5457 """ 5458 Gets a list of custom fields associated with the account. 5459 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. 5460 This method makes a synchronous HTTP request by default. To make an 5461 asynchronous HTTP request, please define a `callback` function 5462 to be invoked when receiving the response. 5463 >>> def callback_function(response): 5464 >>> pprint(response) 5465 >>> 5466 >>> thread = api.list_custom_fields(account_id, callback=callback_function) 5467 5468 :param callback function: The callback function 5469 for asynchronous request. (optional) 5470 :param str account_id: The external account number (int) or account ID Guid. (required) 5471 :return: CustomFields 5472 If the method is called asynchronously, 5473 returns the request thread. 5474 """ 5475 kwargs['_return_http_data_only'] = True 5476 if kwargs.get('callback'): 5477 return self.list_custom_fields_with_http_info(account_id, **kwargs) 5478 else: 5479 (data) = self.list_custom_fields_with_http_info(account_id, **kwargs) 5480 return data 5481 5482 def list_custom_fields_with_http_info(self, account_id, **kwargs): 5483 """ 5484 Gets a list of custom fields associated with the account. 5485 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. 5486 This method makes a synchronous HTTP request by default. To make an 5487 asynchronous HTTP request, please define a `callback` function 5488 to be invoked when receiving the response. 5489 >>> def callback_function(response): 5490 >>> pprint(response) 5491 >>> 5492 >>> thread = api.list_custom_fields_with_http_info(account_id, callback=callback_function) 5493 5494 :param callback function: The callback function 5495 for asynchronous request. (optional) 5496 :param str account_id: The external account number (int) or account ID Guid. (required) 5497 :return: CustomFields 5498 If the method is called asynchronously, 5499 returns the request thread. 5500 """ 5501 5502 all_params = ['account_id'] 5503 all_params.append('callback') 5504 all_params.append('_return_http_data_only') 5505 all_params.append('_preload_content') 5506 all_params.append('_request_timeout') 5507 5508 params = locals() 5509 for key, val in iteritems(params['kwargs']): 5510 if key not in all_params: 5511 raise TypeError( 5512 "Got an unexpected keyword argument '%s'" 5513 " to method list_custom_fields" % key 5514 ) 5515 params[key] = val 5516 del params['kwargs'] 5517 # verify the required parameter 'account_id' is set 5518 if ('account_id' not in params) or (params['account_id'] is None): 5519 raise ValueError("Missing the required parameter `account_id` when calling `list_custom_fields`") 5520 5521 5522 collection_formats = {} 5523 5524 resource_path = '/v2.1/accounts/{accountId}/custom_fields'.replace('{format}', 'json') 5525 path_params = {} 5526 if 'account_id' in params: 5527 path_params['accountId'] = params['account_id'] 5528 5529 query_params = {} 5530 5531 header_params = {} 5532 5533 form_params = [] 5534 local_var_files = {} 5535 5536 body_params = None 5537 # HTTP header `Accept` 5538 header_params['Accept'] = self.api_client.\ 5539 select_header_accept(['application/json']) 5540 5541 # Authentication setting 5542 auth_settings = [] 5543 5544 return self.api_client.call_api(resource_path, 'GET', 5545 path_params, 5546 query_params, 5547 header_params, 5548 body=body_params, 5549 post_params=form_params, 5550 files=local_var_files, 5551 response_type='CustomFields', 5552 auth_settings=auth_settings, 5553 callback=params.get('callback'), 5554 _return_http_data_only=params.get('_return_http_data_only'), 5555 _preload_content=params.get('_preload_content', True), 5556 _request_timeout=params.get('_request_timeout'), 5557 collection_formats=collection_formats) 5558 5559 def list_permissions(self, account_id, **kwargs): 5560 """ 5561 Gets a list of permission profiles. 5562 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. 5563 This method makes a synchronous HTTP request by default. To make an 5564 asynchronous HTTP request, please define a `callback` function 5565 to be invoked when receiving the response. 5566 >>> def callback_function(response): 5567 >>> pprint(response) 5568 >>> 5569 >>> thread = api.list_permissions(account_id, callback=callback_function) 5570 5571 :param callback function: The callback function 5572 for asynchronous request. (optional) 5573 :param str account_id: The external account number (int) or account ID Guid. (required) 5574 :param str include: 5575 :return: PermissionProfileInformation 5576 If the method is called asynchronously, 5577 returns the request thread. 5578 """ 5579 kwargs['_return_http_data_only'] = True 5580 if kwargs.get('callback'): 5581 return self.list_permissions_with_http_info(account_id, **kwargs) 5582 else: 5583 (data) = self.list_permissions_with_http_info(account_id, **kwargs) 5584 return data 5585 5586 def list_permissions_with_http_info(self, account_id, **kwargs): 5587 """ 5588 Gets a list of permission profiles. 5589 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. 5590 This method makes a synchronous HTTP request by default. To make an 5591 asynchronous HTTP request, please define a `callback` function 5592 to be invoked when receiving the response. 5593 >>> def callback_function(response): 5594 >>> pprint(response) 5595 >>> 5596 >>> thread = api.list_permissions_with_http_info(account_id, callback=callback_function) 5597 5598 :param callback function: The callback function 5599 for asynchronous request. (optional) 5600 :param str account_id: The external account number (int) or account ID Guid. (required) 5601 :param str include: 5602 :return: PermissionProfileInformation 5603 If the method is called asynchronously, 5604 returns the request thread. 5605 """ 5606 5607 all_params = ['account_id', 'include'] 5608 all_params.append('callback') 5609 all_params.append('_return_http_data_only') 5610 all_params.append('_preload_content') 5611 all_params.append('_request_timeout') 5612 5613 params = locals() 5614 for key, val in iteritems(params['kwargs']): 5615 if key not in all_params: 5616 raise TypeError( 5617 "Got an unexpected keyword argument '%s'" 5618 " to method list_permissions" % key 5619 ) 5620 params[key] = val 5621 del params['kwargs'] 5622 # verify the required parameter 'account_id' is set 5623 if ('account_id' not in params) or (params['account_id'] is None): 5624 raise ValueError("Missing the required parameter `account_id` when calling `list_permissions`") 5625 5626 5627 collection_formats = {} 5628 5629 resource_path = '/v2.1/accounts/{accountId}/permission_profiles'.replace('{format}', 'json') 5630 path_params = {} 5631 if 'account_id' in params: 5632 path_params['accountId'] = params['account_id'] 5633 5634 query_params = {} 5635 if 'include' in params: 5636 query_params['include'] = params['include'] 5637 5638 header_params = {} 5639 5640 form_params = [] 5641 local_var_files = {} 5642 5643 body_params = None 5644 # HTTP header `Accept` 5645 header_params['Accept'] = self.api_client.\ 5646 select_header_accept(['application/json']) 5647 5648 # Authentication setting 5649 auth_settings = [] 5650 5651 return self.api_client.call_api(resource_path, 'GET', 5652 path_params, 5653 query_params, 5654 header_params, 5655 body=body_params, 5656 post_params=form_params, 5657 files=local_var_files, 5658 response_type='PermissionProfileInformation', 5659 auth_settings=auth_settings, 5660 callback=params.get('callback'), 5661 _return_http_data_only=params.get('_return_http_data_only'), 5662 _preload_content=params.get('_preload_content', True), 5663 _request_timeout=params.get('_request_timeout'), 5664 collection_formats=collection_formats) 5665 5666 def list_recipient_names_by_email(self, account_id, **kwargs): 5667 """ 5668 Gets recipient names associated with an email address. 5669 Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string. 5670 This method makes a synchronous HTTP request by default. To make an 5671 asynchronous HTTP request, please define a `callback` function 5672 to be invoked when receiving the response. 5673 >>> def callback_function(response): 5674 >>> pprint(response) 5675 >>> 5676 >>> thread = api.list_recipient_names_by_email(account_id, callback=callback_function) 5677 5678 :param callback function: The callback function 5679 for asynchronous request. (optional) 5680 :param str account_id: The external account number (int) or account ID Guid. (required) 5681 :param str email: The email address for the user 5682 :return: RecipientNamesResponse 5683 If the method is called asynchronously, 5684 returns the request thread. 5685 """ 5686 kwargs['_return_http_data_only'] = True 5687 if kwargs.get('callback'): 5688 return self.list_recipient_names_by_email_with_http_info(account_id, **kwargs) 5689 else: 5690 (data) = self.list_recipient_names_by_email_with_http_info(account_id, **kwargs) 5691 return data 5692 5693 def list_recipient_names_by_email_with_http_info(self, account_id, **kwargs): 5694 """ 5695 Gets recipient names associated with an email address. 5696 Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string. 5697 This method makes a synchronous HTTP request by default. To make an 5698 asynchronous HTTP request, please define a `callback` function 5699 to be invoked when receiving the response. 5700 >>> def callback_function(response): 5701 >>> pprint(response) 5702 >>> 5703 >>> thread = api.list_recipient_names_by_email_with_http_info(account_id, callback=callback_function) 5704 5705 :param callback function: The callback function 5706 for asynchronous request. (optional) 5707 :param str account_id: The external account number (int) or account ID Guid. (required) 5708 :param str email: The email address for the user 5709 :return: RecipientNamesResponse 5710 If the method is called asynchronously, 5711 returns the request thread. 5712 """ 5713 5714 all_params = ['account_id', 'email'] 5715 all_params.append('callback') 5716 all_params.append('_return_http_data_only') 5717 all_params.append('_preload_content') 5718 all_params.append('_request_timeout') 5719 5720 params = locals() 5721 for key, val in iteritems(params['kwargs']): 5722 if key not in all_params: 5723 raise TypeError( 5724 "Got an unexpected keyword argument '%s'" 5725 " to method list_recipient_names_by_email" % key 5726 ) 5727 params[key] = val 5728 del params['kwargs'] 5729 # verify the required parameter 'account_id' is set 5730 if ('account_id' not in params) or (params['account_id'] is None): 5731 raise ValueError("Missing the required parameter `account_id` when calling `list_recipient_names_by_email`") 5732 5733 5734 collection_formats = {} 5735 5736 resource_path = '/v2.1/accounts/{accountId}/recipient_names'.replace('{format}', 'json') 5737 path_params = {} 5738 if 'account_id' in params: 5739 path_params['accountId'] = params['account_id'] 5740 5741 query_params = {} 5742 if 'email' in params: 5743 query_params['email'] = params['email'] 5744 5745 header_params = {} 5746 5747 form_params = [] 5748 local_var_files = {} 5749 5750 body_params = None 5751 # HTTP header `Accept` 5752 header_params['Accept'] = self.api_client.\ 5753 select_header_accept(['application/json']) 5754 5755 # Authentication setting 5756 auth_settings = [] 5757 5758 return self.api_client.call_api(resource_path, 'GET', 5759 path_params, 5760 query_params, 5761 header_params, 5762 body=body_params, 5763 post_params=form_params, 5764 files=local_var_files, 5765 response_type='RecipientNamesResponse', 5766 auth_settings=auth_settings, 5767 callback=params.get('callback'), 5768 _return_http_data_only=params.get('_return_http_data_only'), 5769 _preload_content=params.get('_preload_content', True), 5770 _request_timeout=params.get('_request_timeout'), 5771 collection_formats=collection_formats) 5772 5773 def list_settings(self, account_id, **kwargs): 5774 """ 5775 Gets account settings information. 5776 Retrieves the account settings information for the specified account. 5777 This method makes a synchronous HTTP request by default. To make an 5778 asynchronous HTTP request, please define a `callback` function 5779 to be invoked when receiving the response. 5780 >>> def callback_function(response): 5781 >>> pprint(response) 5782 >>> 5783 >>> thread = api.list_settings(account_id, callback=callback_function) 5784 5785 :param callback function: The callback function 5786 for asynchronous request. (optional) 5787 :param str account_id: The external account number (int) or account ID Guid. (required) 5788 :return: AccountSettingsInformation 5789 If the method is called asynchronously, 5790 returns the request thread. 5791 """ 5792 kwargs['_return_http_data_only'] = True 5793 if kwargs.get('callback'): 5794 return self.list_settings_with_http_info(account_id, **kwargs) 5795 else: 5796 (data) = self.list_settings_with_http_info(account_id, **kwargs) 5797 return data 5798 5799 def list_settings_with_http_info(self, account_id, **kwargs): 5800 """ 5801 Gets account settings information. 5802 Retrieves the account settings information for the specified account. 5803 This method makes a synchronous HTTP request by default. To make an 5804 asynchronous HTTP request, please define a `callback` function 5805 to be invoked when receiving the response. 5806 >>> def callback_function(response): 5807 >>> pprint(response) 5808 >>> 5809 >>> thread = api.list_settings_with_http_info(account_id, callback=callback_function) 5810 5811 :param callback function: The callback function 5812 for asynchronous request. (optional) 5813 :param str account_id: The external account number (int) or account ID Guid. (required) 5814 :return: AccountSettingsInformation 5815 If the method is called asynchronously, 5816 returns the request thread. 5817 """ 5818 5819 all_params = ['account_id'] 5820 all_params.append('callback') 5821 all_params.append('_return_http_data_only') 5822 all_params.append('_preload_content') 5823 all_params.append('_request_timeout') 5824 5825 params = locals() 5826 for key, val in iteritems(params['kwargs']): 5827 if key not in all_params: 5828 raise TypeError( 5829 "Got an unexpected keyword argument '%s'" 5830 " to method list_settings" % key 5831 ) 5832 params[key] = val 5833 del params['kwargs'] 5834 # verify the required parameter 'account_id' is set 5835 if ('account_id' not in params) or (params['account_id'] is None): 5836 raise ValueError("Missing the required parameter `account_id` when calling `list_settings`") 5837 5838 5839 collection_formats = {} 5840 5841 resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json') 5842 path_params = {} 5843 if 'account_id' in params: 5844 path_params['accountId'] = params['account_id'] 5845 5846 query_params = {} 5847 5848 header_params = {} 5849 5850 form_params = [] 5851 local_var_files = {} 5852 5853 body_params = None 5854 # HTTP header `Accept` 5855 header_params['Accept'] = self.api_client.\ 5856 select_header_accept(['application/json']) 5857 5858 # Authentication setting 5859 auth_settings = [] 5860 5861 return self.api_client.call_api(resource_path, 'GET', 5862 path_params, 5863 query_params, 5864 header_params, 5865 body=body_params, 5866 post_params=form_params, 5867 files=local_var_files, 5868 response_type='AccountSettingsInformation', 5869 auth_settings=auth_settings, 5870 callback=params.get('callback'), 5871 _return_http_data_only=params.get('_return_http_data_only'), 5872 _preload_content=params.get('_preload_content', True), 5873 _request_timeout=params.get('_request_timeout'), 5874 collection_formats=collection_formats) 5875 5876 def list_shared_access(self, account_id, **kwargs): 5877 """ 5878 Reserved: Gets the shared item status for one or more users. 5879 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. 5880 This method makes a synchronous HTTP request by default. To make an 5881 asynchronous HTTP request, please define a `callback` function 5882 to be invoked when receiving the response. 5883 >>> def callback_function(response): 5884 >>> pprint(response) 5885 >>> 5886 >>> thread = api.list_shared_access(account_id, callback=callback_function) 5887 5888 :param callback function: The callback function 5889 for asynchronous request. (optional) 5890 :param str account_id: The external account number (int) or account ID Guid. (required) 5891 :param str count: Specifies maximum number of results included in the response. If no value is specified, this defaults to 1000. 5892 :param str envelopes_not_shared_user_status: 5893 :param str folder_ids: 5894 :param str item_type: Specifies the type of shared item being requested. The accepted values are: -envelopes: returns information about envelope sharing between users. 5895 :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. 5896 :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 5897 :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. 5898 :param str user_ids: A comma separated list of userIds for whom the shared item information is being requested. 5899 :return: AccountSharedAccess 5900 If the method is called asynchronously, 5901 returns the request thread. 5902 """ 5903 kwargs['_return_http_data_only'] = True 5904 if kwargs.get('callback'): 5905 return self.list_shared_access_with_http_info(account_id, **kwargs) 5906 else: 5907 (data) = self.list_shared_access_with_http_info(account_id, **kwargs) 5908 return data 5909 5910 def list_shared_access_with_http_info(self, account_id, **kwargs): 5911 """ 5912 Reserved: Gets the shared item status for one or more users. 5913 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. 5914 This method makes a synchronous HTTP request by default. To make an 5915 asynchronous HTTP request, please define a `callback` function 5916 to be invoked when receiving the response. 5917 >>> def callback_function(response): 5918 >>> pprint(response) 5919 >>> 5920 >>> thread = api.list_shared_access_with_http_info(account_id, callback=callback_function) 5921 5922 :param callback function: The callback function 5923 for asynchronous request. (optional) 5924 :param str account_id: The external account number (int) or account ID Guid. (required) 5925 :param str count: Specifies maximum number of results included in the response. If no value is specified, this defaults to 1000. 5926 :param str envelopes_not_shared_user_status: 5927 :param str folder_ids: 5928 :param str item_type: Specifies the type of shared item being requested. The accepted values are: -envelopes: returns information about envelope sharing between users. 5929 :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. 5930 :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 5931 :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. 5932 :param str user_ids: A comma separated list of userIds for whom the shared item information is being requested. 5933 :return: AccountSharedAccess 5934 If the method is called asynchronously, 5935 returns the request thread. 5936 """ 5937 5938 all_params = ['account_id', 'count', 'envelopes_not_shared_user_status', 'folder_ids', 'item_type', 'search_text', 'shared', 'start_position', 'user_ids'] 5939 all_params.append('callback') 5940 all_params.append('_return_http_data_only') 5941 all_params.append('_preload_content') 5942 all_params.append('_request_timeout') 5943 5944 params = locals() 5945 for key, val in iteritems(params['kwargs']): 5946 if key not in all_params: 5947 raise TypeError( 5948 "Got an unexpected keyword argument '%s'" 5949 " to method list_shared_access" % key 5950 ) 5951 params[key] = val 5952 del params['kwargs'] 5953 # verify the required parameter 'account_id' is set 5954 if ('account_id' not in params) or (params['account_id'] is None): 5955 raise ValueError("Missing the required parameter `account_id` when calling `list_shared_access`") 5956 5957 5958 collection_formats = {} 5959 5960 resource_path = '/v2.1/accounts/{accountId}/shared_access'.replace('{format}', 'json') 5961 path_params = {} 5962 if 'account_id' in params: 5963 path_params['accountId'] = params['account_id'] 5964 5965 query_params = {} 5966 if 'count' in params: 5967 query_params['count'] = params['count'] 5968 if 'envelopes_not_shared_user_status' in params: 5969 query_params['envelopes_not_shared_user_status'] = params['envelopes_not_shared_user_status'] 5970 if 'folder_ids' in params: 5971 query_params['folder_ids'] = params['folder_ids'] 5972 if 'item_type' in params: 5973 query_params['item_type'] = params['item_type'] 5974 if 'search_text' in params: 5975 query_params['search_text'] = params['search_text'] 5976 if 'shared' in params: 5977 query_params['shared'] = params['shared'] 5978 if 'start_position' in params: 5979 query_params['start_position'] = params['start_position'] 5980 if 'user_ids' in params: 5981 query_params['user_ids'] = params['user_ids'] 5982 5983 header_params = {} 5984 5985 form_params = [] 5986 local_var_files = {} 5987 5988 body_params = None 5989 # HTTP header `Accept` 5990 header_params['Accept'] = self.api_client.\ 5991 select_header_accept(['application/json']) 5992 5993 # Authentication setting 5994 auth_settings = [] 5995 5996 return self.api_client.call_api(resource_path, 'GET', 5997 path_params, 5998 query_params, 5999 header_params, 6000 body=body_params, 6001 post_params=form_params, 6002 files=local_var_files, 6003 response_type='AccountSharedAccess', 6004 auth_settings=auth_settings, 6005 callback=params.get('callback'), 6006 _return_http_data_only=params.get('_return_http_data_only'), 6007 _preload_content=params.get('_preload_content', True), 6008 _request_timeout=params.get('_request_timeout'), 6009 collection_formats=collection_formats) 6010 6011 def list_signature_providers(self, account_id, **kwargs): 6012 """ 6013 Returns Account available signature providers for specified account. 6014 Returns a list of signature providers that the specified account can use. 6015 This method makes a synchronous HTTP request by default. To make an 6016 asynchronous HTTP request, please define a `callback` function 6017 to be invoked when receiving the response. 6018 >>> def callback_function(response): 6019 >>> pprint(response) 6020 >>> 6021 >>> thread = api.list_signature_providers(account_id, callback=callback_function) 6022 6023 :param callback function: The callback function 6024 for asynchronous request. (optional) 6025 :param str account_id: The external account number (int) or account ID Guid. (required) 6026 :return: AccountSignatureProviders 6027 If the method is called asynchronously, 6028 returns the request thread. 6029 """ 6030 kwargs['_return_http_data_only'] = True 6031 if kwargs.get('callback'): 6032 return self.list_signature_providers_with_http_info(account_id, **kwargs) 6033 else: 6034 (data) = self.list_signature_providers_with_http_info(account_id, **kwargs) 6035 return data 6036 6037 def list_signature_providers_with_http_info(self, account_id, **kwargs): 6038 """ 6039 Returns Account available signature providers for specified account. 6040 Returns a list of signature providers that the specified account can use. 6041 This method makes a synchronous HTTP request by default. To make an 6042 asynchronous HTTP request, please define a `callback` function 6043 to be invoked when receiving the response. 6044 >>> def callback_function(response): 6045 >>> pprint(response) 6046 >>> 6047 >>> thread = api.list_signature_providers_with_http_info(account_id, callback=callback_function) 6048 6049 :param callback function: The callback function 6050 for asynchronous request. (optional) 6051 :param str account_id: The external account number (int) or account ID Guid. (required) 6052 :return: AccountSignatureProviders 6053 If the method is called asynchronously, 6054 returns the request thread. 6055 """ 6056 6057 all_params = ['account_id'] 6058 all_params.append('callback') 6059 all_params.append('_return_http_data_only') 6060 all_params.append('_preload_content') 6061 all_params.append('_request_timeout') 6062 6063 params = locals() 6064 for key, val in iteritems(params['kwargs']): 6065 if key not in all_params: 6066 raise TypeError( 6067 "Got an unexpected keyword argument '%s'" 6068 " to method list_signature_providers" % key 6069 ) 6070 params[key] = val 6071 del params['kwargs'] 6072 # verify the required parameter 'account_id' is set 6073 if ('account_id' not in params) or (params['account_id'] is None): 6074 raise ValueError("Missing the required parameter `account_id` when calling `list_signature_providers`") 6075 6076 6077 collection_formats = {} 6078 6079 resource_path = '/v2.1/accounts/{accountId}/signatureProviders'.replace('{format}', 'json') 6080 path_params = {} 6081 if 'account_id' in params: 6082 path_params['accountId'] = params['account_id'] 6083 6084 query_params = {} 6085 6086 header_params = {} 6087 6088 form_params = [] 6089 local_var_files = {} 6090 6091 body_params = None 6092 # HTTP header `Accept` 6093 header_params['Accept'] = self.api_client.\ 6094 select_header_accept(['application/json']) 6095 6096 # Authentication setting 6097 auth_settings = [] 6098 6099 return self.api_client.call_api(resource_path, 'GET', 6100 path_params, 6101 query_params, 6102 header_params, 6103 body=body_params, 6104 post_params=form_params, 6105 files=local_var_files, 6106 response_type='AccountSignatureProviders', 6107 auth_settings=auth_settings, 6108 callback=params.get('callback'), 6109 _return_http_data_only=params.get('_return_http_data_only'), 6110 _preload_content=params.get('_preload_content', True), 6111 _request_timeout=params.get('_request_timeout'), 6112 collection_formats=collection_formats) 6113 6114 def list_unsupported_file_types(self, account_id, **kwargs): 6115 """ 6116 Gets a list of unsupported file types. 6117 Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system. 6118 This method makes a synchronous HTTP request by default. To make an 6119 asynchronous HTTP request, please define a `callback` function 6120 to be invoked when receiving the response. 6121 >>> def callback_function(response): 6122 >>> pprint(response) 6123 >>> 6124 >>> thread = api.list_unsupported_file_types(account_id, callback=callback_function) 6125 6126 :param callback function: The callback function 6127 for asynchronous request. (optional) 6128 :param str account_id: The external account number (int) or account ID Guid. (required) 6129 :return: FileTypeList 6130 If the method is called asynchronously, 6131 returns the request thread. 6132 """ 6133 kwargs['_return_http_data_only'] = True 6134 if kwargs.get('callback'): 6135 return self.list_unsupported_file_types_with_http_info(account_id, **kwargs) 6136 else: 6137 (data) = self.list_unsupported_file_types_with_http_info(account_id, **kwargs) 6138 return data 6139 6140 def list_unsupported_file_types_with_http_info(self, account_id, **kwargs): 6141 """ 6142 Gets a list of unsupported file types. 6143 Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system. 6144 This method makes a synchronous HTTP request by default. To make an 6145 asynchronous HTTP request, please define a `callback` function 6146 to be invoked when receiving the response. 6147 >>> def callback_function(response): 6148 >>> pprint(response) 6149 >>> 6150 >>> thread = api.list_unsupported_file_types_with_http_info(account_id, callback=callback_function) 6151 6152 :param callback function: The callback function 6153 for asynchronous request. (optional) 6154 :param str account_id: The external account number (int) or account ID Guid. (required) 6155 :return: FileTypeList 6156 If the method is called asynchronously, 6157 returns the request thread. 6158 """ 6159 6160 all_params = ['account_id'] 6161 all_params.append('callback') 6162 all_params.append('_return_http_data_only') 6163 all_params.append('_preload_content') 6164 all_params.append('_request_timeout') 6165 6166 params = locals() 6167 for key, val in iteritems(params['kwargs']): 6168 if key not in all_params: 6169 raise TypeError( 6170 "Got an unexpected keyword argument '%s'" 6171 " to method list_unsupported_file_types" % key 6172 ) 6173 params[key] = val 6174 del params['kwargs'] 6175 # verify the required parameter 'account_id' is set 6176 if ('account_id' not in params) or (params['account_id'] is None): 6177 raise ValueError("Missing the required parameter `account_id` when calling `list_unsupported_file_types`") 6178 6179 6180 collection_formats = {} 6181 6182 resource_path = '/v2.1/accounts/{accountId}/unsupported_file_types'.replace('{format}', 'json') 6183 path_params = {} 6184 if 'account_id' in params: 6185 path_params['accountId'] = params['account_id'] 6186 6187 query_params = {} 6188 6189 header_params = {} 6190 6191 form_params = [] 6192 local_var_files = {} 6193 6194 body_params = None 6195 # HTTP header `Accept` 6196 header_params['Accept'] = self.api_client.\ 6197 select_header_accept(['application/json']) 6198 6199 # Authentication setting 6200 auth_settings = [] 6201 6202 return self.api_client.call_api(resource_path, 'GET', 6203 path_params, 6204 query_params, 6205 header_params, 6206 body=body_params, 6207 post_params=form_params, 6208 files=local_var_files, 6209 response_type='FileTypeList', 6210 auth_settings=auth_settings, 6211 callback=params.get('callback'), 6212 _return_http_data_only=params.get('_return_http_data_only'), 6213 _preload_content=params.get('_preload_content', True), 6214 _request_timeout=params.get('_request_timeout'), 6215 collection_formats=collection_formats) 6216 6217 def un_favorite_template(self, account_id, **kwargs): 6218 """ 6219 Unfavorite a template 6220 6221 This method makes a synchronous HTTP request by default. To make an 6222 asynchronous HTTP request, please define a `callback` function 6223 to be invoked when receiving the response. 6224 >>> def callback_function(response): 6225 >>> pprint(response) 6226 >>> 6227 >>> thread = api.un_favorite_template(account_id, callback=callback_function) 6228 6229 :param callback function: The callback function 6230 for asynchronous request. (optional) 6231 :param str account_id: The external account number (int) or account ID Guid. (required) 6232 :param FavoriteTemplatesInfo favorite_templates_info: 6233 :return: FavoriteTemplatesInfo 6234 If the method is called asynchronously, 6235 returns the request thread. 6236 """ 6237 kwargs['_return_http_data_only'] = True 6238 if kwargs.get('callback'): 6239 return self.un_favorite_template_with_http_info(account_id, **kwargs) 6240 else: 6241 (data) = self.un_favorite_template_with_http_info(account_id, **kwargs) 6242 return data 6243 6244 def un_favorite_template_with_http_info(self, account_id, **kwargs): 6245 """ 6246 Unfavorite a template 6247 6248 This method makes a synchronous HTTP request by default. To make an 6249 asynchronous HTTP request, please define a `callback` function 6250 to be invoked when receiving the response. 6251 >>> def callback_function(response): 6252 >>> pprint(response) 6253 >>> 6254 >>> thread = api.un_favorite_template_with_http_info(account_id, callback=callback_function) 6255 6256 :param callback function: The callback function 6257 for asynchronous request. (optional) 6258 :param str account_id: The external account number (int) or account ID Guid. (required) 6259 :param FavoriteTemplatesInfo favorite_templates_info: 6260 :return: FavoriteTemplatesInfo 6261 If the method is called asynchronously, 6262 returns the request thread. 6263 """ 6264 6265 all_params = ['account_id', 'favorite_templates_info'] 6266 all_params.append('callback') 6267 all_params.append('_return_http_data_only') 6268 all_params.append('_preload_content') 6269 all_params.append('_request_timeout') 6270 6271 params = locals() 6272 for key, val in iteritems(params['kwargs']): 6273 if key not in all_params: 6274 raise TypeError( 6275 "Got an unexpected keyword argument '%s'" 6276 " to method un_favorite_template" % key 6277 ) 6278 params[key] = val 6279 del params['kwargs'] 6280 # verify the required parameter 'account_id' is set 6281 if ('account_id' not in params) or (params['account_id'] is None): 6282 raise ValueError("Missing the required parameter `account_id` when calling `un_favorite_template`") 6283 6284 6285 collection_formats = {} 6286 6287 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 6288 path_params = {} 6289 if 'account_id' in params: 6290 path_params['accountId'] = params['account_id'] 6291 6292 query_params = {} 6293 6294 header_params = {} 6295 6296 form_params = [] 6297 local_var_files = {} 6298 6299 body_params = None 6300 if 'favorite_templates_info' in params: 6301 body_params = params['favorite_templates_info'] 6302 # HTTP header `Accept` 6303 header_params['Accept'] = self.api_client.\ 6304 select_header_accept(['application/json']) 6305 6306 # Authentication setting 6307 auth_settings = [] 6308 6309 return self.api_client.call_api(resource_path, 'DELETE', 6310 path_params, 6311 query_params, 6312 header_params, 6313 body=body_params, 6314 post_params=form_params, 6315 files=local_var_files, 6316 response_type='FavoriteTemplatesInfo', 6317 auth_settings=auth_settings, 6318 callback=params.get('callback'), 6319 _return_http_data_only=params.get('_return_http_data_only'), 6320 _preload_content=params.get('_preload_content', True), 6321 _request_timeout=params.get('_request_timeout'), 6322 collection_formats=collection_formats) 6323 6324 def update_account_signature(self, account_id, **kwargs): 6325 """ 6326 Updates a account signature. 6327 6328 This method makes a synchronous HTTP request by default. To make an 6329 asynchronous HTTP request, please define a `callback` function 6330 to be invoked when receiving the response. 6331 >>> def callback_function(response): 6332 >>> pprint(response) 6333 >>> 6334 >>> thread = api.update_account_signature(account_id, callback=callback_function) 6335 6336 :param callback function: The callback function 6337 for asynchronous request. (optional) 6338 :param str account_id: The external account number (int) or account ID Guid. (required) 6339 :param AccountSignaturesInformation account_signatures_information: 6340 :return: AccountSignaturesInformation 6341 If the method is called asynchronously, 6342 returns the request thread. 6343 """ 6344 kwargs['_return_http_data_only'] = True 6345 if kwargs.get('callback'): 6346 return self.update_account_signature_with_http_info(account_id, **kwargs) 6347 else: 6348 (data) = self.update_account_signature_with_http_info(account_id, **kwargs) 6349 return data 6350 6351 def update_account_signature_with_http_info(self, account_id, **kwargs): 6352 """ 6353 Updates a account signature. 6354 6355 This method makes a synchronous HTTP request by default. To make an 6356 asynchronous HTTP request, please define a `callback` function 6357 to be invoked when receiving the response. 6358 >>> def callback_function(response): 6359 >>> pprint(response) 6360 >>> 6361 >>> thread = api.update_account_signature_with_http_info(account_id, callback=callback_function) 6362 6363 :param callback function: The callback function 6364 for asynchronous request. (optional) 6365 :param str account_id: The external account number (int) or account ID Guid. (required) 6366 :param AccountSignaturesInformation account_signatures_information: 6367 :return: AccountSignaturesInformation 6368 If the method is called asynchronously, 6369 returns the request thread. 6370 """ 6371 6372 all_params = ['account_id', 'account_signatures_information'] 6373 all_params.append('callback') 6374 all_params.append('_return_http_data_only') 6375 all_params.append('_preload_content') 6376 all_params.append('_request_timeout') 6377 6378 params = locals() 6379 for key, val in iteritems(params['kwargs']): 6380 if key not in all_params: 6381 raise TypeError( 6382 "Got an unexpected keyword argument '%s'" 6383 " to method update_account_signature" % key 6384 ) 6385 params[key] = val 6386 del params['kwargs'] 6387 # verify the required parameter 'account_id' is set 6388 if ('account_id' not in params) or (params['account_id'] is None): 6389 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature`") 6390 6391 6392 collection_formats = {} 6393 6394 resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json') 6395 path_params = {} 6396 if 'account_id' in params: 6397 path_params['accountId'] = params['account_id'] 6398 6399 query_params = {} 6400 6401 header_params = {} 6402 6403 form_params = [] 6404 local_var_files = {} 6405 6406 body_params = None 6407 if 'account_signatures_information' in params: 6408 body_params = params['account_signatures_information'] 6409 # HTTP header `Accept` 6410 header_params['Accept'] = self.api_client.\ 6411 select_header_accept(['application/json']) 6412 6413 # Authentication setting 6414 auth_settings = [] 6415 6416 return self.api_client.call_api(resource_path, 'PUT', 6417 path_params, 6418 query_params, 6419 header_params, 6420 body=body_params, 6421 post_params=form_params, 6422 files=local_var_files, 6423 response_type='AccountSignaturesInformation', 6424 auth_settings=auth_settings, 6425 callback=params.get('callback'), 6426 _return_http_data_only=params.get('_return_http_data_only'), 6427 _preload_content=params.get('_preload_content', True), 6428 _request_timeout=params.get('_request_timeout'), 6429 collection_formats=collection_formats) 6430 6431 def update_account_signature_by_id(self, account_id, signature_id, **kwargs): 6432 """ 6433 Updates a account signature. 6434 6435 This method makes a synchronous HTTP request by default. To make an 6436 asynchronous HTTP request, please define a `callback` function 6437 to be invoked when receiving the response. 6438 >>> def callback_function(response): 6439 >>> pprint(response) 6440 >>> 6441 >>> thread = api.update_account_signature_by_id(account_id, signature_id, callback=callback_function) 6442 6443 :param callback function: The callback function 6444 for asynchronous request. (optional) 6445 :param str account_id: The external account number (int) or account ID Guid. (required) 6446 :param str signature_id: The ID of the signature being accessed. (required) 6447 :param str close_existing_signature: 6448 :param AccountSignatureDefinition account_signature_definition: 6449 :return: AccountSignature 6450 If the method is called asynchronously, 6451 returns the request thread. 6452 """ 6453 kwargs['_return_http_data_only'] = True 6454 if kwargs.get('callback'): 6455 return self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs) 6456 else: 6457 (data) = self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs) 6458 return data 6459 6460 def update_account_signature_by_id_with_http_info(self, account_id, signature_id, **kwargs): 6461 """ 6462 Updates a account signature. 6463 6464 This method makes a synchronous HTTP request by default. To make an 6465 asynchronous HTTP request, please define a `callback` function 6466 to be invoked when receiving the response. 6467 >>> def callback_function(response): 6468 >>> pprint(response) 6469 >>> 6470 >>> thread = api.update_account_signature_by_id_with_http_info(account_id, signature_id, callback=callback_function) 6471 6472 :param callback function: The callback function 6473 for asynchronous request. (optional) 6474 :param str account_id: The external account number (int) or account ID Guid. (required) 6475 :param str signature_id: The ID of the signature being accessed. (required) 6476 :param str close_existing_signature: 6477 :param AccountSignatureDefinition account_signature_definition: 6478 :return: AccountSignature 6479 If the method is called asynchronously, 6480 returns the request thread. 6481 """ 6482 6483 all_params = ['account_id', 'signature_id', 'close_existing_signature', 'account_signature_definition'] 6484 all_params.append('callback') 6485 all_params.append('_return_http_data_only') 6486 all_params.append('_preload_content') 6487 all_params.append('_request_timeout') 6488 6489 params = locals() 6490 for key, val in iteritems(params['kwargs']): 6491 if key not in all_params: 6492 raise TypeError( 6493 "Got an unexpected keyword argument '%s'" 6494 " to method update_account_signature_by_id" % key 6495 ) 6496 params[key] = val 6497 del params['kwargs'] 6498 # verify the required parameter 'account_id' is set 6499 if ('account_id' not in params) or (params['account_id'] is None): 6500 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_by_id`") 6501 # verify the required parameter 'signature_id' is set 6502 if ('signature_id' not in params) or (params['signature_id'] is None): 6503 raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_by_id`") 6504 6505 6506 collection_formats = {} 6507 6508 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 6509 path_params = {} 6510 if 'account_id' in params: 6511 path_params['accountId'] = params['account_id'] 6512 if 'signature_id' in params: 6513 path_params['signatureId'] = params['signature_id'] 6514 6515 query_params = {} 6516 if 'close_existing_signature' in params: 6517 query_params['close_existing_signature'] = params['close_existing_signature'] 6518 6519 header_params = {} 6520 6521 form_params = [] 6522 local_var_files = {} 6523 6524 body_params = None 6525 if 'account_signature_definition' in params: 6526 body_params = params['account_signature_definition'] 6527 # HTTP header `Accept` 6528 header_params['Accept'] = self.api_client.\ 6529 select_header_accept(['application/json']) 6530 6531 # Authentication setting 6532 auth_settings = [] 6533 6534 return self.api_client.call_api(resource_path, 'PUT', 6535 path_params, 6536 query_params, 6537 header_params, 6538 body=body_params, 6539 post_params=form_params, 6540 files=local_var_files, 6541 response_type='AccountSignature', 6542 auth_settings=auth_settings, 6543 callback=params.get('callback'), 6544 _return_http_data_only=params.get('_return_http_data_only'), 6545 _preload_content=params.get('_preload_content', True), 6546 _request_timeout=params.get('_request_timeout'), 6547 collection_formats=collection_formats) 6548 6549 def update_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 6550 """ 6551 Sets a signature, initials, or stamps image. 6552 6553 This method makes a synchronous HTTP request by default. To make an 6554 asynchronous HTTP request, please define a `callback` function 6555 to be invoked when receiving the response. 6556 >>> def callback_function(response): 6557 >>> pprint(response) 6558 >>> 6559 >>> thread = api.update_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 6560 6561 :param callback function: The callback function 6562 for asynchronous request. (optional) 6563 :param str account_id: The external account number (int) or account ID Guid. (required) 6564 :param str image_type: One of **signature_image** or **initials_image**. (required) 6565 :param str signature_id: The ID of the signature being accessed. (required) 6566 :param str transparent_png: 6567 :return: AccountSignature 6568 If the method is called asynchronously, 6569 returns the request thread. 6570 """ 6571 kwargs['_return_http_data_only'] = True 6572 if kwargs.get('callback'): 6573 return self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 6574 else: 6575 (data) = self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 6576 return data 6577 6578 def update_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 6579 """ 6580 Sets a signature, initials, or stamps image. 6581 6582 This method makes a synchronous HTTP request by default. To make an 6583 asynchronous HTTP request, please define a `callback` function 6584 to be invoked when receiving the response. 6585 >>> def callback_function(response): 6586 >>> pprint(response) 6587 >>> 6588 >>> thread = api.update_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 6589 6590 :param callback function: The callback function 6591 for asynchronous request. (optional) 6592 :param str account_id: The external account number (int) or account ID Guid. (required) 6593 :param str image_type: One of **signature_image** or **initials_image**. (required) 6594 :param str signature_id: The ID of the signature being accessed. (required) 6595 :param str transparent_png: 6596 :return: AccountSignature 6597 If the method is called asynchronously, 6598 returns the request thread. 6599 """ 6600 6601 all_params = ['account_id', 'image_type', 'signature_id', 'transparent_png'] 6602 all_params.append('callback') 6603 all_params.append('_return_http_data_only') 6604 all_params.append('_preload_content') 6605 all_params.append('_request_timeout') 6606 6607 params = locals() 6608 for key, val in iteritems(params['kwargs']): 6609 if key not in all_params: 6610 raise TypeError( 6611 "Got an unexpected keyword argument '%s'" 6612 " to method update_account_signature_image" % key 6613 ) 6614 params[key] = val 6615 del params['kwargs'] 6616 # verify the required parameter 'account_id' is set 6617 if ('account_id' not in params) or (params['account_id'] is None): 6618 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_image`") 6619 # verify the required parameter 'image_type' is set 6620 if ('image_type' not in params) or (params['image_type'] is None): 6621 raise ValueError("Missing the required parameter `image_type` when calling `update_account_signature_image`") 6622 # verify the required parameter 'signature_id' is set 6623 if ('signature_id' not in params) or (params['signature_id'] is None): 6624 raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_image`") 6625 6626 6627 collection_formats = {} 6628 6629 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 6630 path_params = {} 6631 if 'account_id' in params: 6632 path_params['accountId'] = params['account_id'] 6633 if 'image_type' in params: 6634 path_params['imageType'] = params['image_type'] 6635 if 'signature_id' in params: 6636 path_params['signatureId'] = params['signature_id'] 6637 6638 query_params = {} 6639 if 'transparent_png' in params: 6640 query_params['transparent_png'] = params['transparent_png'] 6641 6642 header_params = {} 6643 6644 form_params = [] 6645 local_var_files = {} 6646 6647 body_params = None 6648 # HTTP header `Accept` 6649 header_params['Accept'] = self.api_client.\ 6650 select_header_accept(['application/json']) 6651 6652 # HTTP header `Content-Type` 6653 header_params['Content-Type'] = self.api_client.\ 6654 select_header_content_type(['image/gif']) 6655 6656 # Authentication setting 6657 auth_settings = [] 6658 6659 return self.api_client.call_api(resource_path, 'PUT', 6660 path_params, 6661 query_params, 6662 header_params, 6663 body=body_params, 6664 post_params=form_params, 6665 files=local_var_files, 6666 response_type='AccountSignature', 6667 auth_settings=auth_settings, 6668 callback=params.get('callback'), 6669 _return_http_data_only=params.get('_return_http_data_only'), 6670 _preload_content=params.get('_preload_content', True), 6671 _request_timeout=params.get('_request_timeout'), 6672 collection_formats=collection_formats) 6673 6674 def update_account_tab_settings(self, account_id, **kwargs): 6675 """ 6676 Modifies tab settings for specified account 6677 This method modifies the tab types and tab functionality that is enabled for an account. 6678 This method makes a synchronous HTTP request by default. To make an 6679 asynchronous HTTP request, please define a `callback` function 6680 to be invoked when receiving the response. 6681 >>> def callback_function(response): 6682 >>> pprint(response) 6683 >>> 6684 >>> thread = api.update_account_tab_settings(account_id, callback=callback_function) 6685 6686 :param callback function: The callback function 6687 for asynchronous request. (optional) 6688 :param str account_id: The external account number (int) or account ID Guid. (required) 6689 :param TabAccountSettings tab_account_settings: 6690 :return: TabAccountSettings 6691 If the method is called asynchronously, 6692 returns the request thread. 6693 """ 6694 kwargs['_return_http_data_only'] = True 6695 if kwargs.get('callback'): 6696 return self.update_account_tab_settings_with_http_info(account_id, **kwargs) 6697 else: 6698 (data) = self.update_account_tab_settings_with_http_info(account_id, **kwargs) 6699 return data 6700 6701 def update_account_tab_settings_with_http_info(self, account_id, **kwargs): 6702 """ 6703 Modifies tab settings for specified account 6704 This method modifies the tab types and tab functionality that is enabled for an account. 6705 This method makes a synchronous HTTP request by default. To make an 6706 asynchronous HTTP request, please define a `callback` function 6707 to be invoked when receiving the response. 6708 >>> def callback_function(response): 6709 >>> pprint(response) 6710 >>> 6711 >>> thread = api.update_account_tab_settings_with_http_info(account_id, callback=callback_function) 6712 6713 :param callback function: The callback function 6714 for asynchronous request. (optional) 6715 :param str account_id: The external account number (int) or account ID Guid. (required) 6716 :param TabAccountSettings tab_account_settings: 6717 :return: TabAccountSettings 6718 If the method is called asynchronously, 6719 returns the request thread. 6720 """ 6721 6722 all_params = ['account_id', 'tab_account_settings'] 6723 all_params.append('callback') 6724 all_params.append('_return_http_data_only') 6725 all_params.append('_preload_content') 6726 all_params.append('_request_timeout') 6727 6728 params = locals() 6729 for key, val in iteritems(params['kwargs']): 6730 if key not in all_params: 6731 raise TypeError( 6732 "Got an unexpected keyword argument '%s'" 6733 " to method update_account_tab_settings" % key 6734 ) 6735 params[key] = val 6736 del params['kwargs'] 6737 # verify the required parameter 'account_id' is set 6738 if ('account_id' not in params) or (params['account_id'] is None): 6739 raise ValueError("Missing the required parameter `account_id` when calling `update_account_tab_settings`") 6740 6741 6742 collection_formats = {} 6743 6744 resource_path = '/v2.1/accounts/{accountId}/settings/tabs'.replace('{format}', 'json') 6745 path_params = {} 6746 if 'account_id' in params: 6747 path_params['accountId'] = params['account_id'] 6748 6749 query_params = {} 6750 6751 header_params = {} 6752 6753 form_params = [] 6754 local_var_files = {} 6755 6756 body_params = None 6757 if 'tab_account_settings' in params: 6758 body_params = params['tab_account_settings'] 6759 # HTTP header `Accept` 6760 header_params['Accept'] = self.api_client.\ 6761 select_header_accept(['application/json']) 6762 6763 # Authentication setting 6764 auth_settings = [] 6765 6766 return self.api_client.call_api(resource_path, 'PUT', 6767 path_params, 6768 query_params, 6769 header_params, 6770 body=body_params, 6771 post_params=form_params, 6772 files=local_var_files, 6773 response_type='TabAccountSettings', 6774 auth_settings=auth_settings, 6775 callback=params.get('callback'), 6776 _return_http_data_only=params.get('_return_http_data_only'), 6777 _preload_content=params.get('_preload_content', True), 6778 _request_timeout=params.get('_request_timeout'), 6779 collection_formats=collection_formats) 6780 6781 def update_brand(self, account_id, brand_id, **kwargs): 6782 """ 6783 Updates an existing brand. 6784 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**). 6785 This method makes a synchronous HTTP request by default. To make an 6786 asynchronous HTTP request, please define a `callback` function 6787 to be invoked when receiving the response. 6788 >>> def callback_function(response): 6789 >>> pprint(response) 6790 >>> 6791 >>> thread = api.update_brand(account_id, brand_id, callback=callback_function) 6792 6793 :param callback function: The callback function 6794 for asynchronous request. (optional) 6795 :param str account_id: The external account number (int) or account ID Guid. (required) 6796 :param str brand_id: The unique identifier of a brand. (required) 6797 :param str replace_brand: 6798 :param Brand brand: 6799 :return: Brand 6800 If the method is called asynchronously, 6801 returns the request thread. 6802 """ 6803 kwargs['_return_http_data_only'] = True 6804 if kwargs.get('callback'): 6805 return self.update_brand_with_http_info(account_id, brand_id, **kwargs) 6806 else: 6807 (data) = self.update_brand_with_http_info(account_id, brand_id, **kwargs) 6808 return data 6809 6810 def update_brand_with_http_info(self, account_id, brand_id, **kwargs): 6811 """ 6812 Updates an existing brand. 6813 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**). 6814 This method makes a synchronous HTTP request by default. To make an 6815 asynchronous HTTP request, please define a `callback` function 6816 to be invoked when receiving the response. 6817 >>> def callback_function(response): 6818 >>> pprint(response) 6819 >>> 6820 >>> thread = api.update_brand_with_http_info(account_id, brand_id, callback=callback_function) 6821 6822 :param callback function: The callback function 6823 for asynchronous request. (optional) 6824 :param str account_id: The external account number (int) or account ID Guid. (required) 6825 :param str brand_id: The unique identifier of a brand. (required) 6826 :param str replace_brand: 6827 :param Brand brand: 6828 :return: Brand 6829 If the method is called asynchronously, 6830 returns the request thread. 6831 """ 6832 6833 all_params = ['account_id', 'brand_id', 'replace_brand', 'brand'] 6834 all_params.append('callback') 6835 all_params.append('_return_http_data_only') 6836 all_params.append('_preload_content') 6837 all_params.append('_request_timeout') 6838 6839 params = locals() 6840 for key, val in iteritems(params['kwargs']): 6841 if key not in all_params: 6842 raise TypeError( 6843 "Got an unexpected keyword argument '%s'" 6844 " to method update_brand" % key 6845 ) 6846 params[key] = val 6847 del params['kwargs'] 6848 # verify the required parameter 'account_id' is set 6849 if ('account_id' not in params) or (params['account_id'] is None): 6850 raise ValueError("Missing the required parameter `account_id` when calling `update_brand`") 6851 # verify the required parameter 'brand_id' is set 6852 if ('brand_id' not in params) or (params['brand_id'] is None): 6853 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand`") 6854 6855 6856 collection_formats = {} 6857 6858 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 6859 path_params = {} 6860 if 'account_id' in params: 6861 path_params['accountId'] = params['account_id'] 6862 if 'brand_id' in params: 6863 path_params['brandId'] = params['brand_id'] 6864 6865 query_params = {} 6866 if 'replace_brand' in params: 6867 query_params['replace_brand'] = params['replace_brand'] 6868 6869 header_params = {} 6870 6871 form_params = [] 6872 local_var_files = {} 6873 6874 body_params = None 6875 if 'brand' in params: 6876 body_params = params['brand'] 6877 # HTTP header `Accept` 6878 header_params['Accept'] = self.api_client.\ 6879 select_header_accept(['application/json']) 6880 6881 # Authentication setting 6882 auth_settings = [] 6883 6884 return self.api_client.call_api(resource_path, 'PUT', 6885 path_params, 6886 query_params, 6887 header_params, 6888 body=body_params, 6889 post_params=form_params, 6890 files=local_var_files, 6891 response_type='Brand', 6892 auth_settings=auth_settings, 6893 callback=params.get('callback'), 6894 _return_http_data_only=params.get('_return_http_data_only'), 6895 _preload_content=params.get('_preload_content', True), 6896 _request_timeout=params.get('_request_timeout'), 6897 collection_formats=collection_formats) 6898 6899 def update_brand_logo_by_type(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs): 6900 """ 6901 Put one branding logo. 6902 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**). 6903 This method makes a synchronous HTTP request by default. To make an 6904 asynchronous HTTP request, please define a `callback` function 6905 to be invoked when receiving the response. 6906 >>> def callback_function(response): 6907 >>> pprint(response) 6908 >>> 6909 >>> thread = api.update_brand_logo_by_type(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function) 6910 6911 :param callback function: The callback function 6912 for asynchronous request. (optional) 6913 :param str account_id: The external account number (int) or account ID GUID. (required) 6914 :param str brand_id: The ID of the brand. (required) 6915 :param str logo_type: The type of logo. Valid values are: - `primary` - `secondary` - `email` (required) 6916 :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) 6917 :return: None 6918 If the method is called asynchronously, 6919 returns the request thread. 6920 """ 6921 kwargs['_return_http_data_only'] = True 6922 if kwargs.get('callback'): 6923 return self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs) 6924 else: 6925 (data) = self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs) 6926 return data 6927 6928 def update_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs): 6929 """ 6930 Put one branding logo. 6931 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**). 6932 This method makes a synchronous HTTP request by default. To make an 6933 asynchronous HTTP request, please define a `callback` function 6934 to be invoked when receiving the response. 6935 >>> def callback_function(response): 6936 >>> pprint(response) 6937 >>> 6938 >>> thread = api.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function) 6939 6940 :param callback function: The callback function 6941 for asynchronous request. (optional) 6942 :param str account_id: The external account number (int) or account ID GUID. (required) 6943 :param str brand_id: The ID of the brand. (required) 6944 :param str logo_type: The type of logo. Valid values are: - `primary` - `secondary` - `email` (required) 6945 :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) 6946 :return: None 6947 If the method is called asynchronously, 6948 returns the request thread. 6949 """ 6950 6951 all_params = ['account_id', 'brand_id', 'logo_type', 'logo_file_bytes'] 6952 all_params.append('callback') 6953 all_params.append('_return_http_data_only') 6954 all_params.append('_preload_content') 6955 all_params.append('_request_timeout') 6956 6957 params = locals() 6958 for key, val in iteritems(params['kwargs']): 6959 if key not in all_params: 6960 raise TypeError( 6961 "Got an unexpected keyword argument '%s'" 6962 " to method update_brand_logo_by_type" % key 6963 ) 6964 params[key] = val 6965 del params['kwargs'] 6966 # verify the required parameter 'account_id' is set 6967 if ('account_id' not in params) or (params['account_id'] is None): 6968 raise ValueError("Missing the required parameter `account_id` when calling `update_brand_logo_by_type`") 6969 # verify the required parameter 'brand_id' is set 6970 if ('brand_id' not in params) or (params['brand_id'] is None): 6971 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_logo_by_type`") 6972 # verify the required parameter 'logo_type' is set 6973 if ('logo_type' not in params) or (params['logo_type'] is None): 6974 raise ValueError("Missing the required parameter `logo_type` when calling `update_brand_logo_by_type`") 6975 # verify the required parameter 'logo_file_bytes' is set 6976 if ('logo_file_bytes' not in params) or (params['logo_file_bytes'] is None): 6977 raise ValueError("Missing the required parameter `logo_file_bytes` when calling `update_brand_logo_by_type`") 6978 6979 6980 collection_formats = {} 6981 6982 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 6983 path_params = {} 6984 if 'account_id' in params: 6985 path_params['accountId'] = params['account_id'] 6986 if 'brand_id' in params: 6987 path_params['brandId'] = params['brand_id'] 6988 if 'logo_type' in params: 6989 path_params['logoType'] = params['logo_type'] 6990 6991 query_params = {} 6992 6993 header_params = {} 6994 6995 form_params = [] 6996 local_var_files = {} 6997 6998 body_params = None 6999 if 'logo_file_bytes' in params: 7000 body_params = params['logo_file_bytes'] 7001 # HTTP header `Accept` 7002 header_params['Accept'] = self.api_client.\ 7003 select_header_accept(['application/json']) 7004 7005 # HTTP header `Content-Type` 7006 header_params['Content-Type'] = self.api_client.\ 7007 select_header_content_type(['image/png']) 7008 7009 # Authentication setting 7010 auth_settings = [] 7011 7012 return self.api_client.call_api(resource_path, 'PUT', 7013 path_params, 7014 query_params, 7015 header_params, 7016 body=body_params, 7017 post_params=form_params, 7018 files=local_var_files, 7019 response_type=None, 7020 auth_settings=auth_settings, 7021 callback=params.get('callback'), 7022 _return_http_data_only=params.get('_return_http_data_only'), 7023 _preload_content=params.get('_preload_content', True), 7024 _request_timeout=params.get('_request_timeout'), 7025 collection_formats=collection_formats) 7026 7027 def update_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, file_xml, **kwargs): 7028 """ 7029 Uploads a branding resource file. 7030 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. 7031 This method makes a synchronous HTTP request by default. To make an 7032 asynchronous HTTP request, please define a `callback` function 7033 to be invoked when receiving the response. 7034 >>> def callback_function(response): 7035 >>> pprint(response) 7036 >>> 7037 >>> thread = api.update_brand_resources_by_content_type(account_id, brand_id, resource_content_type, file_xml, callback=callback_function) 7038 7039 :param callback function: The callback function 7040 for asynchronous request. (optional) 7041 :param str account_id: The external account number (int) or account ID GUID. (required) 7042 :param str brand_id: The ID of the brand. (required) 7043 :param str resource_content_type: The type of brand resource file that you are updating. Valid values are: - `sending` - `signing` - `email` - `signing_captive` (required) 7044 :param file file_xml: Brand resource XML file. (required) 7045 :return: BrandResources 7046 If the method is called asynchronously, 7047 returns the request thread. 7048 """ 7049 kwargs['_return_http_data_only'] = True 7050 if kwargs.get('callback'): 7051 return self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs) 7052 else: 7053 (data) = self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs) 7054 return data 7055 7056 def update_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, file_xml, **kwargs): 7057 """ 7058 Uploads a branding resource file. 7059 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. 7060 This method makes a synchronous HTTP request by default. To make an 7061 asynchronous HTTP request, please define a `callback` function 7062 to be invoked when receiving the response. 7063 >>> def callback_function(response): 7064 >>> pprint(response) 7065 >>> 7066 >>> thread = api.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, callback=callback_function) 7067 7068 :param callback function: The callback function 7069 for asynchronous request. (optional) 7070 :param str account_id: The external account number (int) or account ID GUID. (required) 7071 :param str brand_id: The ID of the brand. (required) 7072 :param str resource_content_type: The type of brand resource file that you are updating. Valid values are: - `sending` - `signing` - `email` - `signing_captive` (required) 7073 :param file file_xml: Brand resource XML file. (required) 7074 :return: BrandResources 7075 If the method is called asynchronously, 7076 returns the request thread. 7077 """ 7078 7079 all_params = ['account_id', 'brand_id', 'resource_content_type', 'file_xml'] 7080 all_params.append('callback') 7081 all_params.append('_return_http_data_only') 7082 all_params.append('_preload_content') 7083 all_params.append('_request_timeout') 7084 7085 params = locals() 7086 for key, val in iteritems(params['kwargs']): 7087 if key not in all_params: 7088 raise TypeError( 7089 "Got an unexpected keyword argument '%s'" 7090 " to method update_brand_resources_by_content_type" % key 7091 ) 7092 params[key] = val 7093 del params['kwargs'] 7094 # verify the required parameter 'account_id' is set 7095 if ('account_id' not in params) or (params['account_id'] is None): 7096 raise ValueError("Missing the required parameter `account_id` when calling `update_brand_resources_by_content_type`") 7097 # verify the required parameter 'brand_id' is set 7098 if ('brand_id' not in params) or (params['brand_id'] is None): 7099 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_resources_by_content_type`") 7100 # verify the required parameter 'resource_content_type' is set 7101 if ('resource_content_type' not in params) or (params['resource_content_type'] is None): 7102 raise ValueError("Missing the required parameter `resource_content_type` when calling `update_brand_resources_by_content_type`") 7103 # verify the required parameter 'file_xml' is set 7104 if ('file_xml' not in params) or (params['file_xml'] is None): 7105 raise ValueError("Missing the required parameter `file_xml` when calling `update_brand_resources_by_content_type`") 7106 7107 7108 collection_formats = {} 7109 7110 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources/{resourceContentType}'.replace('{format}', 'json') 7111 path_params = {} 7112 if 'account_id' in params: 7113 path_params['accountId'] = params['account_id'] 7114 if 'brand_id' in params: 7115 path_params['brandId'] = params['brand_id'] 7116 if 'resource_content_type' in params: 7117 path_params['resourceContentType'] = params['resource_content_type'] 7118 7119 query_params = {} 7120 7121 header_params = {} 7122 7123 form_params = [] 7124 local_var_files = {} 7125 if 'file_xml' in params: 7126 local_var_files['file.xml'] = params['file_xml'] 7127 7128 body_params = None 7129 # HTTP header `Accept` 7130 header_params['Accept'] = self.api_client.\ 7131 select_header_accept(['application/json']) 7132 7133 # HTTP header `Content-Type` 7134 header_params['Content-Type'] = self.api_client.\ 7135 select_header_content_type(['multipart/form-data']) 7136 7137 # Authentication setting 7138 auth_settings = [] 7139 7140 return self.api_client.call_api(resource_path, 'PUT', 7141 path_params, 7142 query_params, 7143 header_params, 7144 body=body_params, 7145 post_params=form_params, 7146 files=local_var_files, 7147 response_type='BrandResources', 7148 auth_settings=auth_settings, 7149 callback=params.get('callback'), 7150 _return_http_data_only=params.get('_return_http_data_only'), 7151 _preload_content=params.get('_preload_content', True), 7152 _request_timeout=params.get('_request_timeout'), 7153 collection_formats=collection_formats) 7154 7155 def update_consumer_disclosure(self, account_id, lang_code, **kwargs): 7156 """ 7157 Update Consumer Disclosure. 7158 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. 7159 This method makes a synchronous HTTP request by default. To make an 7160 asynchronous HTTP request, please define a `callback` function 7161 to be invoked when receiving the response. 7162 >>> def callback_function(response): 7163 >>> pprint(response) 7164 >>> 7165 >>> thread = api.update_consumer_disclosure(account_id, lang_code, callback=callback_function) 7166 7167 :param callback function: The callback function 7168 for asynchronous request. (optional) 7169 :param str account_id: The external account number (int) or account ID Guid. (required) 7170 :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) 7171 :param str include_metadata: 7172 :param ConsumerDisclosure consumer_disclosure: 7173 :return: ConsumerDisclosure 7174 If the method is called asynchronously, 7175 returns the request thread. 7176 """ 7177 kwargs['_return_http_data_only'] = True 7178 if kwargs.get('callback'): 7179 return self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 7180 else: 7181 (data) = self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 7182 return data 7183 7184 def update_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs): 7185 """ 7186 Update Consumer Disclosure. 7187 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. 7188 This method makes a synchronous HTTP request by default. To make an 7189 asynchronous HTTP request, please define a `callback` function 7190 to be invoked when receiving the response. 7191 >>> def callback_function(response): 7192 >>> pprint(response) 7193 >>> 7194 >>> thread = api.update_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function) 7195 7196 :param callback function: The callback function 7197 for asynchronous request. (optional) 7198 :param str account_id: The external account number (int) or account ID Guid. (required) 7199 :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) 7200 :param str include_metadata: 7201 :param ConsumerDisclosure consumer_disclosure: 7202 :return: ConsumerDisclosure 7203 If the method is called asynchronously, 7204 returns the request thread. 7205 """ 7206 7207 all_params = ['account_id', 'lang_code', 'include_metadata', 'consumer_disclosure'] 7208 all_params.append('callback') 7209 all_params.append('_return_http_data_only') 7210 all_params.append('_preload_content') 7211 all_params.append('_request_timeout') 7212 7213 params = locals() 7214 for key, val in iteritems(params['kwargs']): 7215 if key not in all_params: 7216 raise TypeError( 7217 "Got an unexpected keyword argument '%s'" 7218 " to method update_consumer_disclosure" % key 7219 ) 7220 params[key] = val 7221 del params['kwargs'] 7222 # verify the required parameter 'account_id' is set 7223 if ('account_id' not in params) or (params['account_id'] is None): 7224 raise ValueError("Missing the required parameter `account_id` when calling `update_consumer_disclosure`") 7225 # verify the required parameter 'lang_code' is set 7226 if ('lang_code' not in params) or (params['lang_code'] is None): 7227 raise ValueError("Missing the required parameter `lang_code` when calling `update_consumer_disclosure`") 7228 7229 7230 collection_formats = {} 7231 7232 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 7233 path_params = {} 7234 if 'account_id' in params: 7235 path_params['accountId'] = params['account_id'] 7236 if 'lang_code' in params: 7237 path_params['langCode'] = params['lang_code'] 7238 7239 query_params = {} 7240 if 'include_metadata' in params: 7241 query_params['include_metadata'] = params['include_metadata'] 7242 7243 header_params = {} 7244 7245 form_params = [] 7246 local_var_files = {} 7247 7248 body_params = None 7249 if 'consumer_disclosure' in params: 7250 body_params = params['consumer_disclosure'] 7251 # HTTP header `Accept` 7252 header_params['Accept'] = self.api_client.\ 7253 select_header_accept(['application/json']) 7254 7255 # Authentication setting 7256 auth_settings = [] 7257 7258 return self.api_client.call_api(resource_path, 'PUT', 7259 path_params, 7260 query_params, 7261 header_params, 7262 body=body_params, 7263 post_params=form_params, 7264 files=local_var_files, 7265 response_type='ConsumerDisclosure', 7266 auth_settings=auth_settings, 7267 callback=params.get('callback'), 7268 _return_http_data_only=params.get('_return_http_data_only'), 7269 _preload_content=params.get('_preload_content', True), 7270 _request_timeout=params.get('_request_timeout'), 7271 collection_formats=collection_formats) 7272 7273 def update_custom_field(self, account_id, custom_field_id, **kwargs): 7274 """ 7275 Updates an existing account custom field. 7276 This method updates an existing account custom field. 7277 This method makes a synchronous HTTP request by default. To make an 7278 asynchronous HTTP request, please define a `callback` function 7279 to be invoked when receiving the response. 7280 >>> def callback_function(response): 7281 >>> pprint(response) 7282 >>> 7283 >>> thread = api.update_custom_field(account_id, custom_field_id, callback=callback_function) 7284 7285 :param callback function: The callback function 7286 for asynchronous request. (optional) 7287 :param str account_id: The external account number (int) or account ID Guid. (required) 7288 :param str custom_field_id: (required) 7289 :param str apply_to_templates: 7290 :param CustomField custom_field: 7291 :return: CustomFields 7292 If the method is called asynchronously, 7293 returns the request thread. 7294 """ 7295 kwargs['_return_http_data_only'] = True 7296 if kwargs.get('callback'): 7297 return self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 7298 else: 7299 (data) = self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 7300 return data 7301 7302 def update_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs): 7303 """ 7304 Updates an existing account custom field. 7305 This method updates an existing account custom field. 7306 This method makes a synchronous HTTP request by default. To make an 7307 asynchronous HTTP request, please define a `callback` function 7308 to be invoked when receiving the response. 7309 >>> def callback_function(response): 7310 >>> pprint(response) 7311 >>> 7312 >>> thread = api.update_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function) 7313 7314 :param callback function: The callback function 7315 for asynchronous request. (optional) 7316 :param str account_id: The external account number (int) or account ID Guid. (required) 7317 :param str custom_field_id: (required) 7318 :param str apply_to_templates: 7319 :param CustomField custom_field: 7320 :return: CustomFields 7321 If the method is called asynchronously, 7322 returns the request thread. 7323 """ 7324 7325 all_params = ['account_id', 'custom_field_id', 'apply_to_templates', 'custom_field'] 7326 all_params.append('callback') 7327 all_params.append('_return_http_data_only') 7328 all_params.append('_preload_content') 7329 all_params.append('_request_timeout') 7330 7331 params = locals() 7332 for key, val in iteritems(params['kwargs']): 7333 if key not in all_params: 7334 raise TypeError( 7335 "Got an unexpected keyword argument '%s'" 7336 " to method update_custom_field" % key 7337 ) 7338 params[key] = val 7339 del params['kwargs'] 7340 # verify the required parameter 'account_id' is set 7341 if ('account_id' not in params) or (params['account_id'] is None): 7342 raise ValueError("Missing the required parameter `account_id` when calling `update_custom_field`") 7343 # verify the required parameter 'custom_field_id' is set 7344 if ('custom_field_id' not in params) or (params['custom_field_id'] is None): 7345 raise ValueError("Missing the required parameter `custom_field_id` when calling `update_custom_field`") 7346 7347 7348 collection_formats = {} 7349 7350 resource_path = '/v2.1/accounts/{accountId}/custom_fields/{customFieldId}'.replace('{format}', 'json') 7351 path_params = {} 7352 if 'account_id' in params: 7353 path_params['accountId'] = params['account_id'] 7354 if 'custom_field_id' in params: 7355 path_params['customFieldId'] = params['custom_field_id'] 7356 7357 query_params = {} 7358 if 'apply_to_templates' in params: 7359 query_params['apply_to_templates'] = params['apply_to_templates'] 7360 7361 header_params = {} 7362 7363 form_params = [] 7364 local_var_files = {} 7365 7366 body_params = None 7367 if 'custom_field' in params: 7368 body_params = params['custom_field'] 7369 # HTTP header `Accept` 7370 header_params['Accept'] = self.api_client.\ 7371 select_header_accept(['application/json']) 7372 7373 # Authentication setting 7374 auth_settings = [] 7375 7376 return self.api_client.call_api(resource_path, 'PUT', 7377 path_params, 7378 query_params, 7379 header_params, 7380 body=body_params, 7381 post_params=form_params, 7382 files=local_var_files, 7383 response_type='CustomFields', 7384 auth_settings=auth_settings, 7385 callback=params.get('callback'), 7386 _return_http_data_only=params.get('_return_http_data_only'), 7387 _preload_content=params.get('_preload_content', True), 7388 _request_timeout=params.get('_request_timeout'), 7389 collection_formats=collection_formats) 7390 7391 def update_e_note_configuration(self, account_id, **kwargs): 7392 """ 7393 Updates configuration information for the eNote eOriginal integration. 7394 7395 This method makes a synchronous HTTP request by default. To make an 7396 asynchronous HTTP request, please define a `callback` function 7397 to be invoked when receiving the response. 7398 >>> def callback_function(response): 7399 >>> pprint(response) 7400 >>> 7401 >>> thread = api.update_e_note_configuration(account_id, callback=callback_function) 7402 7403 :param callback function: The callback function 7404 for asynchronous request. (optional) 7405 :param str account_id: The external account number (int) or account ID Guid. (required) 7406 :param ENoteConfiguration e_note_configuration: 7407 :return: ENoteConfiguration 7408 If the method is called asynchronously, 7409 returns the request thread. 7410 """ 7411 kwargs['_return_http_data_only'] = True 7412 if kwargs.get('callback'): 7413 return self.update_e_note_configuration_with_http_info(account_id, **kwargs) 7414 else: 7415 (data) = self.update_e_note_configuration_with_http_info(account_id, **kwargs) 7416 return data 7417 7418 def update_e_note_configuration_with_http_info(self, account_id, **kwargs): 7419 """ 7420 Updates configuration information for the eNote eOriginal integration. 7421 7422 This method makes a synchronous HTTP request by default. To make an 7423 asynchronous HTTP request, please define a `callback` function 7424 to be invoked when receiving the response. 7425 >>> def callback_function(response): 7426 >>> pprint(response) 7427 >>> 7428 >>> thread = api.update_e_note_configuration_with_http_info(account_id, callback=callback_function) 7429 7430 :param callback function: The callback function 7431 for asynchronous request. (optional) 7432 :param str account_id: The external account number (int) or account ID Guid. (required) 7433 :param ENoteConfiguration e_note_configuration: 7434 :return: ENoteConfiguration 7435 If the method is called asynchronously, 7436 returns the request thread. 7437 """ 7438 7439 all_params = ['account_id', 'e_note_configuration'] 7440 all_params.append('callback') 7441 all_params.append('_return_http_data_only') 7442 all_params.append('_preload_content') 7443 all_params.append('_request_timeout') 7444 7445 params = locals() 7446 for key, val in iteritems(params['kwargs']): 7447 if key not in all_params: 7448 raise TypeError( 7449 "Got an unexpected keyword argument '%s'" 7450 " to method update_e_note_configuration" % key 7451 ) 7452 params[key] = val 7453 del params['kwargs'] 7454 # verify the required parameter 'account_id' is set 7455 if ('account_id' not in params) or (params['account_id'] is None): 7456 raise ValueError("Missing the required parameter `account_id` when calling `update_e_note_configuration`") 7457 7458 7459 collection_formats = {} 7460 7461 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 7462 path_params = {} 7463 if 'account_id' in params: 7464 path_params['accountId'] = params['account_id'] 7465 7466 query_params = {} 7467 7468 header_params = {} 7469 7470 form_params = [] 7471 local_var_files = {} 7472 7473 body_params = None 7474 if 'e_note_configuration' in params: 7475 body_params = params['e_note_configuration'] 7476 # HTTP header `Accept` 7477 header_params['Accept'] = self.api_client.\ 7478 select_header_accept(['application/json']) 7479 7480 # Authentication setting 7481 auth_settings = [] 7482 7483 return self.api_client.call_api(resource_path, 'PUT', 7484 path_params, 7485 query_params, 7486 header_params, 7487 body=body_params, 7488 post_params=form_params, 7489 files=local_var_files, 7490 response_type='ENoteConfiguration', 7491 auth_settings=auth_settings, 7492 callback=params.get('callback'), 7493 _return_http_data_only=params.get('_return_http_data_only'), 7494 _preload_content=params.get('_preload_content', True), 7495 _request_timeout=params.get('_request_timeout'), 7496 collection_formats=collection_formats) 7497 7498 def update_envelope_purge_configuration(self, account_id, **kwargs): 7499 """ 7500 Updates envelope purge configuration. 7501 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). 7502 This method makes a synchronous HTTP request by default. To make an 7503 asynchronous HTTP request, please define a `callback` function 7504 to be invoked when receiving the response. 7505 >>> def callback_function(response): 7506 >>> pprint(response) 7507 >>> 7508 >>> thread = api.update_envelope_purge_configuration(account_id, callback=callback_function) 7509 7510 :param callback function: The callback function 7511 for asynchronous request. (optional) 7512 :param str account_id: The external account number (int) or account ID Guid. (required) 7513 :param EnvelopePurgeConfiguration envelope_purge_configuration: 7514 :return: EnvelopePurgeConfiguration 7515 If the method is called asynchronously, 7516 returns the request thread. 7517 """ 7518 kwargs['_return_http_data_only'] = True 7519 if kwargs.get('callback'): 7520 return self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs) 7521 else: 7522 (data) = self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs) 7523 return data 7524 7525 def update_envelope_purge_configuration_with_http_info(self, account_id, **kwargs): 7526 """ 7527 Updates envelope purge configuration. 7528 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). 7529 This method makes a synchronous HTTP request by default. To make an 7530 asynchronous HTTP request, please define a `callback` function 7531 to be invoked when receiving the response. 7532 >>> def callback_function(response): 7533 >>> pprint(response) 7534 >>> 7535 >>> thread = api.update_envelope_purge_configuration_with_http_info(account_id, callback=callback_function) 7536 7537 :param callback function: The callback function 7538 for asynchronous request. (optional) 7539 :param str account_id: The external account number (int) or account ID Guid. (required) 7540 :param EnvelopePurgeConfiguration envelope_purge_configuration: 7541 :return: EnvelopePurgeConfiguration 7542 If the method is called asynchronously, 7543 returns the request thread. 7544 """ 7545 7546 all_params = ['account_id', 'envelope_purge_configuration'] 7547 all_params.append('callback') 7548 all_params.append('_return_http_data_only') 7549 all_params.append('_preload_content') 7550 all_params.append('_request_timeout') 7551 7552 params = locals() 7553 for key, val in iteritems(params['kwargs']): 7554 if key not in all_params: 7555 raise TypeError( 7556 "Got an unexpected keyword argument '%s'" 7557 " to method update_envelope_purge_configuration" % key 7558 ) 7559 params[key] = val 7560 del params['kwargs'] 7561 # verify the required parameter 'account_id' is set 7562 if ('account_id' not in params) or (params['account_id'] is None): 7563 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_purge_configuration`") 7564 7565 7566 collection_formats = {} 7567 7568 resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json') 7569 path_params = {} 7570 if 'account_id' in params: 7571 path_params['accountId'] = params['account_id'] 7572 7573 query_params = {} 7574 7575 header_params = {} 7576 7577 form_params = [] 7578 local_var_files = {} 7579 7580 body_params = None 7581 if 'envelope_purge_configuration' in params: 7582 body_params = params['envelope_purge_configuration'] 7583 # HTTP header `Accept` 7584 header_params['Accept'] = self.api_client.\ 7585 select_header_accept(['application/json']) 7586 7587 # Authentication setting 7588 auth_settings = [] 7589 7590 return self.api_client.call_api(resource_path, 'PUT', 7591 path_params, 7592 query_params, 7593 header_params, 7594 body=body_params, 7595 post_params=form_params, 7596 files=local_var_files, 7597 response_type='EnvelopePurgeConfiguration', 7598 auth_settings=auth_settings, 7599 callback=params.get('callback'), 7600 _return_http_data_only=params.get('_return_http_data_only'), 7601 _preload_content=params.get('_preload_content', True), 7602 _request_timeout=params.get('_request_timeout'), 7603 collection_formats=collection_formats) 7604 7605 def update_favorite_template(self, account_id, **kwargs): 7606 """ 7607 Favorites a template 7608 7609 This method makes a synchronous HTTP request by default. To make an 7610 asynchronous HTTP request, please define a `callback` function 7611 to be invoked when receiving the response. 7612 >>> def callback_function(response): 7613 >>> pprint(response) 7614 >>> 7615 >>> thread = api.update_favorite_template(account_id, callback=callback_function) 7616 7617 :param callback function: The callback function 7618 for asynchronous request. (optional) 7619 :param str account_id: The external account number (int) or account ID Guid. (required) 7620 :param FavoriteTemplatesInfo favorite_templates_info: 7621 :return: FavoriteTemplatesInfo 7622 If the method is called asynchronously, 7623 returns the request thread. 7624 """ 7625 kwargs['_return_http_data_only'] = True 7626 if kwargs.get('callback'): 7627 return self.update_favorite_template_with_http_info(account_id, **kwargs) 7628 else: 7629 (data) = self.update_favorite_template_with_http_info(account_id, **kwargs) 7630 return data 7631 7632 def update_favorite_template_with_http_info(self, account_id, **kwargs): 7633 """ 7634 Favorites a template 7635 7636 This method makes a synchronous HTTP request by default. To make an 7637 asynchronous HTTP request, please define a `callback` function 7638 to be invoked when receiving the response. 7639 >>> def callback_function(response): 7640 >>> pprint(response) 7641 >>> 7642 >>> thread = api.update_favorite_template_with_http_info(account_id, callback=callback_function) 7643 7644 :param callback function: The callback function 7645 for asynchronous request. (optional) 7646 :param str account_id: The external account number (int) or account ID Guid. (required) 7647 :param FavoriteTemplatesInfo favorite_templates_info: 7648 :return: FavoriteTemplatesInfo 7649 If the method is called asynchronously, 7650 returns the request thread. 7651 """ 7652 7653 all_params = ['account_id', 'favorite_templates_info'] 7654 all_params.append('callback') 7655 all_params.append('_return_http_data_only') 7656 all_params.append('_preload_content') 7657 all_params.append('_request_timeout') 7658 7659 params = locals() 7660 for key, val in iteritems(params['kwargs']): 7661 if key not in all_params: 7662 raise TypeError( 7663 "Got an unexpected keyword argument '%s'" 7664 " to method update_favorite_template" % key 7665 ) 7666 params[key] = val 7667 del params['kwargs'] 7668 # verify the required parameter 'account_id' is set 7669 if ('account_id' not in params) or (params['account_id'] is None): 7670 raise ValueError("Missing the required parameter `account_id` when calling `update_favorite_template`") 7671 7672 7673 collection_formats = {} 7674 7675 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 7676 path_params = {} 7677 if 'account_id' in params: 7678 path_params['accountId'] = params['account_id'] 7679 7680 query_params = {} 7681 7682 header_params = {} 7683 7684 form_params = [] 7685 local_var_files = {} 7686 7687 body_params = None 7688 if 'favorite_templates_info' in params: 7689 body_params = params['favorite_templates_info'] 7690 # HTTP header `Accept` 7691 header_params['Accept'] = self.api_client.\ 7692 select_header_accept(['application/json']) 7693 7694 # Authentication setting 7695 auth_settings = [] 7696 7697 return self.api_client.call_api(resource_path, 'PUT', 7698 path_params, 7699 query_params, 7700 header_params, 7701 body=body_params, 7702 post_params=form_params, 7703 files=local_var_files, 7704 response_type='FavoriteTemplatesInfo', 7705 auth_settings=auth_settings, 7706 callback=params.get('callback'), 7707 _return_http_data_only=params.get('_return_http_data_only'), 7708 _preload_content=params.get('_preload_content', True), 7709 _request_timeout=params.get('_request_timeout'), 7710 collection_formats=collection_formats) 7711 7712 def update_notification_defaults(self, account_id, **kwargs): 7713 """ 7714 Updates default user level settings for a specified account 7715 This method changes the default settings for the email notifications that signers and senders receive about envelopes. 7716 This method makes a synchronous HTTP request by default. To make an 7717 asynchronous HTTP request, please define a `callback` function 7718 to be invoked when receiving the response. 7719 >>> def callback_function(response): 7720 >>> pprint(response) 7721 >>> 7722 >>> thread = api.update_notification_defaults(account_id, callback=callback_function) 7723 7724 :param callback function: The callback function 7725 for asynchronous request. (optional) 7726 :param str account_id: The external account number (int) or account ID Guid. (required) 7727 :param NotificationDefaults notification_defaults: 7728 :return: NotificationDefaults 7729 If the method is called asynchronously, 7730 returns the request thread. 7731 """ 7732 kwargs['_return_http_data_only'] = True 7733 if kwargs.get('callback'): 7734 return self.update_notification_defaults_with_http_info(account_id, **kwargs) 7735 else: 7736 (data) = self.update_notification_defaults_with_http_info(account_id, **kwargs) 7737 return data 7738 7739 def update_notification_defaults_with_http_info(self, account_id, **kwargs): 7740 """ 7741 Updates default user level settings for a specified account 7742 This method changes the default settings for the email notifications that signers and senders receive about envelopes. 7743 This method makes a synchronous HTTP request by default. To make an 7744 asynchronous HTTP request, please define a `callback` function 7745 to be invoked when receiving the response. 7746 >>> def callback_function(response): 7747 >>> pprint(response) 7748 >>> 7749 >>> thread = api.update_notification_defaults_with_http_info(account_id, callback=callback_function) 7750 7751 :param callback function: The callback function 7752 for asynchronous request. (optional) 7753 :param str account_id: The external account number (int) or account ID Guid. (required) 7754 :param NotificationDefaults notification_defaults: 7755 :return: NotificationDefaults 7756 If the method is called asynchronously, 7757 returns the request thread. 7758 """ 7759 7760 all_params = ['account_id', 'notification_defaults'] 7761 all_params.append('callback') 7762 all_params.append('_return_http_data_only') 7763 all_params.append('_preload_content') 7764 all_params.append('_request_timeout') 7765 7766 params = locals() 7767 for key, val in iteritems(params['kwargs']): 7768 if key not in all_params: 7769 raise TypeError( 7770 "Got an unexpected keyword argument '%s'" 7771 " to method update_notification_defaults" % key 7772 ) 7773 params[key] = val 7774 del params['kwargs'] 7775 # verify the required parameter 'account_id' is set 7776 if ('account_id' not in params) or (params['account_id'] is None): 7777 raise ValueError("Missing the required parameter `account_id` when calling `update_notification_defaults`") 7778 7779 7780 collection_formats = {} 7781 7782 resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json') 7783 path_params = {} 7784 if 'account_id' in params: 7785 path_params['accountId'] = params['account_id'] 7786 7787 query_params = {} 7788 7789 header_params = {} 7790 7791 form_params = [] 7792 local_var_files = {} 7793 7794 body_params = None 7795 if 'notification_defaults' in params: 7796 body_params = params['notification_defaults'] 7797 # HTTP header `Accept` 7798 header_params['Accept'] = self.api_client.\ 7799 select_header_accept(['application/json']) 7800 7801 # Authentication setting 7802 auth_settings = [] 7803 7804 return self.api_client.call_api(resource_path, 'PUT', 7805 path_params, 7806 query_params, 7807 header_params, 7808 body=body_params, 7809 post_params=form_params, 7810 files=local_var_files, 7811 response_type='NotificationDefaults', 7812 auth_settings=auth_settings, 7813 callback=params.get('callback'), 7814 _return_http_data_only=params.get('_return_http_data_only'), 7815 _preload_content=params.get('_preload_content', True), 7816 _request_timeout=params.get('_request_timeout'), 7817 collection_formats=collection_formats) 7818 7819 def update_password_rules(self, account_id, **kwargs): 7820 """ 7821 Update the password rules 7822 This method updates the password rules for an account. **Note:** To update the password rules for an account, you must be an account administrator. 7823 This method makes a synchronous HTTP request by default. To make an 7824 asynchronous HTTP request, please define a `callback` function 7825 to be invoked when receiving the response. 7826 >>> def callback_function(response): 7827 >>> pprint(response) 7828 >>> 7829 >>> thread = api.update_password_rules(account_id, callback=callback_function) 7830 7831 :param callback function: The callback function 7832 for asynchronous request. (optional) 7833 :param str account_id: The external account number (int) or account ID Guid. (required) 7834 :param AccountPasswordRules account_password_rules: 7835 :return: AccountPasswordRules 7836 If the method is called asynchronously, 7837 returns the request thread. 7838 """ 7839 kwargs['_return_http_data_only'] = True 7840 if kwargs.get('callback'): 7841 return self.update_password_rules_with_http_info(account_id, **kwargs) 7842 else: 7843 (data) = self.update_password_rules_with_http_info(account_id, **kwargs) 7844 return data 7845 7846 def update_password_rules_with_http_info(self, account_id, **kwargs): 7847 """ 7848 Update the password rules 7849 This method updates the password rules for an account. **Note:** To update the password rules for an account, you must be an account administrator. 7850 This method makes a synchronous HTTP request by default. To make an 7851 asynchronous HTTP request, please define a `callback` function 7852 to be invoked when receiving the response. 7853 >>> def callback_function(response): 7854 >>> pprint(response) 7855 >>> 7856 >>> thread = api.update_password_rules_with_http_info(account_id, callback=callback_function) 7857 7858 :param callback function: The callback function 7859 for asynchronous request. (optional) 7860 :param str account_id: The external account number (int) or account ID Guid. (required) 7861 :param AccountPasswordRules account_password_rules: 7862 :return: AccountPasswordRules 7863 If the method is called asynchronously, 7864 returns the request thread. 7865 """ 7866 7867 all_params = ['account_id', 'account_password_rules'] 7868 all_params.append('callback') 7869 all_params.append('_return_http_data_only') 7870 all_params.append('_preload_content') 7871 all_params.append('_request_timeout') 7872 7873 params = locals() 7874 for key, val in iteritems(params['kwargs']): 7875 if key not in all_params: 7876 raise TypeError( 7877 "Got an unexpected keyword argument '%s'" 7878 " to method update_password_rules" % key 7879 ) 7880 params[key] = val 7881 del params['kwargs'] 7882 # verify the required parameter 'account_id' is set 7883 if ('account_id' not in params) or (params['account_id'] is None): 7884 raise ValueError("Missing the required parameter `account_id` when calling `update_password_rules`") 7885 7886 7887 collection_formats = {} 7888 7889 resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json') 7890 path_params = {} 7891 if 'account_id' in params: 7892 path_params['accountId'] = params['account_id'] 7893 7894 query_params = {} 7895 7896 header_params = {} 7897 7898 form_params = [] 7899 local_var_files = {} 7900 7901 body_params = None 7902 if 'account_password_rules' in params: 7903 body_params = params['account_password_rules'] 7904 # HTTP header `Accept` 7905 header_params['Accept'] = self.api_client.\ 7906 select_header_accept(['application/json']) 7907 7908 # Authentication setting 7909 auth_settings = [] 7910 7911 return self.api_client.call_api(resource_path, 'PUT', 7912 path_params, 7913 query_params, 7914 header_params, 7915 body=body_params, 7916 post_params=form_params, 7917 files=local_var_files, 7918 response_type='AccountPasswordRules', 7919 auth_settings=auth_settings, 7920 callback=params.get('callback'), 7921 _return_http_data_only=params.get('_return_http_data_only'), 7922 _preload_content=params.get('_preload_content', True), 7923 _request_timeout=params.get('_request_timeout'), 7924 collection_formats=collection_formats) 7925 7926 def update_permission_profile(self, account_id, permission_profile_id, **kwargs): 7927 """ 7928 Updates a permission profile within the specified account. 7929 This method updates an account permission profile. ### Related topics - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 7930 This method makes a synchronous HTTP request by default. To make an 7931 asynchronous HTTP request, please define a `callback` function 7932 to be invoked when receiving the response. 7933 >>> def callback_function(response): 7934 >>> pprint(response) 7935 >>> 7936 >>> thread = api.update_permission_profile(account_id, permission_profile_id, callback=callback_function) 7937 7938 :param callback function: The callback function 7939 for asynchronous request. (optional) 7940 :param str account_id: The external account number (int) or account ID Guid. (required) 7941 :param str permission_profile_id: (required) 7942 :param str include: 7943 :param PermissionProfile permission_profile: 7944 :return: PermissionProfile 7945 If the method is called asynchronously, 7946 returns the request thread. 7947 """ 7948 kwargs['_return_http_data_only'] = True 7949 if kwargs.get('callback'): 7950 return self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 7951 else: 7952 (data) = self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 7953 return data 7954 7955 def update_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 7956 """ 7957 Updates a permission profile within the specified account. 7958 This method updates an account permission profile. ### Related topics - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 7959 This method makes a synchronous HTTP request by default. To make an 7960 asynchronous HTTP request, please define a `callback` function 7961 to be invoked when receiving the response. 7962 >>> def callback_function(response): 7963 >>> pprint(response) 7964 >>> 7965 >>> thread = api.update_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 7966 7967 :param callback function: The callback function 7968 for asynchronous request. (optional) 7969 :param str account_id: The external account number (int) or account ID Guid. (required) 7970 :param str permission_profile_id: (required) 7971 :param str include: 7972 :param PermissionProfile permission_profile: 7973 :return: PermissionProfile 7974 If the method is called asynchronously, 7975 returns the request thread. 7976 """ 7977 7978 all_params = ['account_id', 'permission_profile_id', 'include', 'permission_profile'] 7979 all_params.append('callback') 7980 all_params.append('_return_http_data_only') 7981 all_params.append('_preload_content') 7982 all_params.append('_request_timeout') 7983 7984 params = locals() 7985 for key, val in iteritems(params['kwargs']): 7986 if key not in all_params: 7987 raise TypeError( 7988 "Got an unexpected keyword argument '%s'" 7989 " to method update_permission_profile" % key 7990 ) 7991 params[key] = val 7992 del params['kwargs'] 7993 # verify the required parameter 'account_id' is set 7994 if ('account_id' not in params) or (params['account_id'] is None): 7995 raise ValueError("Missing the required parameter `account_id` when calling `update_permission_profile`") 7996 # verify the required parameter 'permission_profile_id' is set 7997 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 7998 raise ValueError("Missing the required parameter `permission_profile_id` when calling `update_permission_profile`") 7999 8000 8001 collection_formats = {} 8002 8003 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 8004 path_params = {} 8005 if 'account_id' in params: 8006 path_params['accountId'] = params['account_id'] 8007 if 'permission_profile_id' in params: 8008 path_params['permissionProfileId'] = params['permission_profile_id'] 8009 8010 query_params = {} 8011 if 'include' in params: 8012 query_params['include'] = params['include'] 8013 8014 header_params = {} 8015 8016 form_params = [] 8017 local_var_files = {} 8018 8019 body_params = None 8020 if 'permission_profile' in params: 8021 body_params = params['permission_profile'] 8022 # HTTP header `Accept` 8023 header_params['Accept'] = self.api_client.\ 8024 select_header_accept(['application/json']) 8025 8026 # Authentication setting 8027 auth_settings = [] 8028 8029 return self.api_client.call_api(resource_path, 'PUT', 8030 path_params, 8031 query_params, 8032 header_params, 8033 body=body_params, 8034 post_params=form_params, 8035 files=local_var_files, 8036 response_type='PermissionProfile', 8037 auth_settings=auth_settings, 8038 callback=params.get('callback'), 8039 _return_http_data_only=params.get('_return_http_data_only'), 8040 _preload_content=params.get('_preload_content', True), 8041 _request_timeout=params.get('_request_timeout'), 8042 collection_formats=collection_formats) 8043 8044 def update_settings(self, account_id, **kwargs): 8045 """ 8046 Updates the account settings for an account. 8047 Updates the account settings for the specified account. 8048 This method makes a synchronous HTTP request by default. To make an 8049 asynchronous HTTP request, please define a `callback` function 8050 to be invoked when receiving the response. 8051 >>> def callback_function(response): 8052 >>> pprint(response) 8053 >>> 8054 >>> thread = api.update_settings(account_id, callback=callback_function) 8055 8056 :param callback function: The callback function 8057 for asynchronous request. (optional) 8058 :param str account_id: The external account number (int) or account ID Guid. (required) 8059 :param AccountSettingsInformation account_settings_information: 8060 :return: None 8061 If the method is called asynchronously, 8062 returns the request thread. 8063 """ 8064 kwargs['_return_http_data_only'] = True 8065 if kwargs.get('callback'): 8066 return self.update_settings_with_http_info(account_id, **kwargs) 8067 else: 8068 (data) = self.update_settings_with_http_info(account_id, **kwargs) 8069 return data 8070 8071 def update_settings_with_http_info(self, account_id, **kwargs): 8072 """ 8073 Updates the account settings for an account. 8074 Updates the account settings for the specified account. 8075 This method makes a synchronous HTTP request by default. To make an 8076 asynchronous HTTP request, please define a `callback` function 8077 to be invoked when receiving the response. 8078 >>> def callback_function(response): 8079 >>> pprint(response) 8080 >>> 8081 >>> thread = api.update_settings_with_http_info(account_id, callback=callback_function) 8082 8083 :param callback function: The callback function 8084 for asynchronous request. (optional) 8085 :param str account_id: The external account number (int) or account ID Guid. (required) 8086 :param AccountSettingsInformation account_settings_information: 8087 :return: None 8088 If the method is called asynchronously, 8089 returns the request thread. 8090 """ 8091 8092 all_params = ['account_id', 'account_settings_information'] 8093 all_params.append('callback') 8094 all_params.append('_return_http_data_only') 8095 all_params.append('_preload_content') 8096 all_params.append('_request_timeout') 8097 8098 params = locals() 8099 for key, val in iteritems(params['kwargs']): 8100 if key not in all_params: 8101 raise TypeError( 8102 "Got an unexpected keyword argument '%s'" 8103 " to method update_settings" % key 8104 ) 8105 params[key] = val 8106 del params['kwargs'] 8107 # verify the required parameter 'account_id' is set 8108 if ('account_id' not in params) or (params['account_id'] is None): 8109 raise ValueError("Missing the required parameter `account_id` when calling `update_settings`") 8110 8111 8112 collection_formats = {} 8113 8114 resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json') 8115 path_params = {} 8116 if 'account_id' in params: 8117 path_params['accountId'] = params['account_id'] 8118 8119 query_params = {} 8120 8121 header_params = {} 8122 8123 form_params = [] 8124 local_var_files = {} 8125 8126 body_params = None 8127 if 'account_settings_information' in params: 8128 body_params = params['account_settings_information'] 8129 # HTTP header `Accept` 8130 header_params['Accept'] = self.api_client.\ 8131 select_header_accept(['application/json']) 8132 8133 # Authentication setting 8134 auth_settings = [] 8135 8136 return self.api_client.call_api(resource_path, 'PUT', 8137 path_params, 8138 query_params, 8139 header_params, 8140 body=body_params, 8141 post_params=form_params, 8142 files=local_var_files, 8143 response_type=None, 8144 auth_settings=auth_settings, 8145 callback=params.get('callback'), 8146 _return_http_data_only=params.get('_return_http_data_only'), 8147 _preload_content=params.get('_preload_content', True), 8148 _request_timeout=params.get('_request_timeout'), 8149 collection_formats=collection_formats) 8150 8151 def update_shared_access(self, account_id, **kwargs): 8152 """ 8153 Reserved: Sets the shared access information for users. 8154 Reserved: Sets the shared access information for one or more users. 8155 This method makes a synchronous HTTP request by default. To make an 8156 asynchronous HTTP request, please define a `callback` function 8157 to be invoked when receiving the response. 8158 >>> def callback_function(response): 8159 >>> pprint(response) 8160 >>> 8161 >>> thread = api.update_shared_access(account_id, callback=callback_function) 8162 8163 :param callback function: The callback function 8164 for asynchronous request. (optional) 8165 :param str account_id: The external account number (int) or account ID Guid. (required) 8166 :param str item_type: 8167 :param str preserve_existing_shared_access: 8168 :param str user_ids: 8169 :param AccountSharedAccess account_shared_access: 8170 :return: AccountSharedAccess 8171 If the method is called asynchronously, 8172 returns the request thread. 8173 """ 8174 kwargs['_return_http_data_only'] = True 8175 if kwargs.get('callback'): 8176 return self.update_shared_access_with_http_info(account_id, **kwargs) 8177 else: 8178 (data) = self.update_shared_access_with_http_info(account_id, **kwargs) 8179 return data 8180 8181 def update_shared_access_with_http_info(self, account_id, **kwargs): 8182 """ 8183 Reserved: Sets the shared access information for users. 8184 Reserved: Sets the shared access information for one or more users. 8185 This method makes a synchronous HTTP request by default. To make an 8186 asynchronous HTTP request, please define a `callback` function 8187 to be invoked when receiving the response. 8188 >>> def callback_function(response): 8189 >>> pprint(response) 8190 >>> 8191 >>> thread = api.update_shared_access_with_http_info(account_id, callback=callback_function) 8192 8193 :param callback function: The callback function 8194 for asynchronous request. (optional) 8195 :param str account_id: The external account number (int) or account ID Guid. (required) 8196 :param str item_type: 8197 :param str preserve_existing_shared_access: 8198 :param str user_ids: 8199 :param AccountSharedAccess account_shared_access: 8200 :return: AccountSharedAccess 8201 If the method is called asynchronously, 8202 returns the request thread. 8203 """ 8204 8205 all_params = ['account_id', 'item_type', 'preserve_existing_shared_access', 'user_ids', 'account_shared_access'] 8206 all_params.append('callback') 8207 all_params.append('_return_http_data_only') 8208 all_params.append('_preload_content') 8209 all_params.append('_request_timeout') 8210 8211 params = locals() 8212 for key, val in iteritems(params['kwargs']): 8213 if key not in all_params: 8214 raise TypeError( 8215 "Got an unexpected keyword argument '%s'" 8216 " to method update_shared_access" % key 8217 ) 8218 params[key] = val 8219 del params['kwargs'] 8220 # verify the required parameter 'account_id' is set 8221 if ('account_id' not in params) or (params['account_id'] is None): 8222 raise ValueError("Missing the required parameter `account_id` when calling `update_shared_access`") 8223 8224 8225 collection_formats = {} 8226 8227 resource_path = '/v2.1/accounts/{accountId}/shared_access'.replace('{format}', 'json') 8228 path_params = {} 8229 if 'account_id' in params: 8230 path_params['accountId'] = params['account_id'] 8231 8232 query_params = {} 8233 if 'item_type' in params: 8234 query_params['item_type'] = params['item_type'] 8235 if 'preserve_existing_shared_access' in params: 8236 query_params['preserve_existing_shared_access'] = params['preserve_existing_shared_access'] 8237 if 'user_ids' in params: 8238 query_params['user_ids'] = params['user_ids'] 8239 8240 header_params = {} 8241 8242 form_params = [] 8243 local_var_files = {} 8244 8245 body_params = None 8246 if 'account_shared_access' in params: 8247 body_params = params['account_shared_access'] 8248 # HTTP header `Accept` 8249 header_params['Accept'] = self.api_client.\ 8250 select_header_accept(['application/json']) 8251 8252 # Authentication setting 8253 auth_settings = [] 8254 8255 return self.api_client.call_api(resource_path, 'PUT', 8256 path_params, 8257 query_params, 8258 header_params, 8259 body=body_params, 8260 post_params=form_params, 8261 files=local_var_files, 8262 response_type='AccountSharedAccess', 8263 auth_settings=auth_settings, 8264 callback=params.get('callback'), 8265 _return_http_data_only=params.get('_return_http_data_only'), 8266 _preload_content=params.get('_preload_content', True), 8267 _request_timeout=params.get('_request_timeout'), 8268 collection_formats=collection_formats) 8269 8270 def update_user_authorization(self, account_id, authorization_id, user_id, **kwargs): 8271 """ 8272 Updates the user authorization 8273 This method makes a synchronous HTTP request by default. To make an 8274 asynchronous HTTP request, please define a `callback` function 8275 to be invoked when receiving the response. 8276 >>> def callback_function(response): 8277 >>> pprint(response) 8278 >>> 8279 >>> thread = api.update_user_authorization(account_id, authorization_id, user_id, callback=callback_function) 8280 8281 :param callback function: The callback function 8282 for asynchronous request. (optional) 8283 :param str account_id: The external account number (int) or account ID Guid. (required) 8284 :param str authorization_id: (required) 8285 :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) 8286 :param UserAuthorizationUpdateRequest user_authorization_update_request: 8287 :return: UserAuthorization 8288 If the method is called asynchronously, 8289 returns the request thread. 8290 """ 8291 kwargs['_return_http_data_only'] = True 8292 if kwargs.get('callback'): 8293 return self.update_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 8294 else: 8295 (data) = self.update_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 8296 return data 8297 8298 def update_user_authorization_with_http_info(self, account_id, authorization_id, user_id, **kwargs): 8299 """ 8300 Updates the user authorization 8301 This method makes a synchronous HTTP request by default. To make an 8302 asynchronous HTTP request, please define a `callback` function 8303 to be invoked when receiving the response. 8304 >>> def callback_function(response): 8305 >>> pprint(response) 8306 >>> 8307 >>> thread = api.update_user_authorization_with_http_info(account_id, authorization_id, user_id, callback=callback_function) 8308 8309 :param callback function: The callback function 8310 for asynchronous request. (optional) 8311 :param str account_id: The external account number (int) or account ID Guid. (required) 8312 :param str authorization_id: (required) 8313 :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) 8314 :param UserAuthorizationUpdateRequest user_authorization_update_request: 8315 :return: UserAuthorization 8316 If the method is called asynchronously, 8317 returns the request thread. 8318 """ 8319 8320 all_params = ['account_id', 'authorization_id', 'user_id', 'user_authorization_update_request'] 8321 all_params.append('callback') 8322 all_params.append('_return_http_data_only') 8323 all_params.append('_preload_content') 8324 all_params.append('_request_timeout') 8325 8326 params = locals() 8327 for key, val in iteritems(params['kwargs']): 8328 if key not in all_params: 8329 raise TypeError( 8330 "Got an unexpected keyword argument '%s'" 8331 " to method update_user_authorization" % key 8332 ) 8333 params[key] = val 8334 del params['kwargs'] 8335 # verify the required parameter 'account_id' is set 8336 if ('account_id' not in params) or (params['account_id'] is None): 8337 raise ValueError("Missing the required parameter `account_id` when calling `update_user_authorization`") 8338 # verify the required parameter 'authorization_id' is set 8339 if ('authorization_id' not in params) or (params['authorization_id'] is None): 8340 raise ValueError("Missing the required parameter `authorization_id` when calling `update_user_authorization`") 8341 # verify the required parameter 'user_id' is set 8342 if ('user_id' not in params) or (params['user_id'] is None): 8343 raise ValueError("Missing the required parameter `user_id` when calling `update_user_authorization`") 8344 8345 8346 collection_formats = {} 8347 8348 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorization/{authorizationId}'.replace('{format}', 'json') 8349 path_params = {} 8350 if 'account_id' in params: 8351 path_params['accountId'] = params['account_id'] 8352 if 'authorization_id' in params: 8353 path_params['authorizationId'] = params['authorization_id'] 8354 if 'user_id' in params: 8355 path_params['userId'] = params['user_id'] 8356 8357 query_params = {} 8358 8359 header_params = {} 8360 8361 form_params = [] 8362 local_var_files = {} 8363 8364 body_params = None 8365 if 'user_authorization_update_request' in params: 8366 body_params = params['user_authorization_update_request'] 8367 # HTTP header `Accept` 8368 header_params['Accept'] = self.api_client.\ 8369 select_header_accept(['application/json']) 8370 8371 # Authentication setting 8372 auth_settings = [] 8373 8374 return self.api_client.call_api(resource_path, 'PUT', 8375 path_params, 8376 query_params, 8377 header_params, 8378 body=body_params, 8379 post_params=form_params, 8380 files=local_var_files, 8381 response_type='UserAuthorization', 8382 auth_settings=auth_settings, 8383 callback=params.get('callback'), 8384 _return_http_data_only=params.get('_return_http_data_only'), 8385 _preload_content=params.get('_preload_content', True), 8386 _request_timeout=params.get('_request_timeout'), 8387 collection_formats=collection_formats) 8388 8389 def update_watermark(self, account_id, **kwargs): 8390 """ 8391 Update watermark information. 8392 8393 This method makes a synchronous HTTP request by default. To make an 8394 asynchronous HTTP request, please define a `callback` function 8395 to be invoked when receiving the response. 8396 >>> def callback_function(response): 8397 >>> pprint(response) 8398 >>> 8399 >>> thread = api.update_watermark(account_id, callback=callback_function) 8400 8401 :param callback function: The callback function 8402 for asynchronous request. (optional) 8403 :param str account_id: The external account number (int) or account ID Guid. (required) 8404 :param Watermark watermark: 8405 :return: Watermark 8406 If the method is called asynchronously, 8407 returns the request thread. 8408 """ 8409 kwargs['_return_http_data_only'] = True 8410 if kwargs.get('callback'): 8411 return self.update_watermark_with_http_info(account_id, **kwargs) 8412 else: 8413 (data) = self.update_watermark_with_http_info(account_id, **kwargs) 8414 return data 8415 8416 def update_watermark_with_http_info(self, account_id, **kwargs): 8417 """ 8418 Update watermark information. 8419 8420 This method makes a synchronous HTTP request by default. To make an 8421 asynchronous HTTP request, please define a `callback` function 8422 to be invoked when receiving the response. 8423 >>> def callback_function(response): 8424 >>> pprint(response) 8425 >>> 8426 >>> thread = api.update_watermark_with_http_info(account_id, callback=callback_function) 8427 8428 :param callback function: The callback function 8429 for asynchronous request. (optional) 8430 :param str account_id: The external account number (int) or account ID Guid. (required) 8431 :param Watermark watermark: 8432 :return: Watermark 8433 If the method is called asynchronously, 8434 returns the request thread. 8435 """ 8436 8437 all_params = ['account_id', 'watermark'] 8438 all_params.append('callback') 8439 all_params.append('_return_http_data_only') 8440 all_params.append('_preload_content') 8441 all_params.append('_request_timeout') 8442 8443 params = locals() 8444 for key, val in iteritems(params['kwargs']): 8445 if key not in all_params: 8446 raise TypeError( 8447 "Got an unexpected keyword argument '%s'" 8448 " to method update_watermark" % key 8449 ) 8450 params[key] = val 8451 del params['kwargs'] 8452 # verify the required parameter 'account_id' is set 8453 if ('account_id' not in params) or (params['account_id'] is None): 8454 raise ValueError("Missing the required parameter `account_id` when calling `update_watermark`") 8455 8456 8457 collection_formats = {} 8458 8459 resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json') 8460 path_params = {} 8461 if 'account_id' in params: 8462 path_params['accountId'] = params['account_id'] 8463 8464 query_params = {} 8465 8466 header_params = {} 8467 8468 form_params = [] 8469 local_var_files = {} 8470 8471 body_params = None 8472 if 'watermark' in params: 8473 body_params = params['watermark'] 8474 # HTTP header `Accept` 8475 header_params['Accept'] = self.api_client.\ 8476 select_header_accept(['application/json']) 8477 8478 # Authentication setting 8479 auth_settings = [] 8480 8481 return self.api_client.call_api(resource_path, 'PUT', 8482 path_params, 8483 query_params, 8484 header_params, 8485 body=body_params, 8486 post_params=form_params, 8487 files=local_var_files, 8488 response_type='Watermark', 8489 auth_settings=auth_settings, 8490 callback=params.get('callback'), 8491 _return_http_data_only=params.get('_return_http_data_only'), 8492 _preload_content=params.get('_preload_content', True), 8493 _request_timeout=params.get('_request_timeout'), 8494 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 :param str include_trial_eligibility: 2276 :return: AccountInformation 2277 If the method is called asynchronously, 2278 returns the request thread. 2279 """ 2280 kwargs['_return_http_data_only'] = True 2281 if kwargs.get('callback'): 2282 return self.get_account_information_with_http_info(account_id, **kwargs) 2283 else: 2284 (data) = self.get_account_information_with_http_info(account_id, **kwargs) 2285 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.
- str include_trial_eligibility:
Returns
AccountInformation If the method is called asynchronously, returns the request thread.
def
get_account_information_with_http_info(self, account_id, **kwargs)
2287 def get_account_information_with_http_info(self, account_id, **kwargs): 2288 """ 2289 Retrieves the account information for the specified account. 2290 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. 2291 This method makes a synchronous HTTP request by default. To make an 2292 asynchronous HTTP request, please define a `callback` function 2293 to be invoked when receiving the response. 2294 >>> def callback_function(response): 2295 >>> pprint(response) 2296 >>> 2297 >>> thread = api.get_account_information_with_http_info(account_id, callback=callback_function) 2298 2299 :param callback function: The callback function 2300 for asynchronous request. (optional) 2301 :param str account_id: The external account number (int) or account ID Guid. (required) 2302 :param str include_account_settings: When set to **true**, includes the account settings for the account in the response. 2303 :param str include_trial_eligibility: 2304 :return: AccountInformation 2305 If the method is called asynchronously, 2306 returns the request thread. 2307 """ 2308 2309 all_params = ['account_id', 'include_account_settings', 'include_trial_eligibility'] 2310 all_params.append('callback') 2311 all_params.append('_return_http_data_only') 2312 all_params.append('_preload_content') 2313 all_params.append('_request_timeout') 2314 2315 params = locals() 2316 for key, val in iteritems(params['kwargs']): 2317 if key not in all_params: 2318 raise TypeError( 2319 "Got an unexpected keyword argument '%s'" 2320 " to method get_account_information" % key 2321 ) 2322 params[key] = val 2323 del params['kwargs'] 2324 # verify the required parameter 'account_id' is set 2325 if ('account_id' not in params) or (params['account_id'] is None): 2326 raise ValueError("Missing the required parameter `account_id` when calling `get_account_information`") 2327 2328 2329 collection_formats = {} 2330 2331 resource_path = '/v2.1/accounts/{accountId}'.replace('{format}', 'json') 2332 path_params = {} 2333 if 'account_id' in params: 2334 path_params['accountId'] = params['account_id'] 2335 2336 query_params = {} 2337 if 'include_account_settings' in params: 2338 query_params['include_account_settings'] = params['include_account_settings'] 2339 if 'include_trial_eligibility' in params: 2340 query_params['include_trial_eligibility'] = params['include_trial_eligibility'] 2341 2342 header_params = {} 2343 2344 form_params = [] 2345 local_var_files = {} 2346 2347 body_params = None 2348 # HTTP header `Accept` 2349 header_params['Accept'] = self.api_client.\ 2350 select_header_accept(['application/json']) 2351 2352 # Authentication setting 2353 auth_settings = [] 2354 2355 return self.api_client.call_api(resource_path, 'GET', 2356 path_params, 2357 query_params, 2358 header_params, 2359 body=body_params, 2360 post_params=form_params, 2361 files=local_var_files, 2362 response_type='AccountInformation', 2363 auth_settings=auth_settings, 2364 callback=params.get('callback'), 2365 _return_http_data_only=params.get('_return_http_data_only'), 2366 _preload_content=params.get('_preload_content', True), 2367 _request_timeout=params.get('_request_timeout'), 2368 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.
- str include_trial_eligibility:
Returns
AccountInformation If the method is called asynchronously, returns the request thread.
def
get_account_signature(self, account_id, signature_id, **kwargs)
2370 def get_account_signature(self, account_id, signature_id, **kwargs): 2371 """ 2372 Returns information about a single signature by specifed signatureId. 2373 2374 This method makes a synchronous HTTP request by default. To make an 2375 asynchronous HTTP request, please define a `callback` function 2376 to be invoked when receiving the response. 2377 >>> def callback_function(response): 2378 >>> pprint(response) 2379 >>> 2380 >>> thread = api.get_account_signature(account_id, signature_id, callback=callback_function) 2381 2382 :param callback function: The callback function 2383 for asynchronous request. (optional) 2384 :param str account_id: The external account number (int) or account ID Guid. (required) 2385 :param str signature_id: The ID of the signature being accessed. (required) 2386 :return: AccountSignature 2387 If the method is called asynchronously, 2388 returns the request thread. 2389 """ 2390 kwargs['_return_http_data_only'] = True 2391 if kwargs.get('callback'): 2392 return self.get_account_signature_with_http_info(account_id, signature_id, **kwargs) 2393 else: 2394 (data) = self.get_account_signature_with_http_info(account_id, signature_id, **kwargs) 2395 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)
2397 def get_account_signature_with_http_info(self, account_id, signature_id, **kwargs): 2398 """ 2399 Returns information about a single signature by specifed signatureId. 2400 2401 This method makes a synchronous HTTP request by default. To make an 2402 asynchronous HTTP request, please define a `callback` function 2403 to be invoked when receiving the response. 2404 >>> def callback_function(response): 2405 >>> pprint(response) 2406 >>> 2407 >>> thread = api.get_account_signature_with_http_info(account_id, signature_id, callback=callback_function) 2408 2409 :param callback function: The callback function 2410 for asynchronous request. (optional) 2411 :param str account_id: The external account number (int) or account ID Guid. (required) 2412 :param str signature_id: The ID of the signature being accessed. (required) 2413 :return: AccountSignature 2414 If the method is called asynchronously, 2415 returns the request thread. 2416 """ 2417 2418 all_params = ['account_id', 'signature_id'] 2419 all_params.append('callback') 2420 all_params.append('_return_http_data_only') 2421 all_params.append('_preload_content') 2422 all_params.append('_request_timeout') 2423 2424 params = locals() 2425 for key, val in iteritems(params['kwargs']): 2426 if key not in all_params: 2427 raise TypeError( 2428 "Got an unexpected keyword argument '%s'" 2429 " to method get_account_signature" % key 2430 ) 2431 params[key] = val 2432 del params['kwargs'] 2433 # verify the required parameter 'account_id' is set 2434 if ('account_id' not in params) or (params['account_id'] is None): 2435 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signature`") 2436 # verify the required parameter 'signature_id' is set 2437 if ('signature_id' not in params) or (params['signature_id'] is None): 2438 raise ValueError("Missing the required parameter `signature_id` when calling `get_account_signature`") 2439 2440 2441 collection_formats = {} 2442 2443 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 2444 path_params = {} 2445 if 'account_id' in params: 2446 path_params['accountId'] = params['account_id'] 2447 if 'signature_id' in params: 2448 path_params['signatureId'] = params['signature_id'] 2449 2450 query_params = {} 2451 2452 header_params = {} 2453 2454 form_params = [] 2455 local_var_files = {} 2456 2457 body_params = None 2458 # HTTP header `Accept` 2459 header_params['Accept'] = self.api_client.\ 2460 select_header_accept(['application/json']) 2461 2462 # Authentication setting 2463 auth_settings = [] 2464 2465 return self.api_client.call_api(resource_path, 'GET', 2466 path_params, 2467 query_params, 2468 header_params, 2469 body=body_params, 2470 post_params=form_params, 2471 files=local_var_files, 2472 response_type='AccountSignature', 2473 auth_settings=auth_settings, 2474 callback=params.get('callback'), 2475 _return_http_data_only=params.get('_return_http_data_only'), 2476 _preload_content=params.get('_preload_content', True), 2477 _request_timeout=params.get('_request_timeout'), 2478 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)
2480 def get_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 2481 """ 2482 Returns a signature, initials, or stamps image. 2483 2484 This method makes a synchronous HTTP request by default. To make an 2485 asynchronous HTTP request, please define a `callback` function 2486 to be invoked when receiving the response. 2487 >>> def callback_function(response): 2488 >>> pprint(response) 2489 >>> 2490 >>> thread = api.get_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 2491 2492 :param callback function: The callback function 2493 for asynchronous request. (optional) 2494 :param str account_id: The external account number (int) or account ID Guid. (required) 2495 :param str image_type: One of **signature_image** or **initials_image**. (required) 2496 :param str signature_id: The ID of the signature being accessed. (required) 2497 :param str include_chrome: 2498 :return: file 2499 If the method is called asynchronously, 2500 returns the request thread. 2501 """ 2502 kwargs['_return_http_data_only'] = True 2503 if kwargs.get('callback'): 2504 return self.get_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 2505 else: 2506 (data) = self.get_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 2507 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)
2509 def get_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 2510 """ 2511 Returns a signature, initials, or stamps image. 2512 2513 This method makes a synchronous HTTP request by default. To make an 2514 asynchronous HTTP request, please define a `callback` function 2515 to be invoked when receiving the response. 2516 >>> def callback_function(response): 2517 >>> pprint(response) 2518 >>> 2519 >>> thread = api.get_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 2520 2521 :param callback function: The callback function 2522 for asynchronous request. (optional) 2523 :param str account_id: The external account number (int) or account ID Guid. (required) 2524 :param str image_type: One of **signature_image** or **initials_image**. (required) 2525 :param str signature_id: The ID of the signature being accessed. (required) 2526 :param str include_chrome: 2527 :return: file 2528 If the method is called asynchronously, 2529 returns the request thread. 2530 """ 2531 2532 all_params = ['account_id', 'image_type', 'signature_id', 'include_chrome'] 2533 all_params.append('callback') 2534 all_params.append('_return_http_data_only') 2535 all_params.append('_preload_content') 2536 all_params.append('_request_timeout') 2537 2538 params = locals() 2539 for key, val in iteritems(params['kwargs']): 2540 if key not in all_params: 2541 raise TypeError( 2542 "Got an unexpected keyword argument '%s'" 2543 " to method get_account_signature_image" % key 2544 ) 2545 params[key] = val 2546 del params['kwargs'] 2547 # verify the required parameter 'account_id' is set 2548 if ('account_id' not in params) or (params['account_id'] is None): 2549 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signature_image`") 2550 # verify the required parameter 'image_type' is set 2551 if ('image_type' not in params) or (params['image_type'] is None): 2552 raise ValueError("Missing the required parameter `image_type` when calling `get_account_signature_image`") 2553 # verify the required parameter 'signature_id' is set 2554 if ('signature_id' not in params) or (params['signature_id'] is None): 2555 raise ValueError("Missing the required parameter `signature_id` when calling `get_account_signature_image`") 2556 2557 2558 collection_formats = {} 2559 2560 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 2561 path_params = {} 2562 if 'account_id' in params: 2563 path_params['accountId'] = params['account_id'] 2564 if 'image_type' in params: 2565 path_params['imageType'] = params['image_type'] 2566 if 'signature_id' in params: 2567 path_params['signatureId'] = params['signature_id'] 2568 2569 query_params = {} 2570 if 'include_chrome' in params: 2571 query_params['include_chrome'] = params['include_chrome'] 2572 2573 header_params = {} 2574 2575 form_params = [] 2576 local_var_files = {} 2577 2578 body_params = None 2579 # HTTP header `Accept` 2580 header_params['Accept'] = self.api_client.\ 2581 select_header_accept(['image/gif']) 2582 2583 # Authentication setting 2584 auth_settings = [] 2585 2586 return self.api_client.call_api(resource_path, 'GET', 2587 path_params, 2588 query_params, 2589 header_params, 2590 body=body_params, 2591 post_params=form_params, 2592 files=local_var_files, 2593 response_type='file', 2594 auth_settings=auth_settings, 2595 callback=params.get('callback'), 2596 _return_http_data_only=params.get('_return_http_data_only'), 2597 _preload_content=params.get('_preload_content', True), 2598 _request_timeout=params.get('_request_timeout'), 2599 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)
2601 def get_account_signatures(self, account_id, **kwargs): 2602 """ 2603 Returns the managed signature definitions for the account 2604 2605 This method makes a synchronous HTTP request by default. To make an 2606 asynchronous HTTP request, please define a `callback` function 2607 to be invoked when receiving the response. 2608 >>> def callback_function(response): 2609 >>> pprint(response) 2610 >>> 2611 >>> thread = api.get_account_signatures(account_id, callback=callback_function) 2612 2613 :param callback function: The callback function 2614 for asynchronous request. (optional) 2615 :param str account_id: The external account number (int) or account ID Guid. (required) 2616 :param str stamp_format: 2617 :param str stamp_name: 2618 :param str stamp_type: 2619 :return: AccountSignaturesInformation 2620 If the method is called asynchronously, 2621 returns the request thread. 2622 """ 2623 kwargs['_return_http_data_only'] = True 2624 if kwargs.get('callback'): 2625 return self.get_account_signatures_with_http_info(account_id, **kwargs) 2626 else: 2627 (data) = self.get_account_signatures_with_http_info(account_id, **kwargs) 2628 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)
2630 def get_account_signatures_with_http_info(self, account_id, **kwargs): 2631 """ 2632 Returns the managed signature definitions for the account 2633 2634 This method makes a synchronous HTTP request by default. To make an 2635 asynchronous HTTP request, please define a `callback` function 2636 to be invoked when receiving the response. 2637 >>> def callback_function(response): 2638 >>> pprint(response) 2639 >>> 2640 >>> thread = api.get_account_signatures_with_http_info(account_id, callback=callback_function) 2641 2642 :param callback function: The callback function 2643 for asynchronous request. (optional) 2644 :param str account_id: The external account number (int) or account ID Guid. (required) 2645 :param str stamp_format: 2646 :param str stamp_name: 2647 :param str stamp_type: 2648 :return: AccountSignaturesInformation 2649 If the method is called asynchronously, 2650 returns the request thread. 2651 """ 2652 2653 all_params = ['account_id', 'stamp_format', 'stamp_name', 'stamp_type'] 2654 all_params.append('callback') 2655 all_params.append('_return_http_data_only') 2656 all_params.append('_preload_content') 2657 all_params.append('_request_timeout') 2658 2659 params = locals() 2660 for key, val in iteritems(params['kwargs']): 2661 if key not in all_params: 2662 raise TypeError( 2663 "Got an unexpected keyword argument '%s'" 2664 " to method get_account_signatures" % key 2665 ) 2666 params[key] = val 2667 del params['kwargs'] 2668 # verify the required parameter 'account_id' is set 2669 if ('account_id' not in params) or (params['account_id'] is None): 2670 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signatures`") 2671 2672 2673 collection_formats = {} 2674 2675 resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json') 2676 path_params = {} 2677 if 'account_id' in params: 2678 path_params['accountId'] = params['account_id'] 2679 2680 query_params = {} 2681 if 'stamp_format' in params: 2682 query_params['stamp_format'] = params['stamp_format'] 2683 if 'stamp_name' in params: 2684 query_params['stamp_name'] = params['stamp_name'] 2685 if 'stamp_type' in params: 2686 query_params['stamp_type'] = params['stamp_type'] 2687 2688 header_params = {} 2689 2690 form_params = [] 2691 local_var_files = {} 2692 2693 body_params = None 2694 # HTTP header `Accept` 2695 header_params['Accept'] = self.api_client.\ 2696 select_header_accept(['application/json']) 2697 2698 # Authentication setting 2699 auth_settings = [] 2700 2701 return self.api_client.call_api(resource_path, 'GET', 2702 path_params, 2703 query_params, 2704 header_params, 2705 body=body_params, 2706 post_params=form_params, 2707 files=local_var_files, 2708 response_type='AccountSignaturesInformation', 2709 auth_settings=auth_settings, 2710 callback=params.get('callback'), 2711 _return_http_data_only=params.get('_return_http_data_only'), 2712 _preload_content=params.get('_preload_content', True), 2713 _request_timeout=params.get('_request_timeout'), 2714 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)
2716 def get_account_tab_settings(self, account_id, **kwargs): 2717 """ 2718 Returns tab settings list for specified account 2719 This method returns information about the tab types and tab functionality that is currently enabled for an account. 2720 This method makes a synchronous HTTP request by default. To make an 2721 asynchronous HTTP request, please define a `callback` function 2722 to be invoked when receiving the response. 2723 >>> def callback_function(response): 2724 >>> pprint(response) 2725 >>> 2726 >>> thread = api.get_account_tab_settings(account_id, callback=callback_function) 2727 2728 :param callback function: The callback function 2729 for asynchronous request. (optional) 2730 :param str account_id: The external account number (int) or account ID Guid. (required) 2731 :return: TabAccountSettings 2732 If the method is called asynchronously, 2733 returns the request thread. 2734 """ 2735 kwargs['_return_http_data_only'] = True 2736 if kwargs.get('callback'): 2737 return self.get_account_tab_settings_with_http_info(account_id, **kwargs) 2738 else: 2739 (data) = self.get_account_tab_settings_with_http_info(account_id, **kwargs) 2740 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)
2742 def get_account_tab_settings_with_http_info(self, account_id, **kwargs): 2743 """ 2744 Returns tab settings list for specified account 2745 This method returns information about the tab types and tab functionality that is currently enabled for an account. 2746 This method makes a synchronous HTTP request by default. To make an 2747 asynchronous HTTP request, please define a `callback` function 2748 to be invoked when receiving the response. 2749 >>> def callback_function(response): 2750 >>> pprint(response) 2751 >>> 2752 >>> thread = api.get_account_tab_settings_with_http_info(account_id, callback=callback_function) 2753 2754 :param callback function: The callback function 2755 for asynchronous request. (optional) 2756 :param str account_id: The external account number (int) or account ID Guid. (required) 2757 :return: TabAccountSettings 2758 If the method is called asynchronously, 2759 returns the request thread. 2760 """ 2761 2762 all_params = ['account_id'] 2763 all_params.append('callback') 2764 all_params.append('_return_http_data_only') 2765 all_params.append('_preload_content') 2766 all_params.append('_request_timeout') 2767 2768 params = locals() 2769 for key, val in iteritems(params['kwargs']): 2770 if key not in all_params: 2771 raise TypeError( 2772 "Got an unexpected keyword argument '%s'" 2773 " to method get_account_tab_settings" % key 2774 ) 2775 params[key] = val 2776 del params['kwargs'] 2777 # verify the required parameter 'account_id' is set 2778 if ('account_id' not in params) or (params['account_id'] is None): 2779 raise ValueError("Missing the required parameter `account_id` when calling `get_account_tab_settings`") 2780 2781 2782 collection_formats = {} 2783 2784 resource_path = '/v2.1/accounts/{accountId}/settings/tabs'.replace('{format}', 'json') 2785 path_params = {} 2786 if 'account_id' in params: 2787 path_params['accountId'] = params['account_id'] 2788 2789 query_params = {} 2790 2791 header_params = {} 2792 2793 form_params = [] 2794 local_var_files = {} 2795 2796 body_params = None 2797 # HTTP header `Accept` 2798 header_params['Accept'] = self.api_client.\ 2799 select_header_accept(['application/json']) 2800 2801 # Authentication setting 2802 auth_settings = [] 2803 2804 return self.api_client.call_api(resource_path, 'GET', 2805 path_params, 2806 query_params, 2807 header_params, 2808 body=body_params, 2809 post_params=form_params, 2810 files=local_var_files, 2811 response_type='TabAccountSettings', 2812 auth_settings=auth_settings, 2813 callback=params.get('callback'), 2814 _return_http_data_only=params.get('_return_http_data_only'), 2815 _preload_content=params.get('_preload_content', True), 2816 _request_timeout=params.get('_request_timeout'), 2817 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)
2955 def get_all_payment_gateway_accounts(self, account_id, **kwargs): 2956 """ 2957 Get all payment gateway account for the provided accountId 2958 This method returns a list of payment gateway accounts and basic information about them. 2959 This method makes a synchronous HTTP request by default. To make an 2960 asynchronous HTTP request, please define a `callback` function 2961 to be invoked when receiving the response. 2962 >>> def callback_function(response): 2963 >>> pprint(response) 2964 >>> 2965 >>> thread = api.get_all_payment_gateway_accounts(account_id, callback=callback_function) 2966 2967 :param callback function: The callback function 2968 for asynchronous request. (optional) 2969 :param str account_id: The external account number (int) or account ID Guid. (required) 2970 :return: PaymentGatewayAccountsInfo 2971 If the method is called asynchronously, 2972 returns the request thread. 2973 """ 2974 kwargs['_return_http_data_only'] = True 2975 if kwargs.get('callback'): 2976 return self.get_all_payment_gateway_accounts_with_http_info(account_id, **kwargs) 2977 else: 2978 (data) = self.get_all_payment_gateway_accounts_with_http_info(account_id, **kwargs) 2979 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)
2981 def get_all_payment_gateway_accounts_with_http_info(self, account_id, **kwargs): 2982 """ 2983 Get all payment gateway account for the provided accountId 2984 This method returns a list of payment gateway accounts and basic information about them. 2985 This method makes a synchronous HTTP request by default. To make an 2986 asynchronous HTTP request, please define a `callback` function 2987 to be invoked when receiving the response. 2988 >>> def callback_function(response): 2989 >>> pprint(response) 2990 >>> 2991 >>> thread = api.get_all_payment_gateway_accounts_with_http_info(account_id, callback=callback_function) 2992 2993 :param callback function: The callback function 2994 for asynchronous request. (optional) 2995 :param str account_id: The external account number (int) or account ID Guid. (required) 2996 :return: PaymentGatewayAccountsInfo 2997 If the method is called asynchronously, 2998 returns the request thread. 2999 """ 3000 3001 all_params = ['account_id'] 3002 all_params.append('callback') 3003 all_params.append('_return_http_data_only') 3004 all_params.append('_preload_content') 3005 all_params.append('_request_timeout') 3006 3007 params = locals() 3008 for key, val in iteritems(params['kwargs']): 3009 if key not in all_params: 3010 raise TypeError( 3011 "Got an unexpected keyword argument '%s'" 3012 " to method get_all_payment_gateway_accounts" % key 3013 ) 3014 params[key] = val 3015 del params['kwargs'] 3016 # verify the required parameter 'account_id' is set 3017 if ('account_id' not in params) or (params['account_id'] is None): 3018 raise ValueError("Missing the required parameter `account_id` when calling `get_all_payment_gateway_accounts`") 3019 3020 3021 collection_formats = {} 3022 3023 resource_path = '/v2.1/accounts/{accountId}/payment_gateway_accounts'.replace('{format}', 'json') 3024 path_params = {} 3025 if 'account_id' in params: 3026 path_params['accountId'] = params['account_id'] 3027 3028 query_params = {} 3029 3030 header_params = {} 3031 3032 form_params = [] 3033 local_var_files = {} 3034 3035 body_params = None 3036 # HTTP header `Accept` 3037 header_params['Accept'] = self.api_client.\ 3038 select_header_accept(['application/json']) 3039 3040 # Authentication setting 3041 auth_settings = [] 3042 3043 return self.api_client.call_api(resource_path, 'GET', 3044 path_params, 3045 query_params, 3046 header_params, 3047 body=body_params, 3048 post_params=form_params, 3049 files=local_var_files, 3050 response_type='PaymentGatewayAccountsInfo', 3051 auth_settings=auth_settings, 3052 callback=params.get('callback'), 3053 _return_http_data_only=params.get('_return_http_data_only'), 3054 _preload_content=params.get('_preload_content', True), 3055 _request_timeout=params.get('_request_timeout'), 3056 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)
3058 def get_billing_charges(self, account_id, **kwargs): 3059 """ 3060 Gets list of recurring and usage charges for the account. 3061 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 3062 This method makes a synchronous HTTP request by default. To make an 3063 asynchronous HTTP request, please define a `callback` function 3064 to be invoked when receiving the response. 3065 >>> def callback_function(response): 3066 >>> pprint(response) 3067 >>> 3068 >>> thread = api.get_billing_charges(account_id, callback=callback_function) 3069 3070 :param callback function: The callback function 3071 for asynchronous request. (optional) 3072 :param str account_id: The external account number (int) or account ID Guid. (required) 3073 :param str include_charges: Specifies which billing charges to return. Valid values are: * envelopes * seats 3074 :return: BillingChargeResponse 3075 If the method is called asynchronously, 3076 returns the request thread. 3077 """ 3078 kwargs['_return_http_data_only'] = True 3079 if kwargs.get('callback'): 3080 return self.get_billing_charges_with_http_info(account_id, **kwargs) 3081 else: 3082 (data) = self.get_billing_charges_with_http_info(account_id, **kwargs) 3083 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)
3085 def get_billing_charges_with_http_info(self, account_id, **kwargs): 3086 """ 3087 Gets list of recurring and usage charges for the account. 3088 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 3089 This method makes a synchronous HTTP request by default. To make an 3090 asynchronous HTTP request, please define a `callback` function 3091 to be invoked when receiving the response. 3092 >>> def callback_function(response): 3093 >>> pprint(response) 3094 >>> 3095 >>> thread = api.get_billing_charges_with_http_info(account_id, callback=callback_function) 3096 3097 :param callback function: The callback function 3098 for asynchronous request. (optional) 3099 :param str account_id: The external account number (int) or account ID Guid. (required) 3100 :param str include_charges: Specifies which billing charges to return. Valid values are: * envelopes * seats 3101 :return: BillingChargeResponse 3102 If the method is called asynchronously, 3103 returns the request thread. 3104 """ 3105 3106 all_params = ['account_id', 'include_charges'] 3107 all_params.append('callback') 3108 all_params.append('_return_http_data_only') 3109 all_params.append('_preload_content') 3110 all_params.append('_request_timeout') 3111 3112 params = locals() 3113 for key, val in iteritems(params['kwargs']): 3114 if key not in all_params: 3115 raise TypeError( 3116 "Got an unexpected keyword argument '%s'" 3117 " to method get_billing_charges" % key 3118 ) 3119 params[key] = val 3120 del params['kwargs'] 3121 # verify the required parameter 'account_id' is set 3122 if ('account_id' not in params) or (params['account_id'] is None): 3123 raise ValueError("Missing the required parameter `account_id` when calling `get_billing_charges`") 3124 3125 3126 collection_formats = {} 3127 3128 resource_path = '/v2.1/accounts/{accountId}/billing_charges'.replace('{format}', 'json') 3129 path_params = {} 3130 if 'account_id' in params: 3131 path_params['accountId'] = params['account_id'] 3132 3133 query_params = {} 3134 if 'include_charges' in params: 3135 query_params['include_charges'] = params['include_charges'] 3136 3137 header_params = {} 3138 3139 form_params = [] 3140 local_var_files = {} 3141 3142 body_params = None 3143 # HTTP header `Accept` 3144 header_params['Accept'] = self.api_client.\ 3145 select_header_accept(['application/json']) 3146 3147 # Authentication setting 3148 auth_settings = [] 3149 3150 return self.api_client.call_api(resource_path, 'GET', 3151 path_params, 3152 query_params, 3153 header_params, 3154 body=body_params, 3155 post_params=form_params, 3156 files=local_var_files, 3157 response_type='BillingChargeResponse', 3158 auth_settings=auth_settings, 3159 callback=params.get('callback'), 3160 _return_http_data_only=params.get('_return_http_data_only'), 3161 _preload_content=params.get('_preload_content', True), 3162 _request_timeout=params.get('_request_timeout'), 3163 collection_formats=collection_formats)
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)
3165 def get_brand(self, account_id, brand_id, **kwargs): 3166 """ 3167 Get information for a specific brand. 3168 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**). 3169 This method makes a synchronous HTTP request by default. To make an 3170 asynchronous HTTP request, please define a `callback` function 3171 to be invoked when receiving the response. 3172 >>> def callback_function(response): 3173 >>> pprint(response) 3174 >>> 3175 >>> thread = api.get_brand(account_id, brand_id, callback=callback_function) 3176 3177 :param callback function: The callback function 3178 for asynchronous request. (optional) 3179 :param str account_id: The external account number (int) or account ID Guid. (required) 3180 :param str brand_id: The unique identifier of a brand. (required) 3181 :param str include_external_references: 3182 :param str include_logos: 3183 :return: Brand 3184 If the method is called asynchronously, 3185 returns the request thread. 3186 """ 3187 kwargs['_return_http_data_only'] = True 3188 if kwargs.get('callback'): 3189 return self.get_brand_with_http_info(account_id, brand_id, **kwargs) 3190 else: 3191 (data) = self.get_brand_with_http_info(account_id, brand_id, **kwargs) 3192 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)
3194 def get_brand_with_http_info(self, account_id, brand_id, **kwargs): 3195 """ 3196 Get information for a specific brand. 3197 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**). 3198 This method makes a synchronous HTTP request by default. To make an 3199 asynchronous HTTP request, please define a `callback` function 3200 to be invoked when receiving the response. 3201 >>> def callback_function(response): 3202 >>> pprint(response) 3203 >>> 3204 >>> thread = api.get_brand_with_http_info(account_id, brand_id, callback=callback_function) 3205 3206 :param callback function: The callback function 3207 for asynchronous request. (optional) 3208 :param str account_id: The external account number (int) or account ID Guid. (required) 3209 :param str brand_id: The unique identifier of a brand. (required) 3210 :param str include_external_references: 3211 :param str include_logos: 3212 :return: Brand 3213 If the method is called asynchronously, 3214 returns the request thread. 3215 """ 3216 3217 all_params = ['account_id', 'brand_id', 'include_external_references', 'include_logos'] 3218 all_params.append('callback') 3219 all_params.append('_return_http_data_only') 3220 all_params.append('_preload_content') 3221 all_params.append('_request_timeout') 3222 3223 params = locals() 3224 for key, val in iteritems(params['kwargs']): 3225 if key not in all_params: 3226 raise TypeError( 3227 "Got an unexpected keyword argument '%s'" 3228 " to method get_brand" % key 3229 ) 3230 params[key] = val 3231 del params['kwargs'] 3232 # verify the required parameter 'account_id' is set 3233 if ('account_id' not in params) or (params['account_id'] is None): 3234 raise ValueError("Missing the required parameter `account_id` when calling `get_brand`") 3235 # verify the required parameter 'brand_id' is set 3236 if ('brand_id' not in params) or (params['brand_id'] is None): 3237 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand`") 3238 3239 3240 collection_formats = {} 3241 3242 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 3243 path_params = {} 3244 if 'account_id' in params: 3245 path_params['accountId'] = params['account_id'] 3246 if 'brand_id' in params: 3247 path_params['brandId'] = params['brand_id'] 3248 3249 query_params = {} 3250 if 'include_external_references' in params: 3251 query_params['include_external_references'] = params['include_external_references'] 3252 if 'include_logos' in params: 3253 query_params['include_logos'] = params['include_logos'] 3254 3255 header_params = {} 3256 3257 form_params = [] 3258 local_var_files = {} 3259 3260 body_params = None 3261 # HTTP header `Accept` 3262 header_params['Accept'] = self.api_client.\ 3263 select_header_accept(['application/json']) 3264 3265 # Authentication setting 3266 auth_settings = [] 3267 3268 return self.api_client.call_api(resource_path, 'GET', 3269 path_params, 3270 query_params, 3271 header_params, 3272 body=body_params, 3273 post_params=form_params, 3274 files=local_var_files, 3275 response_type='Brand', 3276 auth_settings=auth_settings, 3277 callback=params.get('callback'), 3278 _return_http_data_only=params.get('_return_http_data_only'), 3279 _preload_content=params.get('_preload_content', True), 3280 _request_timeout=params.get('_request_timeout'), 3281 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)
3283 def get_brand_export_file(self, account_id, brand_id, **kwargs): 3284 """ 3285 Export a specific brand. 3286 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**). 3287 This method makes a synchronous HTTP request by default. To make an 3288 asynchronous HTTP request, please define a `callback` function 3289 to be invoked when receiving the response. 3290 >>> def callback_function(response): 3291 >>> pprint(response) 3292 >>> 3293 >>> thread = api.get_brand_export_file(account_id, brand_id, callback=callback_function) 3294 3295 :param callback function: The callback function 3296 for asynchronous request. (optional) 3297 :param str account_id: The external account number (int) or account ID Guid. (required) 3298 :param str brand_id: The unique identifier of a brand. (required) 3299 :return: None 3300 If the method is called asynchronously, 3301 returns the request thread. 3302 """ 3303 kwargs['_return_http_data_only'] = True 3304 if kwargs.get('callback'): 3305 return self.get_brand_export_file_with_http_info(account_id, brand_id, **kwargs) 3306 else: 3307 (data) = self.get_brand_export_file_with_http_info(account_id, brand_id, **kwargs) 3308 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)
3310 def get_brand_export_file_with_http_info(self, account_id, brand_id, **kwargs): 3311 """ 3312 Export a specific brand. 3313 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**). 3314 This method makes a synchronous HTTP request by default. To make an 3315 asynchronous HTTP request, please define a `callback` function 3316 to be invoked when receiving the response. 3317 >>> def callback_function(response): 3318 >>> pprint(response) 3319 >>> 3320 >>> thread = api.get_brand_export_file_with_http_info(account_id, brand_id, callback=callback_function) 3321 3322 :param callback function: The callback function 3323 for asynchronous request. (optional) 3324 :param str account_id: The external account number (int) or account ID Guid. (required) 3325 :param str brand_id: The unique identifier of a brand. (required) 3326 :return: None 3327 If the method is called asynchronously, 3328 returns the request thread. 3329 """ 3330 3331 all_params = ['account_id', 'brand_id'] 3332 all_params.append('callback') 3333 all_params.append('_return_http_data_only') 3334 all_params.append('_preload_content') 3335 all_params.append('_request_timeout') 3336 3337 params = locals() 3338 for key, val in iteritems(params['kwargs']): 3339 if key not in all_params: 3340 raise TypeError( 3341 "Got an unexpected keyword argument '%s'" 3342 " to method get_brand_export_file" % key 3343 ) 3344 params[key] = val 3345 del params['kwargs'] 3346 # verify the required parameter 'account_id' is set 3347 if ('account_id' not in params) or (params['account_id'] is None): 3348 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_export_file`") 3349 # verify the required parameter 'brand_id' is set 3350 if ('brand_id' not in params) or (params['brand_id'] is None): 3351 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_export_file`") 3352 3353 3354 collection_formats = {} 3355 3356 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/file'.replace('{format}', 'json') 3357 path_params = {} 3358 if 'account_id' in params: 3359 path_params['accountId'] = params['account_id'] 3360 if 'brand_id' in params: 3361 path_params['brandId'] = params['brand_id'] 3362 3363 query_params = {} 3364 3365 header_params = {} 3366 3367 form_params = [] 3368 local_var_files = {} 3369 3370 body_params = None 3371 # HTTP header `Accept` 3372 header_params['Accept'] = self.api_client.\ 3373 select_header_accept(['application/json']) 3374 3375 # Authentication setting 3376 auth_settings = [] 3377 3378 return self.api_client.call_api(resource_path, 'GET', 3379 path_params, 3380 query_params, 3381 header_params, 3382 body=body_params, 3383 post_params=form_params, 3384 files=local_var_files, 3385 response_type=None, 3386 auth_settings=auth_settings, 3387 callback=params.get('callback'), 3388 _return_http_data_only=params.get('_return_http_data_only'), 3389 _preload_content=params.get('_preload_content', True), 3390 _request_timeout=params.get('_request_timeout'), 3391 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)
3393 def get_brand_logo_by_type(self, account_id, brand_id, logo_type, **kwargs): 3394 """ 3395 Obtains the specified image for a brand. 3396 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**). 3397 This method makes a synchronous HTTP request by default. To make an 3398 asynchronous HTTP request, please define a `callback` function 3399 to be invoked when receiving the response. 3400 >>> def callback_function(response): 3401 >>> pprint(response) 3402 >>> 3403 >>> thread = api.get_brand_logo_by_type(account_id, brand_id, logo_type, callback=callback_function) 3404 3405 :param callback function: The callback function 3406 for asynchronous request. (optional) 3407 :param str account_id: The external account number (int) or account ID Guid. (required) 3408 :param str brand_id: The unique identifier of a brand. (required) 3409 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 3410 :return: file 3411 If the method is called asynchronously, 3412 returns the request thread. 3413 """ 3414 kwargs['_return_http_data_only'] = True 3415 if kwargs.get('callback'): 3416 return self.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 3417 else: 3418 (data) = self.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 3419 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)
3421 def get_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, **kwargs): 3422 """ 3423 Obtains the specified image for a brand. 3424 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**). 3425 This method makes a synchronous HTTP request by default. To make an 3426 asynchronous HTTP request, please define a `callback` function 3427 to be invoked when receiving the response. 3428 >>> def callback_function(response): 3429 >>> pprint(response) 3430 >>> 3431 >>> thread = api.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, callback=callback_function) 3432 3433 :param callback function: The callback function 3434 for asynchronous request. (optional) 3435 :param str account_id: The external account number (int) or account ID Guid. (required) 3436 :param str brand_id: The unique identifier of a brand. (required) 3437 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 3438 :return: file 3439 If the method is called asynchronously, 3440 returns the request thread. 3441 """ 3442 3443 all_params = ['account_id', 'brand_id', 'logo_type'] 3444 all_params.append('callback') 3445 all_params.append('_return_http_data_only') 3446 all_params.append('_preload_content') 3447 all_params.append('_request_timeout') 3448 3449 params = locals() 3450 for key, val in iteritems(params['kwargs']): 3451 if key not in all_params: 3452 raise TypeError( 3453 "Got an unexpected keyword argument '%s'" 3454 " to method get_brand_logo_by_type" % key 3455 ) 3456 params[key] = val 3457 del params['kwargs'] 3458 # verify the required parameter 'account_id' is set 3459 if ('account_id' not in params) or (params['account_id'] is None): 3460 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_logo_by_type`") 3461 # verify the required parameter 'brand_id' is set 3462 if ('brand_id' not in params) or (params['brand_id'] is None): 3463 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_logo_by_type`") 3464 # verify the required parameter 'logo_type' is set 3465 if ('logo_type' not in params) or (params['logo_type'] is None): 3466 raise ValueError("Missing the required parameter `logo_type` when calling `get_brand_logo_by_type`") 3467 3468 3469 collection_formats = {} 3470 3471 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 3472 path_params = {} 3473 if 'account_id' in params: 3474 path_params['accountId'] = params['account_id'] 3475 if 'brand_id' in params: 3476 path_params['brandId'] = params['brand_id'] 3477 if 'logo_type' in params: 3478 path_params['logoType'] = params['logo_type'] 3479 3480 query_params = {} 3481 3482 header_params = {} 3483 3484 form_params = [] 3485 local_var_files = {} 3486 3487 body_params = None 3488 # HTTP header `Accept` 3489 header_params['Accept'] = self.api_client.\ 3490 select_header_accept(['image/png']) 3491 3492 # Authentication setting 3493 auth_settings = [] 3494 3495 return self.api_client.call_api(resource_path, 'GET', 3496 path_params, 3497 query_params, 3498 header_params, 3499 body=body_params, 3500 post_params=form_params, 3501 files=local_var_files, 3502 response_type='file', 3503 auth_settings=auth_settings, 3504 callback=params.get('callback'), 3505 _return_http_data_only=params.get('_return_http_data_only'), 3506 _preload_content=params.get('_preload_content', True), 3507 _request_timeout=params.get('_request_timeout'), 3508 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)
3510 def get_brand_resources(self, account_id, brand_id, **kwargs): 3511 """ 3512 Returns the specified account's list of branding resources (metadata). 3513 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**). 3514 This method makes a synchronous HTTP request by default. To make an 3515 asynchronous HTTP request, please define a `callback` function 3516 to be invoked when receiving the response. 3517 >>> def callback_function(response): 3518 >>> pprint(response) 3519 >>> 3520 >>> thread = api.get_brand_resources(account_id, brand_id, callback=callback_function) 3521 3522 :param callback function: The callback function 3523 for asynchronous request. (optional) 3524 :param str account_id: The external account number (int) or account ID Guid. (required) 3525 :param str brand_id: The unique identifier of a brand. (required) 3526 :return: BrandResourcesList 3527 If the method is called asynchronously, 3528 returns the request thread. 3529 """ 3530 kwargs['_return_http_data_only'] = True 3531 if kwargs.get('callback'): 3532 return self.get_brand_resources_with_http_info(account_id, brand_id, **kwargs) 3533 else: 3534 (data) = self.get_brand_resources_with_http_info(account_id, brand_id, **kwargs) 3535 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)
3537 def get_brand_resources_with_http_info(self, account_id, brand_id, **kwargs): 3538 """ 3539 Returns the specified account's list of branding resources (metadata). 3540 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**). 3541 This method makes a synchronous HTTP request by default. To make an 3542 asynchronous HTTP request, please define a `callback` function 3543 to be invoked when receiving the response. 3544 >>> def callback_function(response): 3545 >>> pprint(response) 3546 >>> 3547 >>> thread = api.get_brand_resources_with_http_info(account_id, brand_id, callback=callback_function) 3548 3549 :param callback function: The callback function 3550 for asynchronous request. (optional) 3551 :param str account_id: The external account number (int) or account ID Guid. (required) 3552 :param str brand_id: The unique identifier of a brand. (required) 3553 :return: BrandResourcesList 3554 If the method is called asynchronously, 3555 returns the request thread. 3556 """ 3557 3558 all_params = ['account_id', 'brand_id'] 3559 all_params.append('callback') 3560 all_params.append('_return_http_data_only') 3561 all_params.append('_preload_content') 3562 all_params.append('_request_timeout') 3563 3564 params = locals() 3565 for key, val in iteritems(params['kwargs']): 3566 if key not in all_params: 3567 raise TypeError( 3568 "Got an unexpected keyword argument '%s'" 3569 " to method get_brand_resources" % key 3570 ) 3571 params[key] = val 3572 del params['kwargs'] 3573 # verify the required parameter 'account_id' is set 3574 if ('account_id' not in params) or (params['account_id'] is None): 3575 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_resources`") 3576 # verify the required parameter 'brand_id' is set 3577 if ('brand_id' not in params) or (params['brand_id'] is None): 3578 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_resources`") 3579 3580 3581 collection_formats = {} 3582 3583 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources'.replace('{format}', 'json') 3584 path_params = {} 3585 if 'account_id' in params: 3586 path_params['accountId'] = params['account_id'] 3587 if 'brand_id' in params: 3588 path_params['brandId'] = params['brand_id'] 3589 3590 query_params = {} 3591 3592 header_params = {} 3593 3594 form_params = [] 3595 local_var_files = {} 3596 3597 body_params = None 3598 # HTTP header `Accept` 3599 header_params['Accept'] = self.api_client.\ 3600 select_header_accept(['application/json']) 3601 3602 # Authentication setting 3603 auth_settings = [] 3604 3605 return self.api_client.call_api(resource_path, 'GET', 3606 path_params, 3607 query_params, 3608 header_params, 3609 body=body_params, 3610 post_params=form_params, 3611 files=local_var_files, 3612 response_type='BrandResourcesList', 3613 auth_settings=auth_settings, 3614 callback=params.get('callback'), 3615 _return_http_data_only=params.get('_return_http_data_only'), 3616 _preload_content=params.get('_preload_content', True), 3617 _request_timeout=params.get('_request_timeout'), 3618 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)
3620 def get_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, **kwargs): 3621 """ 3622 Returns the specified branding resource file. 3623 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**). 3624 This method makes a synchronous HTTP request by default. To make an 3625 asynchronous HTTP request, please define a `callback` function 3626 to be invoked when receiving the response. 3627 >>> def callback_function(response): 3628 >>> pprint(response) 3629 >>> 3630 >>> thread = api.get_brand_resources_by_content_type(account_id, brand_id, resource_content_type, callback=callback_function) 3631 3632 :param callback function: The callback function 3633 for asynchronous request. (optional) 3634 :param str account_id: The external account number (int) or account ID Guid. (required) 3635 :param str brand_id: The unique identifier of a brand. (required) 3636 :param str resource_content_type: (required) 3637 :param str langcode: 3638 :param str return_master: 3639 :return: None 3640 If the method is called asynchronously, 3641 returns the request thread. 3642 """ 3643 kwargs['_return_http_data_only'] = True 3644 if kwargs.get('callback'): 3645 return self.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, **kwargs) 3646 else: 3647 (data) = self.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, **kwargs) 3648 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)
3650 def get_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, **kwargs): 3651 """ 3652 Returns the specified branding resource file. 3653 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**). 3654 This method makes a synchronous HTTP request by default. To make an 3655 asynchronous HTTP request, please define a `callback` function 3656 to be invoked when receiving the response. 3657 >>> def callback_function(response): 3658 >>> pprint(response) 3659 >>> 3660 >>> thread = api.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, callback=callback_function) 3661 3662 :param callback function: The callback function 3663 for asynchronous request. (optional) 3664 :param str account_id: The external account number (int) or account ID Guid. (required) 3665 :param str brand_id: The unique identifier of a brand. (required) 3666 :param str resource_content_type: (required) 3667 :param str langcode: 3668 :param str return_master: 3669 :return: None 3670 If the method is called asynchronously, 3671 returns the request thread. 3672 """ 3673 3674 all_params = ['account_id', 'brand_id', 'resource_content_type', 'langcode', 'return_master'] 3675 all_params.append('callback') 3676 all_params.append('_return_http_data_only') 3677 all_params.append('_preload_content') 3678 all_params.append('_request_timeout') 3679 3680 params = locals() 3681 for key, val in iteritems(params['kwargs']): 3682 if key not in all_params: 3683 raise TypeError( 3684 "Got an unexpected keyword argument '%s'" 3685 " to method get_brand_resources_by_content_type" % key 3686 ) 3687 params[key] = val 3688 del params['kwargs'] 3689 # verify the required parameter 'account_id' is set 3690 if ('account_id' not in params) or (params['account_id'] is None): 3691 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_resources_by_content_type`") 3692 # verify the required parameter 'brand_id' is set 3693 if ('brand_id' not in params) or (params['brand_id'] is None): 3694 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_resources_by_content_type`") 3695 # verify the required parameter 'resource_content_type' is set 3696 if ('resource_content_type' not in params) or (params['resource_content_type'] is None): 3697 raise ValueError("Missing the required parameter `resource_content_type` when calling `get_brand_resources_by_content_type`") 3698 3699 3700 collection_formats = {} 3701 3702 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources/{resourceContentType}'.replace('{format}', 'json') 3703 path_params = {} 3704 if 'account_id' in params: 3705 path_params['accountId'] = params['account_id'] 3706 if 'brand_id' in params: 3707 path_params['brandId'] = params['brand_id'] 3708 if 'resource_content_type' in params: 3709 path_params['resourceContentType'] = params['resource_content_type'] 3710 3711 query_params = {} 3712 if 'langcode' in params: 3713 query_params['langcode'] = params['langcode'] 3714 if 'return_master' in params: 3715 query_params['return_master'] = params['return_master'] 3716 3717 header_params = {} 3718 3719 form_params = [] 3720 local_var_files = {} 3721 3722 body_params = None 3723 # HTTP header `Accept` 3724 header_params['Accept'] = self.api_client.\ 3725 select_header_accept(['application/json']) 3726 3727 # Authentication setting 3728 auth_settings = [] 3729 3730 return self.api_client.call_api(resource_path, 'GET', 3731 path_params, 3732 query_params, 3733 header_params, 3734 body=body_params, 3735 post_params=form_params, 3736 files=local_var_files, 3737 response_type=None, 3738 auth_settings=auth_settings, 3739 callback=params.get('callback'), 3740 _return_http_data_only=params.get('_return_http_data_only'), 3741 _preload_content=params.get('_preload_content', True), 3742 _request_timeout=params.get('_request_timeout'), 3743 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)
3745 def get_consumer_disclosure(self, account_id, lang_code, **kwargs): 3746 """ 3747 Gets the Electronic Record and Signature Disclosure. 3748 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. 3749 This method makes a synchronous HTTP request by default. To make an 3750 asynchronous HTTP request, please define a `callback` function 3751 to be invoked when receiving the response. 3752 >>> def callback_function(response): 3753 >>> pprint(response) 3754 >>> 3755 >>> thread = api.get_consumer_disclosure(account_id, lang_code, callback=callback_function) 3756 3757 :param callback function: The callback function 3758 for asynchronous request. (optional) 3759 :param str account_id: The external account number (int) or account ID Guid. (required) 3760 :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) 3761 :return: ConsumerDisclosure 3762 If the method is called asynchronously, 3763 returns the request thread. 3764 """ 3765 kwargs['_return_http_data_only'] = True 3766 if kwargs.get('callback'): 3767 return self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 3768 else: 3769 (data) = self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 3770 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)
3772 def get_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs): 3773 """ 3774 Gets the Electronic Record and Signature Disclosure. 3775 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. 3776 This method makes a synchronous HTTP request by default. To make an 3777 asynchronous HTTP request, please define a `callback` function 3778 to be invoked when receiving the response. 3779 >>> def callback_function(response): 3780 >>> pprint(response) 3781 >>> 3782 >>> thread = api.get_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function) 3783 3784 :param callback function: The callback function 3785 for asynchronous request. (optional) 3786 :param str account_id: The external account number (int) or account ID Guid. (required) 3787 :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) 3788 :return: ConsumerDisclosure 3789 If the method is called asynchronously, 3790 returns the request thread. 3791 """ 3792 3793 all_params = ['account_id', 'lang_code'] 3794 all_params.append('callback') 3795 all_params.append('_return_http_data_only') 3796 all_params.append('_preload_content') 3797 all_params.append('_request_timeout') 3798 3799 params = locals() 3800 for key, val in iteritems(params['kwargs']): 3801 if key not in all_params: 3802 raise TypeError( 3803 "Got an unexpected keyword argument '%s'" 3804 " to method get_consumer_disclosure" % key 3805 ) 3806 params[key] = val 3807 del params['kwargs'] 3808 # verify the required parameter 'account_id' is set 3809 if ('account_id' not in params) or (params['account_id'] is None): 3810 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure`") 3811 # verify the required parameter 'lang_code' is set 3812 if ('lang_code' not in params) or (params['lang_code'] is None): 3813 raise ValueError("Missing the required parameter `lang_code` when calling `get_consumer_disclosure`") 3814 3815 3816 collection_formats = {} 3817 3818 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 3819 path_params = {} 3820 if 'account_id' in params: 3821 path_params['accountId'] = params['account_id'] 3822 if 'lang_code' in params: 3823 path_params['langCode'] = params['lang_code'] 3824 3825 query_params = {} 3826 3827 header_params = {} 3828 3829 form_params = [] 3830 local_var_files = {} 3831 3832 body_params = None 3833 # HTTP header `Accept` 3834 header_params['Accept'] = self.api_client.\ 3835 select_header_accept(['application/json']) 3836 3837 # Authentication setting 3838 auth_settings = [] 3839 3840 return self.api_client.call_api(resource_path, 'GET', 3841 path_params, 3842 query_params, 3843 header_params, 3844 body=body_params, 3845 post_params=form_params, 3846 files=local_var_files, 3847 response_type='ConsumerDisclosure', 3848 auth_settings=auth_settings, 3849 callback=params.get('callback'), 3850 _return_http_data_only=params.get('_return_http_data_only'), 3851 _preload_content=params.get('_preload_content', True), 3852 _request_timeout=params.get('_request_timeout'), 3853 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)
3855 def get_consumer_disclosure_default(self, account_id, **kwargs): 3856 """ 3857 Gets the Electronic Record and Signature Disclosure for the account. 3858 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. 3859 This method makes a synchronous HTTP request by default. To make an 3860 asynchronous HTTP request, please define a `callback` function 3861 to be invoked when receiving the response. 3862 >>> def callback_function(response): 3863 >>> pprint(response) 3864 >>> 3865 >>> thread = api.get_consumer_disclosure_default(account_id, callback=callback_function) 3866 3867 :param callback function: The callback function 3868 for asynchronous request. (optional) 3869 :param str account_id: The external account number (int) or account ID Guid. (required) 3870 :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. 3871 :return: ConsumerDisclosure 3872 If the method is called asynchronously, 3873 returns the request thread. 3874 """ 3875 kwargs['_return_http_data_only'] = True 3876 if kwargs.get('callback'): 3877 return self.get_consumer_disclosure_default_with_http_info(account_id, **kwargs) 3878 else: 3879 (data) = self.get_consumer_disclosure_default_with_http_info(account_id, **kwargs) 3880 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)
3882 def get_consumer_disclosure_default_with_http_info(self, account_id, **kwargs): 3883 """ 3884 Gets the Electronic Record and Signature Disclosure for the account. 3885 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. 3886 This method makes a synchronous HTTP request by default. To make an 3887 asynchronous HTTP request, please define a `callback` function 3888 to be invoked when receiving the response. 3889 >>> def callback_function(response): 3890 >>> pprint(response) 3891 >>> 3892 >>> thread = api.get_consumer_disclosure_default_with_http_info(account_id, callback=callback_function) 3893 3894 :param callback function: The callback function 3895 for asynchronous request. (optional) 3896 :param str account_id: The external account number (int) or account ID Guid. (required) 3897 :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. 3898 :return: ConsumerDisclosure 3899 If the method is called asynchronously, 3900 returns the request thread. 3901 """ 3902 3903 all_params = ['account_id', 'lang_code'] 3904 all_params.append('callback') 3905 all_params.append('_return_http_data_only') 3906 all_params.append('_preload_content') 3907 all_params.append('_request_timeout') 3908 3909 params = locals() 3910 for key, val in iteritems(params['kwargs']): 3911 if key not in all_params: 3912 raise TypeError( 3913 "Got an unexpected keyword argument '%s'" 3914 " to method get_consumer_disclosure_default" % key 3915 ) 3916 params[key] = val 3917 del params['kwargs'] 3918 # verify the required parameter 'account_id' is set 3919 if ('account_id' not in params) or (params['account_id'] is None): 3920 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure_default`") 3921 3922 3923 collection_formats = {} 3924 3925 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure'.replace('{format}', 'json') 3926 path_params = {} 3927 if 'account_id' in params: 3928 path_params['accountId'] = params['account_id'] 3929 3930 query_params = {} 3931 if 'lang_code' in params: 3932 query_params['langCode'] = params['lang_code'] 3933 3934 header_params = {} 3935 3936 form_params = [] 3937 local_var_files = {} 3938 3939 body_params = None 3940 # HTTP header `Accept` 3941 header_params['Accept'] = self.api_client.\ 3942 select_header_accept(['application/json']) 3943 3944 # Authentication setting 3945 auth_settings = [] 3946 3947 return self.api_client.call_api(resource_path, 'GET', 3948 path_params, 3949 query_params, 3950 header_params, 3951 body=body_params, 3952 post_params=form_params, 3953 files=local_var_files, 3954 response_type='ConsumerDisclosure', 3955 auth_settings=auth_settings, 3956 callback=params.get('callback'), 3957 _return_http_data_only=params.get('_return_http_data_only'), 3958 _preload_content=params.get('_preload_content', True), 3959 _request_timeout=params.get('_request_timeout'), 3960 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)
3962 def get_e_note_configuration(self, account_id, **kwargs): 3963 """ 3964 Returns the configuration information for the eNote eOriginal integration. 3965 3966 This method makes a synchronous HTTP request by default. To make an 3967 asynchronous HTTP request, please define a `callback` function 3968 to be invoked when receiving the response. 3969 >>> def callback_function(response): 3970 >>> pprint(response) 3971 >>> 3972 >>> thread = api.get_e_note_configuration(account_id, callback=callback_function) 3973 3974 :param callback function: The callback function 3975 for asynchronous request. (optional) 3976 :param str account_id: The external account number (int) or account ID Guid. (required) 3977 :return: ENoteConfiguration 3978 If the method is called asynchronously, 3979 returns the request thread. 3980 """ 3981 kwargs['_return_http_data_only'] = True 3982 if kwargs.get('callback'): 3983 return self.get_e_note_configuration_with_http_info(account_id, **kwargs) 3984 else: 3985 (data) = self.get_e_note_configuration_with_http_info(account_id, **kwargs) 3986 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)
3988 def get_e_note_configuration_with_http_info(self, account_id, **kwargs): 3989 """ 3990 Returns the configuration information for the eNote eOriginal integration. 3991 3992 This method makes a synchronous HTTP request by default. To make an 3993 asynchronous HTTP request, please define a `callback` function 3994 to be invoked when receiving the response. 3995 >>> def callback_function(response): 3996 >>> pprint(response) 3997 >>> 3998 >>> thread = api.get_e_note_configuration_with_http_info(account_id, callback=callback_function) 3999 4000 :param callback function: The callback function 4001 for asynchronous request. (optional) 4002 :param str account_id: The external account number (int) or account ID Guid. (required) 4003 :return: ENoteConfiguration 4004 If the method is called asynchronously, 4005 returns the request thread. 4006 """ 4007 4008 all_params = ['account_id'] 4009 all_params.append('callback') 4010 all_params.append('_return_http_data_only') 4011 all_params.append('_preload_content') 4012 all_params.append('_request_timeout') 4013 4014 params = locals() 4015 for key, val in iteritems(params['kwargs']): 4016 if key not in all_params: 4017 raise TypeError( 4018 "Got an unexpected keyword argument '%s'" 4019 " to method get_e_note_configuration" % key 4020 ) 4021 params[key] = val 4022 del params['kwargs'] 4023 # verify the required parameter 'account_id' is set 4024 if ('account_id' not in params) or (params['account_id'] is None): 4025 raise ValueError("Missing the required parameter `account_id` when calling `get_e_note_configuration`") 4026 4027 4028 collection_formats = {} 4029 4030 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 4031 path_params = {} 4032 if 'account_id' in params: 4033 path_params['accountId'] = params['account_id'] 4034 4035 query_params = {} 4036 4037 header_params = {} 4038 4039 form_params = [] 4040 local_var_files = {} 4041 4042 body_params = None 4043 # HTTP header `Accept` 4044 header_params['Accept'] = self.api_client.\ 4045 select_header_accept(['application/json']) 4046 4047 # Authentication setting 4048 auth_settings = [] 4049 4050 return self.api_client.call_api(resource_path, 'GET', 4051 path_params, 4052 query_params, 4053 header_params, 4054 body=body_params, 4055 post_params=form_params, 4056 files=local_var_files, 4057 response_type='ENoteConfiguration', 4058 auth_settings=auth_settings, 4059 callback=params.get('callback'), 4060 _return_http_data_only=params.get('_return_http_data_only'), 4061 _preload_content=params.get('_preload_content', True), 4062 _request_timeout=params.get('_request_timeout'), 4063 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)
4065 def get_envelope_purge_configuration(self, account_id, **kwargs): 4066 """ 4067 Select envelope purge configuration. 4068 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. 4069 This method makes a synchronous HTTP request by default. To make an 4070 asynchronous HTTP request, please define a `callback` function 4071 to be invoked when receiving the response. 4072 >>> def callback_function(response): 4073 >>> pprint(response) 4074 >>> 4075 >>> thread = api.get_envelope_purge_configuration(account_id, callback=callback_function) 4076 4077 :param callback function: The callback function 4078 for asynchronous request. (optional) 4079 :param str account_id: The external account number (int) or account ID Guid. (required) 4080 :return: EnvelopePurgeConfiguration 4081 If the method is called asynchronously, 4082 returns the request thread. 4083 """ 4084 kwargs['_return_http_data_only'] = True 4085 if kwargs.get('callback'): 4086 return self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs) 4087 else: 4088 (data) = self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs) 4089 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)
4091 def get_envelope_purge_configuration_with_http_info(self, account_id, **kwargs): 4092 """ 4093 Select envelope purge configuration. 4094 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. 4095 This method makes a synchronous HTTP request by default. To make an 4096 asynchronous HTTP request, please define a `callback` function 4097 to be invoked when receiving the response. 4098 >>> def callback_function(response): 4099 >>> pprint(response) 4100 >>> 4101 >>> thread = api.get_envelope_purge_configuration_with_http_info(account_id, callback=callback_function) 4102 4103 :param callback function: The callback function 4104 for asynchronous request. (optional) 4105 :param str account_id: The external account number (int) or account ID Guid. (required) 4106 :return: EnvelopePurgeConfiguration 4107 If the method is called asynchronously, 4108 returns the request thread. 4109 """ 4110 4111 all_params = ['account_id'] 4112 all_params.append('callback') 4113 all_params.append('_return_http_data_only') 4114 all_params.append('_preload_content') 4115 all_params.append('_request_timeout') 4116 4117 params = locals() 4118 for key, val in iteritems(params['kwargs']): 4119 if key not in all_params: 4120 raise TypeError( 4121 "Got an unexpected keyword argument '%s'" 4122 " to method get_envelope_purge_configuration" % key 4123 ) 4124 params[key] = val 4125 del params['kwargs'] 4126 # verify the required parameter 'account_id' is set 4127 if ('account_id' not in params) or (params['account_id'] is None): 4128 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_purge_configuration`") 4129 4130 4131 collection_formats = {} 4132 4133 resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json') 4134 path_params = {} 4135 if 'account_id' in params: 4136 path_params['accountId'] = params['account_id'] 4137 4138 query_params = {} 4139 4140 header_params = {} 4141 4142 form_params = [] 4143 local_var_files = {} 4144 4145 body_params = None 4146 # HTTP header `Accept` 4147 header_params['Accept'] = self.api_client.\ 4148 select_header_accept(['application/json']) 4149 4150 # Authentication setting 4151 auth_settings = [] 4152 4153 return self.api_client.call_api(resource_path, 'GET', 4154 path_params, 4155 query_params, 4156 header_params, 4157 body=body_params, 4158 post_params=form_params, 4159 files=local_var_files, 4160 response_type='EnvelopePurgeConfiguration', 4161 auth_settings=auth_settings, 4162 callback=params.get('callback'), 4163 _return_http_data_only=params.get('_return_http_data_only'), 4164 _preload_content=params.get('_preload_content', True), 4165 _request_timeout=params.get('_request_timeout'), 4166 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)
4168 def get_favorite_templates(self, account_id, **kwargs): 4169 """ 4170 Retrieves the list of favorited templates for this caller 4171 4172 This method makes a synchronous HTTP request by default. To make an 4173 asynchronous HTTP request, please define a `callback` function 4174 to be invoked when receiving the response. 4175 >>> def callback_function(response): 4176 >>> pprint(response) 4177 >>> 4178 >>> thread = api.get_favorite_templates(account_id, callback=callback_function) 4179 4180 :param callback function: The callback function 4181 for asynchronous request. (optional) 4182 :param str account_id: The external account number (int) or account ID Guid. (required) 4183 :return: FavoriteTemplatesInfo 4184 If the method is called asynchronously, 4185 returns the request thread. 4186 """ 4187 kwargs['_return_http_data_only'] = True 4188 if kwargs.get('callback'): 4189 return self.get_favorite_templates_with_http_info(account_id, **kwargs) 4190 else: 4191 (data) = self.get_favorite_templates_with_http_info(account_id, **kwargs) 4192 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)
4194 def get_favorite_templates_with_http_info(self, account_id, **kwargs): 4195 """ 4196 Retrieves the list of favorited templates for this caller 4197 4198 This method makes a synchronous HTTP request by default. To make an 4199 asynchronous HTTP request, please define a `callback` function 4200 to be invoked when receiving the response. 4201 >>> def callback_function(response): 4202 >>> pprint(response) 4203 >>> 4204 >>> thread = api.get_favorite_templates_with_http_info(account_id, callback=callback_function) 4205 4206 :param callback function: The callback function 4207 for asynchronous request. (optional) 4208 :param str account_id: The external account number (int) or account ID Guid. (required) 4209 :return: FavoriteTemplatesInfo 4210 If the method is called asynchronously, 4211 returns the request thread. 4212 """ 4213 4214 all_params = ['account_id'] 4215 all_params.append('callback') 4216 all_params.append('_return_http_data_only') 4217 all_params.append('_preload_content') 4218 all_params.append('_request_timeout') 4219 4220 params = locals() 4221 for key, val in iteritems(params['kwargs']): 4222 if key not in all_params: 4223 raise TypeError( 4224 "Got an unexpected keyword argument '%s'" 4225 " to method get_favorite_templates" % key 4226 ) 4227 params[key] = val 4228 del params['kwargs'] 4229 # verify the required parameter 'account_id' is set 4230 if ('account_id' not in params) or (params['account_id'] is None): 4231 raise ValueError("Missing the required parameter `account_id` when calling `get_favorite_templates`") 4232 4233 4234 collection_formats = {} 4235 4236 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 4237 path_params = {} 4238 if 'account_id' in params: 4239 path_params['accountId'] = params['account_id'] 4240 4241 query_params = {} 4242 4243 header_params = {} 4244 4245 form_params = [] 4246 local_var_files = {} 4247 4248 body_params = None 4249 # HTTP header `Accept` 4250 header_params['Accept'] = self.api_client.\ 4251 select_header_accept(['application/json']) 4252 4253 # Authentication setting 4254 auth_settings = [] 4255 4256 return self.api_client.call_api(resource_path, 'GET', 4257 path_params, 4258 query_params, 4259 header_params, 4260 body=body_params, 4261 post_params=form_params, 4262 files=local_var_files, 4263 response_type='FavoriteTemplatesInfo', 4264 auth_settings=auth_settings, 4265 callback=params.get('callback'), 4266 _return_http_data_only=params.get('_return_http_data_only'), 4267 _preload_content=params.get('_preload_content', True), 4268 _request_timeout=params.get('_request_timeout'), 4269 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)
4271 def get_notification_defaults(self, account_id, **kwargs): 4272 """ 4273 Returns default user level settings for a specified account 4274 This method returns the default settings for the email notifications that signers and senders receive about envelopes. 4275 This method makes a synchronous HTTP request by default. To make an 4276 asynchronous HTTP request, please define a `callback` function 4277 to be invoked when receiving the response. 4278 >>> def callback_function(response): 4279 >>> pprint(response) 4280 >>> 4281 >>> thread = api.get_notification_defaults(account_id, callback=callback_function) 4282 4283 :param callback function: The callback function 4284 for asynchronous request. (optional) 4285 :param str account_id: The external account number (int) or account ID Guid. (required) 4286 :return: NotificationDefaults 4287 If the method is called asynchronously, 4288 returns the request thread. 4289 """ 4290 kwargs['_return_http_data_only'] = True 4291 if kwargs.get('callback'): 4292 return self.get_notification_defaults_with_http_info(account_id, **kwargs) 4293 else: 4294 (data) = self.get_notification_defaults_with_http_info(account_id, **kwargs) 4295 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)
4297 def get_notification_defaults_with_http_info(self, account_id, **kwargs): 4298 """ 4299 Returns default user level settings for a specified account 4300 This method returns the default settings for the email notifications that signers and senders receive about envelopes. 4301 This method makes a synchronous HTTP request by default. To make an 4302 asynchronous HTTP request, please define a `callback` function 4303 to be invoked when receiving the response. 4304 >>> def callback_function(response): 4305 >>> pprint(response) 4306 >>> 4307 >>> thread = api.get_notification_defaults_with_http_info(account_id, callback=callback_function) 4308 4309 :param callback function: The callback function 4310 for asynchronous request. (optional) 4311 :param str account_id: The external account number (int) or account ID Guid. (required) 4312 :return: NotificationDefaults 4313 If the method is called asynchronously, 4314 returns the request thread. 4315 """ 4316 4317 all_params = ['account_id'] 4318 all_params.append('callback') 4319 all_params.append('_return_http_data_only') 4320 all_params.append('_preload_content') 4321 all_params.append('_request_timeout') 4322 4323 params = locals() 4324 for key, val in iteritems(params['kwargs']): 4325 if key not in all_params: 4326 raise TypeError( 4327 "Got an unexpected keyword argument '%s'" 4328 " to method get_notification_defaults" % key 4329 ) 4330 params[key] = val 4331 del params['kwargs'] 4332 # verify the required parameter 'account_id' is set 4333 if ('account_id' not in params) or (params['account_id'] is None): 4334 raise ValueError("Missing the required parameter `account_id` when calling `get_notification_defaults`") 4335 4336 4337 collection_formats = {} 4338 4339 resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json') 4340 path_params = {} 4341 if 'account_id' in params: 4342 path_params['accountId'] = params['account_id'] 4343 4344 query_params = {} 4345 4346 header_params = {} 4347 4348 form_params = [] 4349 local_var_files = {} 4350 4351 body_params = None 4352 # HTTP header `Accept` 4353 header_params['Accept'] = self.api_client.\ 4354 select_header_accept(['application/json']) 4355 4356 # Authentication setting 4357 auth_settings = [] 4358 4359 return self.api_client.call_api(resource_path, 'GET', 4360 path_params, 4361 query_params, 4362 header_params, 4363 body=body_params, 4364 post_params=form_params, 4365 files=local_var_files, 4366 response_type='NotificationDefaults', 4367 auth_settings=auth_settings, 4368 callback=params.get('callback'), 4369 _return_http_data_only=params.get('_return_http_data_only'), 4370 _preload_content=params.get('_preload_content', True), 4371 _request_timeout=params.get('_request_timeout'), 4372 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)
4374 def get_password_rules(self, account_id, **kwargs): 4375 """ 4376 Get the password rules 4377 This method retrieves the password rules for an account. 4378 This method makes a synchronous HTTP request by default. To make an 4379 asynchronous HTTP request, please define a `callback` function 4380 to be invoked when receiving the response. 4381 >>> def callback_function(response): 4382 >>> pprint(response) 4383 >>> 4384 >>> thread = api.get_password_rules(account_id, callback=callback_function) 4385 4386 :param callback function: The callback function 4387 for asynchronous request. (optional) 4388 :param str account_id: The external account number (int) or account ID Guid. (required) 4389 :return: AccountPasswordRules 4390 If the method is called asynchronously, 4391 returns the request thread. 4392 """ 4393 kwargs['_return_http_data_only'] = True 4394 if kwargs.get('callback'): 4395 return self.get_password_rules_with_http_info(account_id, **kwargs) 4396 else: 4397 (data) = self.get_password_rules_with_http_info(account_id, **kwargs) 4398 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)
4400 def get_password_rules_with_http_info(self, account_id, **kwargs): 4401 """ 4402 Get the password rules 4403 This method retrieves the password rules for an account. 4404 This method makes a synchronous HTTP request by default. To make an 4405 asynchronous HTTP request, please define a `callback` function 4406 to be invoked when receiving the response. 4407 >>> def callback_function(response): 4408 >>> pprint(response) 4409 >>> 4410 >>> thread = api.get_password_rules_with_http_info(account_id, callback=callback_function) 4411 4412 :param callback function: The callback function 4413 for asynchronous request. (optional) 4414 :param str account_id: The external account number (int) or account ID Guid. (required) 4415 :return: AccountPasswordRules 4416 If the method is called asynchronously, 4417 returns the request thread. 4418 """ 4419 4420 all_params = ['account_id'] 4421 all_params.append('callback') 4422 all_params.append('_return_http_data_only') 4423 all_params.append('_preload_content') 4424 all_params.append('_request_timeout') 4425 4426 params = locals() 4427 for key, val in iteritems(params['kwargs']): 4428 if key not in all_params: 4429 raise TypeError( 4430 "Got an unexpected keyword argument '%s'" 4431 " to method get_password_rules" % key 4432 ) 4433 params[key] = val 4434 del params['kwargs'] 4435 # verify the required parameter 'account_id' is set 4436 if ('account_id' not in params) or (params['account_id'] is None): 4437 raise ValueError("Missing the required parameter `account_id` when calling `get_password_rules`") 4438 4439 4440 collection_formats = {} 4441 4442 resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json') 4443 path_params = {} 4444 if 'account_id' in params: 4445 path_params['accountId'] = params['account_id'] 4446 4447 query_params = {} 4448 4449 header_params = {} 4450 4451 form_params = [] 4452 local_var_files = {} 4453 4454 body_params = None 4455 # HTTP header `Accept` 4456 header_params['Accept'] = self.api_client.\ 4457 select_header_accept(['application/json']) 4458 4459 # Authentication setting 4460 auth_settings = [] 4461 4462 return self.api_client.call_api(resource_path, 'GET', 4463 path_params, 4464 query_params, 4465 header_params, 4466 body=body_params, 4467 post_params=form_params, 4468 files=local_var_files, 4469 response_type='AccountPasswordRules', 4470 auth_settings=auth_settings, 4471 callback=params.get('callback'), 4472 _return_http_data_only=params.get('_return_http_data_only'), 4473 _preload_content=params.get('_preload_content', True), 4474 _request_timeout=params.get('_request_timeout'), 4475 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)
4477 def get_password_rules_0(self, **kwargs): 4478 """ 4479 Get membership account password rules 4480 4481 This method makes a synchronous HTTP request by default. To make an 4482 asynchronous HTTP request, please define a `callback` function 4483 to be invoked when receiving the response. 4484 >>> def callback_function(response): 4485 >>> pprint(response) 4486 >>> 4487 >>> thread = api.get_password_rules_0(callback=callback_function) 4488 4489 :param callback function: The callback function 4490 for asynchronous request. (optional) 4491 :return: UserPasswordRules 4492 If the method is called asynchronously, 4493 returns the request thread. 4494 """ 4495 kwargs['_return_http_data_only'] = True 4496 if kwargs.get('callback'): 4497 return self.get_password_rules_0_with_http_info(**kwargs) 4498 else: 4499 (data) = self.get_password_rules_0_with_http_info(**kwargs) 4500 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)
4502 def get_password_rules_0_with_http_info(self, **kwargs): 4503 """ 4504 Get membership account password rules 4505 4506 This method makes a synchronous HTTP request by default. To make an 4507 asynchronous HTTP request, please define a `callback` function 4508 to be invoked when receiving the response. 4509 >>> def callback_function(response): 4510 >>> pprint(response) 4511 >>> 4512 >>> thread = api.get_password_rules_0_with_http_info(callback=callback_function) 4513 4514 :param callback function: The callback function 4515 for asynchronous request. (optional) 4516 :return: UserPasswordRules 4517 If the method is called asynchronously, 4518 returns the request thread. 4519 """ 4520 4521 all_params = [] 4522 all_params.append('callback') 4523 all_params.append('_return_http_data_only') 4524 all_params.append('_preload_content') 4525 all_params.append('_request_timeout') 4526 4527 params = locals() 4528 for key, val in iteritems(params['kwargs']): 4529 if key not in all_params: 4530 raise TypeError( 4531 "Got an unexpected keyword argument '%s'" 4532 " to method get_password_rules_0" % key 4533 ) 4534 params[key] = val 4535 del params['kwargs'] 4536 4537 collection_formats = {} 4538 4539 resource_path = '/v2.1/current_user/password_rules'.replace('{format}', 'json') 4540 path_params = {} 4541 4542 query_params = {} 4543 4544 header_params = {} 4545 4546 form_params = [] 4547 local_var_files = {} 4548 4549 body_params = None 4550 # HTTP header `Accept` 4551 header_params['Accept'] = self.api_client.\ 4552 select_header_accept(['application/json']) 4553 4554 # Authentication setting 4555 auth_settings = [] 4556 4557 return self.api_client.call_api(resource_path, 'GET', 4558 path_params, 4559 query_params, 4560 header_params, 4561 body=body_params, 4562 post_params=form_params, 4563 files=local_var_files, 4564 response_type='UserPasswordRules', 4565 auth_settings=auth_settings, 4566 callback=params.get('callback'), 4567 _return_http_data_only=params.get('_return_http_data_only'), 4568 _preload_content=params.get('_preload_content', True), 4569 _request_timeout=params.get('_request_timeout'), 4570 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)
4572 def get_permission_profile(self, account_id, permission_profile_id, **kwargs): 4573 """ 4574 Returns a permissions profile in the specified account. 4575 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/) 4576 This method makes a synchronous HTTP request by default. To make an 4577 asynchronous HTTP request, please define a `callback` function 4578 to be invoked when receiving the response. 4579 >>> def callback_function(response): 4580 >>> pprint(response) 4581 >>> 4582 >>> thread = api.get_permission_profile(account_id, permission_profile_id, callback=callback_function) 4583 4584 :param callback function: The callback function 4585 for asynchronous request. (optional) 4586 :param str account_id: The external account number (int) or account ID Guid. (required) 4587 :param str permission_profile_id: (required) 4588 :param str include: 4589 :return: PermissionProfile 4590 If the method is called asynchronously, 4591 returns the request thread. 4592 """ 4593 kwargs['_return_http_data_only'] = True 4594 if kwargs.get('callback'): 4595 return self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 4596 else: 4597 (data) = self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 4598 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)
4600 def get_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 4601 """ 4602 Returns a permissions profile in the specified account. 4603 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/) 4604 This method makes a synchronous HTTP request by default. To make an 4605 asynchronous HTTP request, please define a `callback` function 4606 to be invoked when receiving the response. 4607 >>> def callback_function(response): 4608 >>> pprint(response) 4609 >>> 4610 >>> thread = api.get_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 4611 4612 :param callback function: The callback function 4613 for asynchronous request. (optional) 4614 :param str account_id: The external account number (int) or account ID Guid. (required) 4615 :param str permission_profile_id: (required) 4616 :param str include: 4617 :return: PermissionProfile 4618 If the method is called asynchronously, 4619 returns the request thread. 4620 """ 4621 4622 all_params = ['account_id', 'permission_profile_id', 'include'] 4623 all_params.append('callback') 4624 all_params.append('_return_http_data_only') 4625 all_params.append('_preload_content') 4626 all_params.append('_request_timeout') 4627 4628 params = locals() 4629 for key, val in iteritems(params['kwargs']): 4630 if key not in all_params: 4631 raise TypeError( 4632 "Got an unexpected keyword argument '%s'" 4633 " to method get_permission_profile" % key 4634 ) 4635 params[key] = val 4636 del params['kwargs'] 4637 # verify the required parameter 'account_id' is set 4638 if ('account_id' not in params) or (params['account_id'] is None): 4639 raise ValueError("Missing the required parameter `account_id` when calling `get_permission_profile`") 4640 # verify the required parameter 'permission_profile_id' is set 4641 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 4642 raise ValueError("Missing the required parameter `permission_profile_id` when calling `get_permission_profile`") 4643 4644 4645 collection_formats = {} 4646 4647 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 4648 path_params = {} 4649 if 'account_id' in params: 4650 path_params['accountId'] = params['account_id'] 4651 if 'permission_profile_id' in params: 4652 path_params['permissionProfileId'] = params['permission_profile_id'] 4653 4654 query_params = {} 4655 if 'include' in params: 4656 query_params['include'] = params['include'] 4657 4658 header_params = {} 4659 4660 form_params = [] 4661 local_var_files = {} 4662 4663 body_params = None 4664 # HTTP header `Accept` 4665 header_params['Accept'] = self.api_client.\ 4666 select_header_accept(['application/json']) 4667 4668 # Authentication setting 4669 auth_settings = [] 4670 4671 return self.api_client.call_api(resource_path, 'GET', 4672 path_params, 4673 query_params, 4674 header_params, 4675 body=body_params, 4676 post_params=form_params, 4677 files=local_var_files, 4678 response_type='PermissionProfile', 4679 auth_settings=auth_settings, 4680 callback=params.get('callback'), 4681 _return_http_data_only=params.get('_return_http_data_only'), 4682 _preload_content=params.get('_preload_content', True), 4683 _request_timeout=params.get('_request_timeout'), 4684 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)
4822 def get_provisioning(self, **kwargs): 4823 """ 4824 Retrieves the account provisioning information for the account. 4825 Retrieves the account provisioning information for the account. 4826 This method makes a synchronous HTTP request by default. To make an 4827 asynchronous HTTP request, please define a `callback` function 4828 to be invoked when receiving the response. 4829 >>> def callback_function(response): 4830 >>> pprint(response) 4831 >>> 4832 >>> thread = api.get_provisioning(callback=callback_function) 4833 4834 :param callback function: The callback function 4835 for asynchronous request. (optional) 4836 :return: ProvisioningInformation 4837 If the method is called asynchronously, 4838 returns the request thread. 4839 """ 4840 kwargs['_return_http_data_only'] = True 4841 if kwargs.get('callback'): 4842 return self.get_provisioning_with_http_info(**kwargs) 4843 else: 4844 (data) = self.get_provisioning_with_http_info(**kwargs) 4845 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)
4847 def get_provisioning_with_http_info(self, **kwargs): 4848 """ 4849 Retrieves the account provisioning information for the account. 4850 Retrieves the account provisioning information for the account. 4851 This method makes a synchronous HTTP request by default. To make an 4852 asynchronous HTTP request, please define a `callback` function 4853 to be invoked when receiving the response. 4854 >>> def callback_function(response): 4855 >>> pprint(response) 4856 >>> 4857 >>> thread = api.get_provisioning_with_http_info(callback=callback_function) 4858 4859 :param callback function: The callback function 4860 for asynchronous request. (optional) 4861 :return: ProvisioningInformation 4862 If the method is called asynchronously, 4863 returns the request thread. 4864 """ 4865 4866 all_params = [] 4867 all_params.append('callback') 4868 all_params.append('_return_http_data_only') 4869 all_params.append('_preload_content') 4870 all_params.append('_request_timeout') 4871 4872 params = locals() 4873 for key, val in iteritems(params['kwargs']): 4874 if key not in all_params: 4875 raise TypeError( 4876 "Got an unexpected keyword argument '%s'" 4877 " to method get_provisioning" % key 4878 ) 4879 params[key] = val 4880 del params['kwargs'] 4881 4882 collection_formats = {} 4883 4884 resource_path = '/v2.1/accounts/provisioning'.replace('{format}', 'json') 4885 path_params = {} 4886 4887 query_params = {} 4888 4889 header_params = {} 4890 4891 form_params = [] 4892 local_var_files = {} 4893 4894 body_params = None 4895 # HTTP header `Accept` 4896 header_params['Accept'] = self.api_client.\ 4897 select_header_accept(['application/json']) 4898 4899 # Authentication setting 4900 auth_settings = [] 4901 4902 return self.api_client.call_api(resource_path, 'GET', 4903 path_params, 4904 query_params, 4905 header_params, 4906 body=body_params, 4907 post_params=form_params, 4908 files=local_var_files, 4909 response_type='ProvisioningInformation', 4910 auth_settings=auth_settings, 4911 callback=params.get('callback'), 4912 _return_http_data_only=params.get('_return_http_data_only'), 4913 _preload_content=params.get('_preload_content', True), 4914 _request_timeout=params.get('_request_timeout'), 4915 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)
4917 def get_supported_languages(self, account_id, **kwargs): 4918 """ 4919 Gets list of supported languages for recipient language setting. 4920 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). 4921 This method makes a synchronous HTTP request by default. To make an 4922 asynchronous HTTP request, please define a `callback` function 4923 to be invoked when receiving the response. 4924 >>> def callback_function(response): 4925 >>> pprint(response) 4926 >>> 4927 >>> thread = api.get_supported_languages(account_id, callback=callback_function) 4928 4929 :param callback function: The callback function 4930 for asynchronous request. (optional) 4931 :param str account_id: The external account number (int) or account ID Guid. (required) 4932 :return: SupportedLanguages 4933 If the method is called asynchronously, 4934 returns the request thread. 4935 """ 4936 kwargs['_return_http_data_only'] = True 4937 if kwargs.get('callback'): 4938 return self.get_supported_languages_with_http_info(account_id, **kwargs) 4939 else: 4940 (data) = self.get_supported_languages_with_http_info(account_id, **kwargs) 4941 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)
4943 def get_supported_languages_with_http_info(self, account_id, **kwargs): 4944 """ 4945 Gets list of supported languages for recipient language setting. 4946 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). 4947 This method makes a synchronous HTTP request by default. To make an 4948 asynchronous HTTP request, please define a `callback` function 4949 to be invoked when receiving the response. 4950 >>> def callback_function(response): 4951 >>> pprint(response) 4952 >>> 4953 >>> thread = api.get_supported_languages_with_http_info(account_id, callback=callback_function) 4954 4955 :param callback function: The callback function 4956 for asynchronous request. (optional) 4957 :param str account_id: The external account number (int) or account ID Guid. (required) 4958 :return: SupportedLanguages 4959 If the method is called asynchronously, 4960 returns the request thread. 4961 """ 4962 4963 all_params = ['account_id'] 4964 all_params.append('callback') 4965 all_params.append('_return_http_data_only') 4966 all_params.append('_preload_content') 4967 all_params.append('_request_timeout') 4968 4969 params = locals() 4970 for key, val in iteritems(params['kwargs']): 4971 if key not in all_params: 4972 raise TypeError( 4973 "Got an unexpected keyword argument '%s'" 4974 " to method get_supported_languages" % key 4975 ) 4976 params[key] = val 4977 del params['kwargs'] 4978 # verify the required parameter 'account_id' is set 4979 if ('account_id' not in params) or (params['account_id'] is None): 4980 raise ValueError("Missing the required parameter `account_id` when calling `get_supported_languages`") 4981 4982 4983 collection_formats = {} 4984 4985 resource_path = '/v2.1/accounts/{accountId}/supported_languages'.replace('{format}', 'json') 4986 path_params = {} 4987 if 'account_id' in params: 4988 path_params['accountId'] = params['account_id'] 4989 4990 query_params = {} 4991 4992 header_params = {} 4993 4994 form_params = [] 4995 local_var_files = {} 4996 4997 body_params = None 4998 # HTTP header `Accept` 4999 header_params['Accept'] = self.api_client.\ 5000 select_header_accept(['application/json']) 5001 5002 # Authentication setting 5003 auth_settings = [] 5004 5005 return self.api_client.call_api(resource_path, 'GET', 5006 path_params, 5007 query_params, 5008 header_params, 5009 body=body_params, 5010 post_params=form_params, 5011 files=local_var_files, 5012 response_type='SupportedLanguages', 5013 auth_settings=auth_settings, 5014 callback=params.get('callback'), 5015 _return_http_data_only=params.get('_return_http_data_only'), 5016 _preload_content=params.get('_preload_content', True), 5017 _request_timeout=params.get('_request_timeout'), 5018 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)
5135 def get_watermark(self, account_id, **kwargs): 5136 """ 5137 Get watermark information. 5138 5139 This method makes a synchronous HTTP request by default. To make an 5140 asynchronous HTTP request, please define a `callback` function 5141 to be invoked when receiving the response. 5142 >>> def callback_function(response): 5143 >>> pprint(response) 5144 >>> 5145 >>> thread = api.get_watermark(account_id, callback=callback_function) 5146 5147 :param callback function: The callback function 5148 for asynchronous request. (optional) 5149 :param str account_id: The external account number (int) or account ID Guid. (required) 5150 :return: Watermark 5151 If the method is called asynchronously, 5152 returns the request thread. 5153 """ 5154 kwargs['_return_http_data_only'] = True 5155 if kwargs.get('callback'): 5156 return self.get_watermark_with_http_info(account_id, **kwargs) 5157 else: 5158 (data) = self.get_watermark_with_http_info(account_id, **kwargs) 5159 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)
5161 def get_watermark_with_http_info(self, account_id, **kwargs): 5162 """ 5163 Get watermark information. 5164 5165 This method makes a synchronous HTTP request by default. To make an 5166 asynchronous HTTP request, please define a `callback` function 5167 to be invoked when receiving the response. 5168 >>> def callback_function(response): 5169 >>> pprint(response) 5170 >>> 5171 >>> thread = api.get_watermark_with_http_info(account_id, callback=callback_function) 5172 5173 :param callback function: The callback function 5174 for asynchronous request. (optional) 5175 :param str account_id: The external account number (int) or account ID Guid. (required) 5176 :return: Watermark 5177 If the method is called asynchronously, 5178 returns the request thread. 5179 """ 5180 5181 all_params = ['account_id'] 5182 all_params.append('callback') 5183 all_params.append('_return_http_data_only') 5184 all_params.append('_preload_content') 5185 all_params.append('_request_timeout') 5186 5187 params = locals() 5188 for key, val in iteritems(params['kwargs']): 5189 if key not in all_params: 5190 raise TypeError( 5191 "Got an unexpected keyword argument '%s'" 5192 " to method get_watermark" % key 5193 ) 5194 params[key] = val 5195 del params['kwargs'] 5196 # verify the required parameter 'account_id' is set 5197 if ('account_id' not in params) or (params['account_id'] is None): 5198 raise ValueError("Missing the required parameter `account_id` when calling `get_watermark`") 5199 5200 5201 collection_formats = {} 5202 5203 resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json') 5204 path_params = {} 5205 if 'account_id' in params: 5206 path_params['accountId'] = params['account_id'] 5207 5208 query_params = {} 5209 5210 header_params = {} 5211 5212 form_params = [] 5213 local_var_files = {} 5214 5215 body_params = None 5216 # HTTP header `Accept` 5217 header_params['Accept'] = self.api_client.\ 5218 select_header_accept(['application/json']) 5219 5220 # Authentication setting 5221 auth_settings = [] 5222 5223 return self.api_client.call_api(resource_path, 'GET', 5224 path_params, 5225 query_params, 5226 header_params, 5227 body=body_params, 5228 post_params=form_params, 5229 files=local_var_files, 5230 response_type='Watermark', 5231 auth_settings=auth_settings, 5232 callback=params.get('callback'), 5233 _return_http_data_only=params.get('_return_http_data_only'), 5234 _preload_content=params.get('_preload_content', True), 5235 _request_timeout=params.get('_request_timeout'), 5236 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)
5238 def get_watermark_preview(self, account_id, **kwargs): 5239 """ 5240 Get watermark preview. 5241 5242 This method makes a synchronous HTTP request by default. To make an 5243 asynchronous HTTP request, please define a `callback` function 5244 to be invoked when receiving the response. 5245 >>> def callback_function(response): 5246 >>> pprint(response) 5247 >>> 5248 >>> thread = api.get_watermark_preview(account_id, callback=callback_function) 5249 5250 :param callback function: The callback function 5251 for asynchronous request. (optional) 5252 :param str account_id: The external account number (int) or account ID Guid. (required) 5253 :param Watermark watermark: 5254 :return: Watermark 5255 If the method is called asynchronously, 5256 returns the request thread. 5257 """ 5258 kwargs['_return_http_data_only'] = True 5259 if kwargs.get('callback'): 5260 return self.get_watermark_preview_with_http_info(account_id, **kwargs) 5261 else: 5262 (data) = self.get_watermark_preview_with_http_info(account_id, **kwargs) 5263 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)
5265 def get_watermark_preview_with_http_info(self, account_id, **kwargs): 5266 """ 5267 Get watermark preview. 5268 5269 This method makes a synchronous HTTP request by default. To make an 5270 asynchronous HTTP request, please define a `callback` function 5271 to be invoked when receiving the response. 5272 >>> def callback_function(response): 5273 >>> pprint(response) 5274 >>> 5275 >>> thread = api.get_watermark_preview_with_http_info(account_id, callback=callback_function) 5276 5277 :param callback function: The callback function 5278 for asynchronous request. (optional) 5279 :param str account_id: The external account number (int) or account ID Guid. (required) 5280 :param Watermark watermark: 5281 :return: Watermark 5282 If the method is called asynchronously, 5283 returns the request thread. 5284 """ 5285 5286 all_params = ['account_id', 'watermark'] 5287 all_params.append('callback') 5288 all_params.append('_return_http_data_only') 5289 all_params.append('_preload_content') 5290 all_params.append('_request_timeout') 5291 5292 params = locals() 5293 for key, val in iteritems(params['kwargs']): 5294 if key not in all_params: 5295 raise TypeError( 5296 "Got an unexpected keyword argument '%s'" 5297 " to method get_watermark_preview" % key 5298 ) 5299 params[key] = val 5300 del params['kwargs'] 5301 # verify the required parameter 'account_id' is set 5302 if ('account_id' not in params) or (params['account_id'] is None): 5303 raise ValueError("Missing the required parameter `account_id` when calling `get_watermark_preview`") 5304 5305 5306 collection_formats = {} 5307 5308 resource_path = '/v2.1/accounts/{accountId}/watermark/preview'.replace('{format}', 'json') 5309 path_params = {} 5310 if 'account_id' in params: 5311 path_params['accountId'] = params['account_id'] 5312 5313 query_params = {} 5314 5315 header_params = {} 5316 5317 form_params = [] 5318 local_var_files = {} 5319 5320 body_params = None 5321 if 'watermark' in params: 5322 body_params = params['watermark'] 5323 # HTTP header `Accept` 5324 header_params['Accept'] = self.api_client.\ 5325 select_header_accept(['application/json']) 5326 5327 # Authentication setting 5328 auth_settings = [] 5329 5330 return self.api_client.call_api(resource_path, 'PUT', 5331 path_params, 5332 query_params, 5333 header_params, 5334 body=body_params, 5335 post_params=form_params, 5336 files=local_var_files, 5337 response_type='Watermark', 5338 auth_settings=auth_settings, 5339 callback=params.get('callback'), 5340 _return_http_data_only=params.get('_return_http_data_only'), 5341 _preload_content=params.get('_preload_content', True), 5342 _request_timeout=params.get('_request_timeout'), 5343 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)
5345 def list_brands(self, account_id, **kwargs): 5346 """ 5347 Gets a list of brand profiles. 5348 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. 5349 This method makes a synchronous HTTP request by default. To make an 5350 asynchronous HTTP request, please define a `callback` function 5351 to be invoked when receiving the response. 5352 >>> def callback_function(response): 5353 >>> pprint(response) 5354 >>> 5355 >>> thread = api.list_brands(account_id, callback=callback_function) 5356 5357 :param callback function: The callback function 5358 for asynchronous request. (optional) 5359 :param str account_id: The external account number (int) or account ID Guid. (required) 5360 :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set. 5361 :param str include_logos: When set to **true**, returns the logos associated with the brand. 5362 :return: BrandsResponse 5363 If the method is called asynchronously, 5364 returns the request thread. 5365 """ 5366 kwargs['_return_http_data_only'] = True 5367 if kwargs.get('callback'): 5368 return self.list_brands_with_http_info(account_id, **kwargs) 5369 else: 5370 (data) = self.list_brands_with_http_info(account_id, **kwargs) 5371 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)
5373 def list_brands_with_http_info(self, account_id, **kwargs): 5374 """ 5375 Gets a list of brand profiles. 5376 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. 5377 This method makes a synchronous HTTP request by default. To make an 5378 asynchronous HTTP request, please define a `callback` function 5379 to be invoked when receiving the response. 5380 >>> def callback_function(response): 5381 >>> pprint(response) 5382 >>> 5383 >>> thread = api.list_brands_with_http_info(account_id, callback=callback_function) 5384 5385 :param callback function: The callback function 5386 for asynchronous request. (optional) 5387 :param str account_id: The external account number (int) or account ID Guid. (required) 5388 :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set. 5389 :param str include_logos: When set to **true**, returns the logos associated with the brand. 5390 :return: BrandsResponse 5391 If the method is called asynchronously, 5392 returns the request thread. 5393 """ 5394 5395 all_params = ['account_id', 'exclude_distributor_brand', 'include_logos'] 5396 all_params.append('callback') 5397 all_params.append('_return_http_data_only') 5398 all_params.append('_preload_content') 5399 all_params.append('_request_timeout') 5400 5401 params = locals() 5402 for key, val in iteritems(params['kwargs']): 5403 if key not in all_params: 5404 raise TypeError( 5405 "Got an unexpected keyword argument '%s'" 5406 " to method list_brands" % key 5407 ) 5408 params[key] = val 5409 del params['kwargs'] 5410 # verify the required parameter 'account_id' is set 5411 if ('account_id' not in params) or (params['account_id'] is None): 5412 raise ValueError("Missing the required parameter `account_id` when calling `list_brands`") 5413 5414 5415 collection_formats = {} 5416 5417 resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json') 5418 path_params = {} 5419 if 'account_id' in params: 5420 path_params['accountId'] = params['account_id'] 5421 5422 query_params = {} 5423 if 'exclude_distributor_brand' in params: 5424 query_params['exclude_distributor_brand'] = params['exclude_distributor_brand'] 5425 if 'include_logos' in params: 5426 query_params['include_logos'] = params['include_logos'] 5427 5428 header_params = {} 5429 5430 form_params = [] 5431 local_var_files = {} 5432 5433 body_params = None 5434 # HTTP header `Accept` 5435 header_params['Accept'] = self.api_client.\ 5436 select_header_accept(['application/json']) 5437 5438 # Authentication setting 5439 auth_settings = [] 5440 5441 return self.api_client.call_api(resource_path, 'GET', 5442 path_params, 5443 query_params, 5444 header_params, 5445 body=body_params, 5446 post_params=form_params, 5447 files=local_var_files, 5448 response_type='BrandsResponse', 5449 auth_settings=auth_settings, 5450 callback=params.get('callback'), 5451 _return_http_data_only=params.get('_return_http_data_only'), 5452 _preload_content=params.get('_preload_content', True), 5453 _request_timeout=params.get('_request_timeout'), 5454 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)
5456 def list_custom_fields(self, account_id, **kwargs): 5457 """ 5458 Gets a list of custom fields associated with the account. 5459 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. 5460 This method makes a synchronous HTTP request by default. To make an 5461 asynchronous HTTP request, please define a `callback` function 5462 to be invoked when receiving the response. 5463 >>> def callback_function(response): 5464 >>> pprint(response) 5465 >>> 5466 >>> thread = api.list_custom_fields(account_id, callback=callback_function) 5467 5468 :param callback function: The callback function 5469 for asynchronous request. (optional) 5470 :param str account_id: The external account number (int) or account ID Guid. (required) 5471 :return: CustomFields 5472 If the method is called asynchronously, 5473 returns the request thread. 5474 """ 5475 kwargs['_return_http_data_only'] = True 5476 if kwargs.get('callback'): 5477 return self.list_custom_fields_with_http_info(account_id, **kwargs) 5478 else: 5479 (data) = self.list_custom_fields_with_http_info(account_id, **kwargs) 5480 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)
5482 def list_custom_fields_with_http_info(self, account_id, **kwargs): 5483 """ 5484 Gets a list of custom fields associated with the account. 5485 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. 5486 This method makes a synchronous HTTP request by default. To make an 5487 asynchronous HTTP request, please define a `callback` function 5488 to be invoked when receiving the response. 5489 >>> def callback_function(response): 5490 >>> pprint(response) 5491 >>> 5492 >>> thread = api.list_custom_fields_with_http_info(account_id, callback=callback_function) 5493 5494 :param callback function: The callback function 5495 for asynchronous request. (optional) 5496 :param str account_id: The external account number (int) or account ID Guid. (required) 5497 :return: CustomFields 5498 If the method is called asynchronously, 5499 returns the request thread. 5500 """ 5501 5502 all_params = ['account_id'] 5503 all_params.append('callback') 5504 all_params.append('_return_http_data_only') 5505 all_params.append('_preload_content') 5506 all_params.append('_request_timeout') 5507 5508 params = locals() 5509 for key, val in iteritems(params['kwargs']): 5510 if key not in all_params: 5511 raise TypeError( 5512 "Got an unexpected keyword argument '%s'" 5513 " to method list_custom_fields" % key 5514 ) 5515 params[key] = val 5516 del params['kwargs'] 5517 # verify the required parameter 'account_id' is set 5518 if ('account_id' not in params) or (params['account_id'] is None): 5519 raise ValueError("Missing the required parameter `account_id` when calling `list_custom_fields`") 5520 5521 5522 collection_formats = {} 5523 5524 resource_path = '/v2.1/accounts/{accountId}/custom_fields'.replace('{format}', 'json') 5525 path_params = {} 5526 if 'account_id' in params: 5527 path_params['accountId'] = params['account_id'] 5528 5529 query_params = {} 5530 5531 header_params = {} 5532 5533 form_params = [] 5534 local_var_files = {} 5535 5536 body_params = None 5537 # HTTP header `Accept` 5538 header_params['Accept'] = self.api_client.\ 5539 select_header_accept(['application/json']) 5540 5541 # Authentication setting 5542 auth_settings = [] 5543 5544 return self.api_client.call_api(resource_path, 'GET', 5545 path_params, 5546 query_params, 5547 header_params, 5548 body=body_params, 5549 post_params=form_params, 5550 files=local_var_files, 5551 response_type='CustomFields', 5552 auth_settings=auth_settings, 5553 callback=params.get('callback'), 5554 _return_http_data_only=params.get('_return_http_data_only'), 5555 _preload_content=params.get('_preload_content', True), 5556 _request_timeout=params.get('_request_timeout'), 5557 collection_formats=collection_formats)
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)
5559 def list_permissions(self, account_id, **kwargs): 5560 """ 5561 Gets a list of permission profiles. 5562 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. 5563 This method makes a synchronous HTTP request by default. To make an 5564 asynchronous HTTP request, please define a `callback` function 5565 to be invoked when receiving the response. 5566 >>> def callback_function(response): 5567 >>> pprint(response) 5568 >>> 5569 >>> thread = api.list_permissions(account_id, callback=callback_function) 5570 5571 :param callback function: The callback function 5572 for asynchronous request. (optional) 5573 :param str account_id: The external account number (int) or account ID Guid. (required) 5574 :param str include: 5575 :return: PermissionProfileInformation 5576 If the method is called asynchronously, 5577 returns the request thread. 5578 """ 5579 kwargs['_return_http_data_only'] = True 5580 if kwargs.get('callback'): 5581 return self.list_permissions_with_http_info(account_id, **kwargs) 5582 else: 5583 (data) = self.list_permissions_with_http_info(account_id, **kwargs) 5584 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)
5586 def list_permissions_with_http_info(self, account_id, **kwargs): 5587 """ 5588 Gets a list of permission profiles. 5589 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. 5590 This method makes a synchronous HTTP request by default. To make an 5591 asynchronous HTTP request, please define a `callback` function 5592 to be invoked when receiving the response. 5593 >>> def callback_function(response): 5594 >>> pprint(response) 5595 >>> 5596 >>> thread = api.list_permissions_with_http_info(account_id, callback=callback_function) 5597 5598 :param callback function: The callback function 5599 for asynchronous request. (optional) 5600 :param str account_id: The external account number (int) or account ID Guid. (required) 5601 :param str include: 5602 :return: PermissionProfileInformation 5603 If the method is called asynchronously, 5604 returns the request thread. 5605 """ 5606 5607 all_params = ['account_id', 'include'] 5608 all_params.append('callback') 5609 all_params.append('_return_http_data_only') 5610 all_params.append('_preload_content') 5611 all_params.append('_request_timeout') 5612 5613 params = locals() 5614 for key, val in iteritems(params['kwargs']): 5615 if key not in all_params: 5616 raise TypeError( 5617 "Got an unexpected keyword argument '%s'" 5618 " to method list_permissions" % key 5619 ) 5620 params[key] = val 5621 del params['kwargs'] 5622 # verify the required parameter 'account_id' is set 5623 if ('account_id' not in params) or (params['account_id'] is None): 5624 raise ValueError("Missing the required parameter `account_id` when calling `list_permissions`") 5625 5626 5627 collection_formats = {} 5628 5629 resource_path = '/v2.1/accounts/{accountId}/permission_profiles'.replace('{format}', 'json') 5630 path_params = {} 5631 if 'account_id' in params: 5632 path_params['accountId'] = params['account_id'] 5633 5634 query_params = {} 5635 if 'include' in params: 5636 query_params['include'] = params['include'] 5637 5638 header_params = {} 5639 5640 form_params = [] 5641 local_var_files = {} 5642 5643 body_params = None 5644 # HTTP header `Accept` 5645 header_params['Accept'] = self.api_client.\ 5646 select_header_accept(['application/json']) 5647 5648 # Authentication setting 5649 auth_settings = [] 5650 5651 return self.api_client.call_api(resource_path, 'GET', 5652 path_params, 5653 query_params, 5654 header_params, 5655 body=body_params, 5656 post_params=form_params, 5657 files=local_var_files, 5658 response_type='PermissionProfileInformation', 5659 auth_settings=auth_settings, 5660 callback=params.get('callback'), 5661 _return_http_data_only=params.get('_return_http_data_only'), 5662 _preload_content=params.get('_preload_content', True), 5663 _request_timeout=params.get('_request_timeout'), 5664 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)
5666 def list_recipient_names_by_email(self, account_id, **kwargs): 5667 """ 5668 Gets recipient names associated with an email address. 5669 Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string. 5670 This method makes a synchronous HTTP request by default. To make an 5671 asynchronous HTTP request, please define a `callback` function 5672 to be invoked when receiving the response. 5673 >>> def callback_function(response): 5674 >>> pprint(response) 5675 >>> 5676 >>> thread = api.list_recipient_names_by_email(account_id, callback=callback_function) 5677 5678 :param callback function: The callback function 5679 for asynchronous request. (optional) 5680 :param str account_id: The external account number (int) or account ID Guid. (required) 5681 :param str email: The email address for the user 5682 :return: RecipientNamesResponse 5683 If the method is called asynchronously, 5684 returns the request thread. 5685 """ 5686 kwargs['_return_http_data_only'] = True 5687 if kwargs.get('callback'): 5688 return self.list_recipient_names_by_email_with_http_info(account_id, **kwargs) 5689 else: 5690 (data) = self.list_recipient_names_by_email_with_http_info(account_id, **kwargs) 5691 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)
5693 def list_recipient_names_by_email_with_http_info(self, account_id, **kwargs): 5694 """ 5695 Gets recipient names associated with an email address. 5696 Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string. 5697 This method makes a synchronous HTTP request by default. To make an 5698 asynchronous HTTP request, please define a `callback` function 5699 to be invoked when receiving the response. 5700 >>> def callback_function(response): 5701 >>> pprint(response) 5702 >>> 5703 >>> thread = api.list_recipient_names_by_email_with_http_info(account_id, callback=callback_function) 5704 5705 :param callback function: The callback function 5706 for asynchronous request. (optional) 5707 :param str account_id: The external account number (int) or account ID Guid. (required) 5708 :param str email: The email address for the user 5709 :return: RecipientNamesResponse 5710 If the method is called asynchronously, 5711 returns the request thread. 5712 """ 5713 5714 all_params = ['account_id', 'email'] 5715 all_params.append('callback') 5716 all_params.append('_return_http_data_only') 5717 all_params.append('_preload_content') 5718 all_params.append('_request_timeout') 5719 5720 params = locals() 5721 for key, val in iteritems(params['kwargs']): 5722 if key not in all_params: 5723 raise TypeError( 5724 "Got an unexpected keyword argument '%s'" 5725 " to method list_recipient_names_by_email" % key 5726 ) 5727 params[key] = val 5728 del params['kwargs'] 5729 # verify the required parameter 'account_id' is set 5730 if ('account_id' not in params) or (params['account_id'] is None): 5731 raise ValueError("Missing the required parameter `account_id` when calling `list_recipient_names_by_email`") 5732 5733 5734 collection_formats = {} 5735 5736 resource_path = '/v2.1/accounts/{accountId}/recipient_names'.replace('{format}', 'json') 5737 path_params = {} 5738 if 'account_id' in params: 5739 path_params['accountId'] = params['account_id'] 5740 5741 query_params = {} 5742 if 'email' in params: 5743 query_params['email'] = params['email'] 5744 5745 header_params = {} 5746 5747 form_params = [] 5748 local_var_files = {} 5749 5750 body_params = None 5751 # HTTP header `Accept` 5752 header_params['Accept'] = self.api_client.\ 5753 select_header_accept(['application/json']) 5754 5755 # Authentication setting 5756 auth_settings = [] 5757 5758 return self.api_client.call_api(resource_path, 'GET', 5759 path_params, 5760 query_params, 5761 header_params, 5762 body=body_params, 5763 post_params=form_params, 5764 files=local_var_files, 5765 response_type='RecipientNamesResponse', 5766 auth_settings=auth_settings, 5767 callback=params.get('callback'), 5768 _return_http_data_only=params.get('_return_http_data_only'), 5769 _preload_content=params.get('_preload_content', True), 5770 _request_timeout=params.get('_request_timeout'), 5771 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)
5773 def list_settings(self, account_id, **kwargs): 5774 """ 5775 Gets account settings information. 5776 Retrieves the account settings information for the specified account. 5777 This method makes a synchronous HTTP request by default. To make an 5778 asynchronous HTTP request, please define a `callback` function 5779 to be invoked when receiving the response. 5780 >>> def callback_function(response): 5781 >>> pprint(response) 5782 >>> 5783 >>> thread = api.list_settings(account_id, callback=callback_function) 5784 5785 :param callback function: The callback function 5786 for asynchronous request. (optional) 5787 :param str account_id: The external account number (int) or account ID Guid. (required) 5788 :return: AccountSettingsInformation 5789 If the method is called asynchronously, 5790 returns the request thread. 5791 """ 5792 kwargs['_return_http_data_only'] = True 5793 if kwargs.get('callback'): 5794 return self.list_settings_with_http_info(account_id, **kwargs) 5795 else: 5796 (data) = self.list_settings_with_http_info(account_id, **kwargs) 5797 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)
5799 def list_settings_with_http_info(self, account_id, **kwargs): 5800 """ 5801 Gets account settings information. 5802 Retrieves the account settings information for the specified account. 5803 This method makes a synchronous HTTP request by default. To make an 5804 asynchronous HTTP request, please define a `callback` function 5805 to be invoked when receiving the response. 5806 >>> def callback_function(response): 5807 >>> pprint(response) 5808 >>> 5809 >>> thread = api.list_settings_with_http_info(account_id, callback=callback_function) 5810 5811 :param callback function: The callback function 5812 for asynchronous request. (optional) 5813 :param str account_id: The external account number (int) or account ID Guid. (required) 5814 :return: AccountSettingsInformation 5815 If the method is called asynchronously, 5816 returns the request thread. 5817 """ 5818 5819 all_params = ['account_id'] 5820 all_params.append('callback') 5821 all_params.append('_return_http_data_only') 5822 all_params.append('_preload_content') 5823 all_params.append('_request_timeout') 5824 5825 params = locals() 5826 for key, val in iteritems(params['kwargs']): 5827 if key not in all_params: 5828 raise TypeError( 5829 "Got an unexpected keyword argument '%s'" 5830 " to method list_settings" % key 5831 ) 5832 params[key] = val 5833 del params['kwargs'] 5834 # verify the required parameter 'account_id' is set 5835 if ('account_id' not in params) or (params['account_id'] is None): 5836 raise ValueError("Missing the required parameter `account_id` when calling `list_settings`") 5837 5838 5839 collection_formats = {} 5840 5841 resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json') 5842 path_params = {} 5843 if 'account_id' in params: 5844 path_params['accountId'] = params['account_id'] 5845 5846 query_params = {} 5847 5848 header_params = {} 5849 5850 form_params = [] 5851 local_var_files = {} 5852 5853 body_params = None 5854 # HTTP header `Accept` 5855 header_params['Accept'] = self.api_client.\ 5856 select_header_accept(['application/json']) 5857 5858 # Authentication setting 5859 auth_settings = [] 5860 5861 return self.api_client.call_api(resource_path, 'GET', 5862 path_params, 5863 query_params, 5864 header_params, 5865 body=body_params, 5866 post_params=form_params, 5867 files=local_var_files, 5868 response_type='AccountSettingsInformation', 5869 auth_settings=auth_settings, 5870 callback=params.get('callback'), 5871 _return_http_data_only=params.get('_return_http_data_only'), 5872 _preload_content=params.get('_preload_content', True), 5873 _request_timeout=params.get('_request_timeout'), 5874 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)
6011 def list_signature_providers(self, account_id, **kwargs): 6012 """ 6013 Returns Account available signature providers for specified account. 6014 Returns a list of signature providers that the specified account can use. 6015 This method makes a synchronous HTTP request by default. To make an 6016 asynchronous HTTP request, please define a `callback` function 6017 to be invoked when receiving the response. 6018 >>> def callback_function(response): 6019 >>> pprint(response) 6020 >>> 6021 >>> thread = api.list_signature_providers(account_id, callback=callback_function) 6022 6023 :param callback function: The callback function 6024 for asynchronous request. (optional) 6025 :param str account_id: The external account number (int) or account ID Guid. (required) 6026 :return: AccountSignatureProviders 6027 If the method is called asynchronously, 6028 returns the request thread. 6029 """ 6030 kwargs['_return_http_data_only'] = True 6031 if kwargs.get('callback'): 6032 return self.list_signature_providers_with_http_info(account_id, **kwargs) 6033 else: 6034 (data) = self.list_signature_providers_with_http_info(account_id, **kwargs) 6035 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)
6037 def list_signature_providers_with_http_info(self, account_id, **kwargs): 6038 """ 6039 Returns Account available signature providers for specified account. 6040 Returns a list of signature providers that the specified account can use. 6041 This method makes a synchronous HTTP request by default. To make an 6042 asynchronous HTTP request, please define a `callback` function 6043 to be invoked when receiving the response. 6044 >>> def callback_function(response): 6045 >>> pprint(response) 6046 >>> 6047 >>> thread = api.list_signature_providers_with_http_info(account_id, callback=callback_function) 6048 6049 :param callback function: The callback function 6050 for asynchronous request. (optional) 6051 :param str account_id: The external account number (int) or account ID Guid. (required) 6052 :return: AccountSignatureProviders 6053 If the method is called asynchronously, 6054 returns the request thread. 6055 """ 6056 6057 all_params = ['account_id'] 6058 all_params.append('callback') 6059 all_params.append('_return_http_data_only') 6060 all_params.append('_preload_content') 6061 all_params.append('_request_timeout') 6062 6063 params = locals() 6064 for key, val in iteritems(params['kwargs']): 6065 if key not in all_params: 6066 raise TypeError( 6067 "Got an unexpected keyword argument '%s'" 6068 " to method list_signature_providers" % key 6069 ) 6070 params[key] = val 6071 del params['kwargs'] 6072 # verify the required parameter 'account_id' is set 6073 if ('account_id' not in params) or (params['account_id'] is None): 6074 raise ValueError("Missing the required parameter `account_id` when calling `list_signature_providers`") 6075 6076 6077 collection_formats = {} 6078 6079 resource_path = '/v2.1/accounts/{accountId}/signatureProviders'.replace('{format}', 'json') 6080 path_params = {} 6081 if 'account_id' in params: 6082 path_params['accountId'] = params['account_id'] 6083 6084 query_params = {} 6085 6086 header_params = {} 6087 6088 form_params = [] 6089 local_var_files = {} 6090 6091 body_params = None 6092 # HTTP header `Accept` 6093 header_params['Accept'] = self.api_client.\ 6094 select_header_accept(['application/json']) 6095 6096 # Authentication setting 6097 auth_settings = [] 6098 6099 return self.api_client.call_api(resource_path, 'GET', 6100 path_params, 6101 query_params, 6102 header_params, 6103 body=body_params, 6104 post_params=form_params, 6105 files=local_var_files, 6106 response_type='AccountSignatureProviders', 6107 auth_settings=auth_settings, 6108 callback=params.get('callback'), 6109 _return_http_data_only=params.get('_return_http_data_only'), 6110 _preload_content=params.get('_preload_content', True), 6111 _request_timeout=params.get('_request_timeout'), 6112 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)
6114 def list_unsupported_file_types(self, account_id, **kwargs): 6115 """ 6116 Gets a list of unsupported file types. 6117 Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system. 6118 This method makes a synchronous HTTP request by default. To make an 6119 asynchronous HTTP request, please define a `callback` function 6120 to be invoked when receiving the response. 6121 >>> def callback_function(response): 6122 >>> pprint(response) 6123 >>> 6124 >>> thread = api.list_unsupported_file_types(account_id, callback=callback_function) 6125 6126 :param callback function: The callback function 6127 for asynchronous request. (optional) 6128 :param str account_id: The external account number (int) or account ID Guid. (required) 6129 :return: FileTypeList 6130 If the method is called asynchronously, 6131 returns the request thread. 6132 """ 6133 kwargs['_return_http_data_only'] = True 6134 if kwargs.get('callback'): 6135 return self.list_unsupported_file_types_with_http_info(account_id, **kwargs) 6136 else: 6137 (data) = self.list_unsupported_file_types_with_http_info(account_id, **kwargs) 6138 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)
6140 def list_unsupported_file_types_with_http_info(self, account_id, **kwargs): 6141 """ 6142 Gets a list of unsupported file types. 6143 Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system. 6144 This method makes a synchronous HTTP request by default. To make an 6145 asynchronous HTTP request, please define a `callback` function 6146 to be invoked when receiving the response. 6147 >>> def callback_function(response): 6148 >>> pprint(response) 6149 >>> 6150 >>> thread = api.list_unsupported_file_types_with_http_info(account_id, callback=callback_function) 6151 6152 :param callback function: The callback function 6153 for asynchronous request. (optional) 6154 :param str account_id: The external account number (int) or account ID Guid. (required) 6155 :return: FileTypeList 6156 If the method is called asynchronously, 6157 returns the request thread. 6158 """ 6159 6160 all_params = ['account_id'] 6161 all_params.append('callback') 6162 all_params.append('_return_http_data_only') 6163 all_params.append('_preload_content') 6164 all_params.append('_request_timeout') 6165 6166 params = locals() 6167 for key, val in iteritems(params['kwargs']): 6168 if key not in all_params: 6169 raise TypeError( 6170 "Got an unexpected keyword argument '%s'" 6171 " to method list_unsupported_file_types" % key 6172 ) 6173 params[key] = val 6174 del params['kwargs'] 6175 # verify the required parameter 'account_id' is set 6176 if ('account_id' not in params) or (params['account_id'] is None): 6177 raise ValueError("Missing the required parameter `account_id` when calling `list_unsupported_file_types`") 6178 6179 6180 collection_formats = {} 6181 6182 resource_path = '/v2.1/accounts/{accountId}/unsupported_file_types'.replace('{format}', 'json') 6183 path_params = {} 6184 if 'account_id' in params: 6185 path_params['accountId'] = params['account_id'] 6186 6187 query_params = {} 6188 6189 header_params = {} 6190 6191 form_params = [] 6192 local_var_files = {} 6193 6194 body_params = None 6195 # HTTP header `Accept` 6196 header_params['Accept'] = self.api_client.\ 6197 select_header_accept(['application/json']) 6198 6199 # Authentication setting 6200 auth_settings = [] 6201 6202 return self.api_client.call_api(resource_path, 'GET', 6203 path_params, 6204 query_params, 6205 header_params, 6206 body=body_params, 6207 post_params=form_params, 6208 files=local_var_files, 6209 response_type='FileTypeList', 6210 auth_settings=auth_settings, 6211 callback=params.get('callback'), 6212 _return_http_data_only=params.get('_return_http_data_only'), 6213 _preload_content=params.get('_preload_content', True), 6214 _request_timeout=params.get('_request_timeout'), 6215 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)
6217 def un_favorite_template(self, account_id, **kwargs): 6218 """ 6219 Unfavorite a template 6220 6221 This method makes a synchronous HTTP request by default. To make an 6222 asynchronous HTTP request, please define a `callback` function 6223 to be invoked when receiving the response. 6224 >>> def callback_function(response): 6225 >>> pprint(response) 6226 >>> 6227 >>> thread = api.un_favorite_template(account_id, callback=callback_function) 6228 6229 :param callback function: The callback function 6230 for asynchronous request. (optional) 6231 :param str account_id: The external account number (int) or account ID Guid. (required) 6232 :param FavoriteTemplatesInfo favorite_templates_info: 6233 :return: FavoriteTemplatesInfo 6234 If the method is called asynchronously, 6235 returns the request thread. 6236 """ 6237 kwargs['_return_http_data_only'] = True 6238 if kwargs.get('callback'): 6239 return self.un_favorite_template_with_http_info(account_id, **kwargs) 6240 else: 6241 (data) = self.un_favorite_template_with_http_info(account_id, **kwargs) 6242 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)
6244 def un_favorite_template_with_http_info(self, account_id, **kwargs): 6245 """ 6246 Unfavorite a template 6247 6248 This method makes a synchronous HTTP request by default. To make an 6249 asynchronous HTTP request, please define a `callback` function 6250 to be invoked when receiving the response. 6251 >>> def callback_function(response): 6252 >>> pprint(response) 6253 >>> 6254 >>> thread = api.un_favorite_template_with_http_info(account_id, callback=callback_function) 6255 6256 :param callback function: The callback function 6257 for asynchronous request. (optional) 6258 :param str account_id: The external account number (int) or account ID Guid. (required) 6259 :param FavoriteTemplatesInfo favorite_templates_info: 6260 :return: FavoriteTemplatesInfo 6261 If the method is called asynchronously, 6262 returns the request thread. 6263 """ 6264 6265 all_params = ['account_id', 'favorite_templates_info'] 6266 all_params.append('callback') 6267 all_params.append('_return_http_data_only') 6268 all_params.append('_preload_content') 6269 all_params.append('_request_timeout') 6270 6271 params = locals() 6272 for key, val in iteritems(params['kwargs']): 6273 if key not in all_params: 6274 raise TypeError( 6275 "Got an unexpected keyword argument '%s'" 6276 " to method un_favorite_template" % key 6277 ) 6278 params[key] = val 6279 del params['kwargs'] 6280 # verify the required parameter 'account_id' is set 6281 if ('account_id' not in params) or (params['account_id'] is None): 6282 raise ValueError("Missing the required parameter `account_id` when calling `un_favorite_template`") 6283 6284 6285 collection_formats = {} 6286 6287 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 6288 path_params = {} 6289 if 'account_id' in params: 6290 path_params['accountId'] = params['account_id'] 6291 6292 query_params = {} 6293 6294 header_params = {} 6295 6296 form_params = [] 6297 local_var_files = {} 6298 6299 body_params = None 6300 if 'favorite_templates_info' in params: 6301 body_params = params['favorite_templates_info'] 6302 # HTTP header `Accept` 6303 header_params['Accept'] = self.api_client.\ 6304 select_header_accept(['application/json']) 6305 6306 # Authentication setting 6307 auth_settings = [] 6308 6309 return self.api_client.call_api(resource_path, 'DELETE', 6310 path_params, 6311 query_params, 6312 header_params, 6313 body=body_params, 6314 post_params=form_params, 6315 files=local_var_files, 6316 response_type='FavoriteTemplatesInfo', 6317 auth_settings=auth_settings, 6318 callback=params.get('callback'), 6319 _return_http_data_only=params.get('_return_http_data_only'), 6320 _preload_content=params.get('_preload_content', True), 6321 _request_timeout=params.get('_request_timeout'), 6322 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)
6324 def update_account_signature(self, account_id, **kwargs): 6325 """ 6326 Updates a account signature. 6327 6328 This method makes a synchronous HTTP request by default. To make an 6329 asynchronous HTTP request, please define a `callback` function 6330 to be invoked when receiving the response. 6331 >>> def callback_function(response): 6332 >>> pprint(response) 6333 >>> 6334 >>> thread = api.update_account_signature(account_id, callback=callback_function) 6335 6336 :param callback function: The callback function 6337 for asynchronous request. (optional) 6338 :param str account_id: The external account number (int) or account ID Guid. (required) 6339 :param AccountSignaturesInformation account_signatures_information: 6340 :return: AccountSignaturesInformation 6341 If the method is called asynchronously, 6342 returns the request thread. 6343 """ 6344 kwargs['_return_http_data_only'] = True 6345 if kwargs.get('callback'): 6346 return self.update_account_signature_with_http_info(account_id, **kwargs) 6347 else: 6348 (data) = self.update_account_signature_with_http_info(account_id, **kwargs) 6349 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)
6351 def update_account_signature_with_http_info(self, account_id, **kwargs): 6352 """ 6353 Updates a account signature. 6354 6355 This method makes a synchronous HTTP request by default. To make an 6356 asynchronous HTTP request, please define a `callback` function 6357 to be invoked when receiving the response. 6358 >>> def callback_function(response): 6359 >>> pprint(response) 6360 >>> 6361 >>> thread = api.update_account_signature_with_http_info(account_id, callback=callback_function) 6362 6363 :param callback function: The callback function 6364 for asynchronous request. (optional) 6365 :param str account_id: The external account number (int) or account ID Guid. (required) 6366 :param AccountSignaturesInformation account_signatures_information: 6367 :return: AccountSignaturesInformation 6368 If the method is called asynchronously, 6369 returns the request thread. 6370 """ 6371 6372 all_params = ['account_id', 'account_signatures_information'] 6373 all_params.append('callback') 6374 all_params.append('_return_http_data_only') 6375 all_params.append('_preload_content') 6376 all_params.append('_request_timeout') 6377 6378 params = locals() 6379 for key, val in iteritems(params['kwargs']): 6380 if key not in all_params: 6381 raise TypeError( 6382 "Got an unexpected keyword argument '%s'" 6383 " to method update_account_signature" % key 6384 ) 6385 params[key] = val 6386 del params['kwargs'] 6387 # verify the required parameter 'account_id' is set 6388 if ('account_id' not in params) or (params['account_id'] is None): 6389 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature`") 6390 6391 6392 collection_formats = {} 6393 6394 resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json') 6395 path_params = {} 6396 if 'account_id' in params: 6397 path_params['accountId'] = params['account_id'] 6398 6399 query_params = {} 6400 6401 header_params = {} 6402 6403 form_params = [] 6404 local_var_files = {} 6405 6406 body_params = None 6407 if 'account_signatures_information' in params: 6408 body_params = params['account_signatures_information'] 6409 # HTTP header `Accept` 6410 header_params['Accept'] = self.api_client.\ 6411 select_header_accept(['application/json']) 6412 6413 # Authentication setting 6414 auth_settings = [] 6415 6416 return self.api_client.call_api(resource_path, 'PUT', 6417 path_params, 6418 query_params, 6419 header_params, 6420 body=body_params, 6421 post_params=form_params, 6422 files=local_var_files, 6423 response_type='AccountSignaturesInformation', 6424 auth_settings=auth_settings, 6425 callback=params.get('callback'), 6426 _return_http_data_only=params.get('_return_http_data_only'), 6427 _preload_content=params.get('_preload_content', True), 6428 _request_timeout=params.get('_request_timeout'), 6429 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)
6431 def update_account_signature_by_id(self, account_id, signature_id, **kwargs): 6432 """ 6433 Updates a account signature. 6434 6435 This method makes a synchronous HTTP request by default. To make an 6436 asynchronous HTTP request, please define a `callback` function 6437 to be invoked when receiving the response. 6438 >>> def callback_function(response): 6439 >>> pprint(response) 6440 >>> 6441 >>> thread = api.update_account_signature_by_id(account_id, signature_id, callback=callback_function) 6442 6443 :param callback function: The callback function 6444 for asynchronous request. (optional) 6445 :param str account_id: The external account number (int) or account ID Guid. (required) 6446 :param str signature_id: The ID of the signature being accessed. (required) 6447 :param str close_existing_signature: 6448 :param AccountSignatureDefinition account_signature_definition: 6449 :return: AccountSignature 6450 If the method is called asynchronously, 6451 returns the request thread. 6452 """ 6453 kwargs['_return_http_data_only'] = True 6454 if kwargs.get('callback'): 6455 return self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs) 6456 else: 6457 (data) = self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs) 6458 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)
6460 def update_account_signature_by_id_with_http_info(self, account_id, signature_id, **kwargs): 6461 """ 6462 Updates a account signature. 6463 6464 This method makes a synchronous HTTP request by default. To make an 6465 asynchronous HTTP request, please define a `callback` function 6466 to be invoked when receiving the response. 6467 >>> def callback_function(response): 6468 >>> pprint(response) 6469 >>> 6470 >>> thread = api.update_account_signature_by_id_with_http_info(account_id, signature_id, callback=callback_function) 6471 6472 :param callback function: The callback function 6473 for asynchronous request. (optional) 6474 :param str account_id: The external account number (int) or account ID Guid. (required) 6475 :param str signature_id: The ID of the signature being accessed. (required) 6476 :param str close_existing_signature: 6477 :param AccountSignatureDefinition account_signature_definition: 6478 :return: AccountSignature 6479 If the method is called asynchronously, 6480 returns the request thread. 6481 """ 6482 6483 all_params = ['account_id', 'signature_id', 'close_existing_signature', 'account_signature_definition'] 6484 all_params.append('callback') 6485 all_params.append('_return_http_data_only') 6486 all_params.append('_preload_content') 6487 all_params.append('_request_timeout') 6488 6489 params = locals() 6490 for key, val in iteritems(params['kwargs']): 6491 if key not in all_params: 6492 raise TypeError( 6493 "Got an unexpected keyword argument '%s'" 6494 " to method update_account_signature_by_id" % key 6495 ) 6496 params[key] = val 6497 del params['kwargs'] 6498 # verify the required parameter 'account_id' is set 6499 if ('account_id' not in params) or (params['account_id'] is None): 6500 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_by_id`") 6501 # verify the required parameter 'signature_id' is set 6502 if ('signature_id' not in params) or (params['signature_id'] is None): 6503 raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_by_id`") 6504 6505 6506 collection_formats = {} 6507 6508 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 6509 path_params = {} 6510 if 'account_id' in params: 6511 path_params['accountId'] = params['account_id'] 6512 if 'signature_id' in params: 6513 path_params['signatureId'] = params['signature_id'] 6514 6515 query_params = {} 6516 if 'close_existing_signature' in params: 6517 query_params['close_existing_signature'] = params['close_existing_signature'] 6518 6519 header_params = {} 6520 6521 form_params = [] 6522 local_var_files = {} 6523 6524 body_params = None 6525 if 'account_signature_definition' in params: 6526 body_params = params['account_signature_definition'] 6527 # HTTP header `Accept` 6528 header_params['Accept'] = self.api_client.\ 6529 select_header_accept(['application/json']) 6530 6531 # Authentication setting 6532 auth_settings = [] 6533 6534 return self.api_client.call_api(resource_path, 'PUT', 6535 path_params, 6536 query_params, 6537 header_params, 6538 body=body_params, 6539 post_params=form_params, 6540 files=local_var_files, 6541 response_type='AccountSignature', 6542 auth_settings=auth_settings, 6543 callback=params.get('callback'), 6544 _return_http_data_only=params.get('_return_http_data_only'), 6545 _preload_content=params.get('_preload_content', True), 6546 _request_timeout=params.get('_request_timeout'), 6547 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)
6549 def update_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 6550 """ 6551 Sets a signature, initials, or stamps image. 6552 6553 This method makes a synchronous HTTP request by default. To make an 6554 asynchronous HTTP request, please define a `callback` function 6555 to be invoked when receiving the response. 6556 >>> def callback_function(response): 6557 >>> pprint(response) 6558 >>> 6559 >>> thread = api.update_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 6560 6561 :param callback function: The callback function 6562 for asynchronous request. (optional) 6563 :param str account_id: The external account number (int) or account ID Guid. (required) 6564 :param str image_type: One of **signature_image** or **initials_image**. (required) 6565 :param str signature_id: The ID of the signature being accessed. (required) 6566 :param str transparent_png: 6567 :return: AccountSignature 6568 If the method is called asynchronously, 6569 returns the request thread. 6570 """ 6571 kwargs['_return_http_data_only'] = True 6572 if kwargs.get('callback'): 6573 return self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 6574 else: 6575 (data) = self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 6576 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)
6578 def update_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 6579 """ 6580 Sets a signature, initials, or stamps image. 6581 6582 This method makes a synchronous HTTP request by default. To make an 6583 asynchronous HTTP request, please define a `callback` function 6584 to be invoked when receiving the response. 6585 >>> def callback_function(response): 6586 >>> pprint(response) 6587 >>> 6588 >>> thread = api.update_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 6589 6590 :param callback function: The callback function 6591 for asynchronous request. (optional) 6592 :param str account_id: The external account number (int) or account ID Guid. (required) 6593 :param str image_type: One of **signature_image** or **initials_image**. (required) 6594 :param str signature_id: The ID of the signature being accessed. (required) 6595 :param str transparent_png: 6596 :return: AccountSignature 6597 If the method is called asynchronously, 6598 returns the request thread. 6599 """ 6600 6601 all_params = ['account_id', 'image_type', 'signature_id', 'transparent_png'] 6602 all_params.append('callback') 6603 all_params.append('_return_http_data_only') 6604 all_params.append('_preload_content') 6605 all_params.append('_request_timeout') 6606 6607 params = locals() 6608 for key, val in iteritems(params['kwargs']): 6609 if key not in all_params: 6610 raise TypeError( 6611 "Got an unexpected keyword argument '%s'" 6612 " to method update_account_signature_image" % key 6613 ) 6614 params[key] = val 6615 del params['kwargs'] 6616 # verify the required parameter 'account_id' is set 6617 if ('account_id' not in params) or (params['account_id'] is None): 6618 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_image`") 6619 # verify the required parameter 'image_type' is set 6620 if ('image_type' not in params) or (params['image_type'] is None): 6621 raise ValueError("Missing the required parameter `image_type` when calling `update_account_signature_image`") 6622 # verify the required parameter 'signature_id' is set 6623 if ('signature_id' not in params) or (params['signature_id'] is None): 6624 raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_image`") 6625 6626 6627 collection_formats = {} 6628 6629 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 6630 path_params = {} 6631 if 'account_id' in params: 6632 path_params['accountId'] = params['account_id'] 6633 if 'image_type' in params: 6634 path_params['imageType'] = params['image_type'] 6635 if 'signature_id' in params: 6636 path_params['signatureId'] = params['signature_id'] 6637 6638 query_params = {} 6639 if 'transparent_png' in params: 6640 query_params['transparent_png'] = params['transparent_png'] 6641 6642 header_params = {} 6643 6644 form_params = [] 6645 local_var_files = {} 6646 6647 body_params = None 6648 # HTTP header `Accept` 6649 header_params['Accept'] = self.api_client.\ 6650 select_header_accept(['application/json']) 6651 6652 # HTTP header `Content-Type` 6653 header_params['Content-Type'] = self.api_client.\ 6654 select_header_content_type(['image/gif']) 6655 6656 # Authentication setting 6657 auth_settings = [] 6658 6659 return self.api_client.call_api(resource_path, 'PUT', 6660 path_params, 6661 query_params, 6662 header_params, 6663 body=body_params, 6664 post_params=form_params, 6665 files=local_var_files, 6666 response_type='AccountSignature', 6667 auth_settings=auth_settings, 6668 callback=params.get('callback'), 6669 _return_http_data_only=params.get('_return_http_data_only'), 6670 _preload_content=params.get('_preload_content', True), 6671 _request_timeout=params.get('_request_timeout'), 6672 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)
6674 def update_account_tab_settings(self, account_id, **kwargs): 6675 """ 6676 Modifies tab settings for specified account 6677 This method modifies the tab types and tab functionality that is enabled for an account. 6678 This method makes a synchronous HTTP request by default. To make an 6679 asynchronous HTTP request, please define a `callback` function 6680 to be invoked when receiving the response. 6681 >>> def callback_function(response): 6682 >>> pprint(response) 6683 >>> 6684 >>> thread = api.update_account_tab_settings(account_id, callback=callback_function) 6685 6686 :param callback function: The callback function 6687 for asynchronous request. (optional) 6688 :param str account_id: The external account number (int) or account ID Guid. (required) 6689 :param TabAccountSettings tab_account_settings: 6690 :return: TabAccountSettings 6691 If the method is called asynchronously, 6692 returns the request thread. 6693 """ 6694 kwargs['_return_http_data_only'] = True 6695 if kwargs.get('callback'): 6696 return self.update_account_tab_settings_with_http_info(account_id, **kwargs) 6697 else: 6698 (data) = self.update_account_tab_settings_with_http_info(account_id, **kwargs) 6699 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)
6701 def update_account_tab_settings_with_http_info(self, account_id, **kwargs): 6702 """ 6703 Modifies tab settings for specified account 6704 This method modifies the tab types and tab functionality that is enabled for an account. 6705 This method makes a synchronous HTTP request by default. To make an 6706 asynchronous HTTP request, please define a `callback` function 6707 to be invoked when receiving the response. 6708 >>> def callback_function(response): 6709 >>> pprint(response) 6710 >>> 6711 >>> thread = api.update_account_tab_settings_with_http_info(account_id, callback=callback_function) 6712 6713 :param callback function: The callback function 6714 for asynchronous request. (optional) 6715 :param str account_id: The external account number (int) or account ID Guid. (required) 6716 :param TabAccountSettings tab_account_settings: 6717 :return: TabAccountSettings 6718 If the method is called asynchronously, 6719 returns the request thread. 6720 """ 6721 6722 all_params = ['account_id', 'tab_account_settings'] 6723 all_params.append('callback') 6724 all_params.append('_return_http_data_only') 6725 all_params.append('_preload_content') 6726 all_params.append('_request_timeout') 6727 6728 params = locals() 6729 for key, val in iteritems(params['kwargs']): 6730 if key not in all_params: 6731 raise TypeError( 6732 "Got an unexpected keyword argument '%s'" 6733 " to method update_account_tab_settings" % key 6734 ) 6735 params[key] = val 6736 del params['kwargs'] 6737 # verify the required parameter 'account_id' is set 6738 if ('account_id' not in params) or (params['account_id'] is None): 6739 raise ValueError("Missing the required parameter `account_id` when calling `update_account_tab_settings`") 6740 6741 6742 collection_formats = {} 6743 6744 resource_path = '/v2.1/accounts/{accountId}/settings/tabs'.replace('{format}', 'json') 6745 path_params = {} 6746 if 'account_id' in params: 6747 path_params['accountId'] = params['account_id'] 6748 6749 query_params = {} 6750 6751 header_params = {} 6752 6753 form_params = [] 6754 local_var_files = {} 6755 6756 body_params = None 6757 if 'tab_account_settings' in params: 6758 body_params = params['tab_account_settings'] 6759 # HTTP header `Accept` 6760 header_params['Accept'] = self.api_client.\ 6761 select_header_accept(['application/json']) 6762 6763 # Authentication setting 6764 auth_settings = [] 6765 6766 return self.api_client.call_api(resource_path, 'PUT', 6767 path_params, 6768 query_params, 6769 header_params, 6770 body=body_params, 6771 post_params=form_params, 6772 files=local_var_files, 6773 response_type='TabAccountSettings', 6774 auth_settings=auth_settings, 6775 callback=params.get('callback'), 6776 _return_http_data_only=params.get('_return_http_data_only'), 6777 _preload_content=params.get('_preload_content', True), 6778 _request_timeout=params.get('_request_timeout'), 6779 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)
6781 def update_brand(self, account_id, brand_id, **kwargs): 6782 """ 6783 Updates an existing brand. 6784 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**). 6785 This method makes a synchronous HTTP request by default. To make an 6786 asynchronous HTTP request, please define a `callback` function 6787 to be invoked when receiving the response. 6788 >>> def callback_function(response): 6789 >>> pprint(response) 6790 >>> 6791 >>> thread = api.update_brand(account_id, brand_id, callback=callback_function) 6792 6793 :param callback function: The callback function 6794 for asynchronous request. (optional) 6795 :param str account_id: The external account number (int) or account ID Guid. (required) 6796 :param str brand_id: The unique identifier of a brand. (required) 6797 :param str replace_brand: 6798 :param Brand brand: 6799 :return: Brand 6800 If the method is called asynchronously, 6801 returns the request thread. 6802 """ 6803 kwargs['_return_http_data_only'] = True 6804 if kwargs.get('callback'): 6805 return self.update_brand_with_http_info(account_id, brand_id, **kwargs) 6806 else: 6807 (data) = self.update_brand_with_http_info(account_id, brand_id, **kwargs) 6808 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)
6810 def update_brand_with_http_info(self, account_id, brand_id, **kwargs): 6811 """ 6812 Updates an existing brand. 6813 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**). 6814 This method makes a synchronous HTTP request by default. To make an 6815 asynchronous HTTP request, please define a `callback` function 6816 to be invoked when receiving the response. 6817 >>> def callback_function(response): 6818 >>> pprint(response) 6819 >>> 6820 >>> thread = api.update_brand_with_http_info(account_id, brand_id, callback=callback_function) 6821 6822 :param callback function: The callback function 6823 for asynchronous request. (optional) 6824 :param str account_id: The external account number (int) or account ID Guid. (required) 6825 :param str brand_id: The unique identifier of a brand. (required) 6826 :param str replace_brand: 6827 :param Brand brand: 6828 :return: Brand 6829 If the method is called asynchronously, 6830 returns the request thread. 6831 """ 6832 6833 all_params = ['account_id', 'brand_id', 'replace_brand', 'brand'] 6834 all_params.append('callback') 6835 all_params.append('_return_http_data_only') 6836 all_params.append('_preload_content') 6837 all_params.append('_request_timeout') 6838 6839 params = locals() 6840 for key, val in iteritems(params['kwargs']): 6841 if key not in all_params: 6842 raise TypeError( 6843 "Got an unexpected keyword argument '%s'" 6844 " to method update_brand" % key 6845 ) 6846 params[key] = val 6847 del params['kwargs'] 6848 # verify the required parameter 'account_id' is set 6849 if ('account_id' not in params) or (params['account_id'] is None): 6850 raise ValueError("Missing the required parameter `account_id` when calling `update_brand`") 6851 # verify the required parameter 'brand_id' is set 6852 if ('brand_id' not in params) or (params['brand_id'] is None): 6853 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand`") 6854 6855 6856 collection_formats = {} 6857 6858 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 6859 path_params = {} 6860 if 'account_id' in params: 6861 path_params['accountId'] = params['account_id'] 6862 if 'brand_id' in params: 6863 path_params['brandId'] = params['brand_id'] 6864 6865 query_params = {} 6866 if 'replace_brand' in params: 6867 query_params['replace_brand'] = params['replace_brand'] 6868 6869 header_params = {} 6870 6871 form_params = [] 6872 local_var_files = {} 6873 6874 body_params = None 6875 if 'brand' in params: 6876 body_params = params['brand'] 6877 # HTTP header `Accept` 6878 header_params['Accept'] = self.api_client.\ 6879 select_header_accept(['application/json']) 6880 6881 # Authentication setting 6882 auth_settings = [] 6883 6884 return self.api_client.call_api(resource_path, 'PUT', 6885 path_params, 6886 query_params, 6887 header_params, 6888 body=body_params, 6889 post_params=form_params, 6890 files=local_var_files, 6891 response_type='Brand', 6892 auth_settings=auth_settings, 6893 callback=params.get('callback'), 6894 _return_http_data_only=params.get('_return_http_data_only'), 6895 _preload_content=params.get('_preload_content', True), 6896 _request_timeout=params.get('_request_timeout'), 6897 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)
6899 def update_brand_logo_by_type(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs): 6900 """ 6901 Put one branding logo. 6902 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**). 6903 This method makes a synchronous HTTP request by default. To make an 6904 asynchronous HTTP request, please define a `callback` function 6905 to be invoked when receiving the response. 6906 >>> def callback_function(response): 6907 >>> pprint(response) 6908 >>> 6909 >>> thread = api.update_brand_logo_by_type(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function) 6910 6911 :param callback function: The callback function 6912 for asynchronous request. (optional) 6913 :param str account_id: The external account number (int) or account ID GUID. (required) 6914 :param str brand_id: The ID of the brand. (required) 6915 :param str logo_type: The type of logo. Valid values are: - `primary` - `secondary` - `email` (required) 6916 :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) 6917 :return: None 6918 If the method is called asynchronously, 6919 returns the request thread. 6920 """ 6921 kwargs['_return_http_data_only'] = True 6922 if kwargs.get('callback'): 6923 return self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs) 6924 else: 6925 (data) = self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs) 6926 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)
6928 def update_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs): 6929 """ 6930 Put one branding logo. 6931 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**). 6932 This method makes a synchronous HTTP request by default. To make an 6933 asynchronous HTTP request, please define a `callback` function 6934 to be invoked when receiving the response. 6935 >>> def callback_function(response): 6936 >>> pprint(response) 6937 >>> 6938 >>> thread = api.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function) 6939 6940 :param callback function: The callback function 6941 for asynchronous request. (optional) 6942 :param str account_id: The external account number (int) or account ID GUID. (required) 6943 :param str brand_id: The ID of the brand. (required) 6944 :param str logo_type: The type of logo. Valid values are: - `primary` - `secondary` - `email` (required) 6945 :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) 6946 :return: None 6947 If the method is called asynchronously, 6948 returns the request thread. 6949 """ 6950 6951 all_params = ['account_id', 'brand_id', 'logo_type', 'logo_file_bytes'] 6952 all_params.append('callback') 6953 all_params.append('_return_http_data_only') 6954 all_params.append('_preload_content') 6955 all_params.append('_request_timeout') 6956 6957 params = locals() 6958 for key, val in iteritems(params['kwargs']): 6959 if key not in all_params: 6960 raise TypeError( 6961 "Got an unexpected keyword argument '%s'" 6962 " to method update_brand_logo_by_type" % key 6963 ) 6964 params[key] = val 6965 del params['kwargs'] 6966 # verify the required parameter 'account_id' is set 6967 if ('account_id' not in params) or (params['account_id'] is None): 6968 raise ValueError("Missing the required parameter `account_id` when calling `update_brand_logo_by_type`") 6969 # verify the required parameter 'brand_id' is set 6970 if ('brand_id' not in params) or (params['brand_id'] is None): 6971 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_logo_by_type`") 6972 # verify the required parameter 'logo_type' is set 6973 if ('logo_type' not in params) or (params['logo_type'] is None): 6974 raise ValueError("Missing the required parameter `logo_type` when calling `update_brand_logo_by_type`") 6975 # verify the required parameter 'logo_file_bytes' is set 6976 if ('logo_file_bytes' not in params) or (params['logo_file_bytes'] is None): 6977 raise ValueError("Missing the required parameter `logo_file_bytes` when calling `update_brand_logo_by_type`") 6978 6979 6980 collection_formats = {} 6981 6982 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 6983 path_params = {} 6984 if 'account_id' in params: 6985 path_params['accountId'] = params['account_id'] 6986 if 'brand_id' in params: 6987 path_params['brandId'] = params['brand_id'] 6988 if 'logo_type' in params: 6989 path_params['logoType'] = params['logo_type'] 6990 6991 query_params = {} 6992 6993 header_params = {} 6994 6995 form_params = [] 6996 local_var_files = {} 6997 6998 body_params = None 6999 if 'logo_file_bytes' in params: 7000 body_params = params['logo_file_bytes'] 7001 # HTTP header `Accept` 7002 header_params['Accept'] = self.api_client.\ 7003 select_header_accept(['application/json']) 7004 7005 # HTTP header `Content-Type` 7006 header_params['Content-Type'] = self.api_client.\ 7007 select_header_content_type(['image/png']) 7008 7009 # Authentication setting 7010 auth_settings = [] 7011 7012 return self.api_client.call_api(resource_path, 'PUT', 7013 path_params, 7014 query_params, 7015 header_params, 7016 body=body_params, 7017 post_params=form_params, 7018 files=local_var_files, 7019 response_type=None, 7020 auth_settings=auth_settings, 7021 callback=params.get('callback'), 7022 _return_http_data_only=params.get('_return_http_data_only'), 7023 _preload_content=params.get('_preload_content', True), 7024 _request_timeout=params.get('_request_timeout'), 7025 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)
7027 def update_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, file_xml, **kwargs): 7028 """ 7029 Uploads a branding resource file. 7030 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. 7031 This method makes a synchronous HTTP request by default. To make an 7032 asynchronous HTTP request, please define a `callback` function 7033 to be invoked when receiving the response. 7034 >>> def callback_function(response): 7035 >>> pprint(response) 7036 >>> 7037 >>> thread = api.update_brand_resources_by_content_type(account_id, brand_id, resource_content_type, file_xml, callback=callback_function) 7038 7039 :param callback function: The callback function 7040 for asynchronous request. (optional) 7041 :param str account_id: The external account number (int) or account ID GUID. (required) 7042 :param str brand_id: The ID of the brand. (required) 7043 :param str resource_content_type: The type of brand resource file that you are updating. Valid values are: - `sending` - `signing` - `email` - `signing_captive` (required) 7044 :param file file_xml: Brand resource XML file. (required) 7045 :return: BrandResources 7046 If the method is called asynchronously, 7047 returns the request thread. 7048 """ 7049 kwargs['_return_http_data_only'] = True 7050 if kwargs.get('callback'): 7051 return self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs) 7052 else: 7053 (data) = self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs) 7054 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)
7056 def update_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, file_xml, **kwargs): 7057 """ 7058 Uploads a branding resource file. 7059 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. 7060 This method makes a synchronous HTTP request by default. To make an 7061 asynchronous HTTP request, please define a `callback` function 7062 to be invoked when receiving the response. 7063 >>> def callback_function(response): 7064 >>> pprint(response) 7065 >>> 7066 >>> thread = api.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, callback=callback_function) 7067 7068 :param callback function: The callback function 7069 for asynchronous request. (optional) 7070 :param str account_id: The external account number (int) or account ID GUID. (required) 7071 :param str brand_id: The ID of the brand. (required) 7072 :param str resource_content_type: The type of brand resource file that you are updating. Valid values are: - `sending` - `signing` - `email` - `signing_captive` (required) 7073 :param file file_xml: Brand resource XML file. (required) 7074 :return: BrandResources 7075 If the method is called asynchronously, 7076 returns the request thread. 7077 """ 7078 7079 all_params = ['account_id', 'brand_id', 'resource_content_type', 'file_xml'] 7080 all_params.append('callback') 7081 all_params.append('_return_http_data_only') 7082 all_params.append('_preload_content') 7083 all_params.append('_request_timeout') 7084 7085 params = locals() 7086 for key, val in iteritems(params['kwargs']): 7087 if key not in all_params: 7088 raise TypeError( 7089 "Got an unexpected keyword argument '%s'" 7090 " to method update_brand_resources_by_content_type" % key 7091 ) 7092 params[key] = val 7093 del params['kwargs'] 7094 # verify the required parameter 'account_id' is set 7095 if ('account_id' not in params) or (params['account_id'] is None): 7096 raise ValueError("Missing the required parameter `account_id` when calling `update_brand_resources_by_content_type`") 7097 # verify the required parameter 'brand_id' is set 7098 if ('brand_id' not in params) or (params['brand_id'] is None): 7099 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_resources_by_content_type`") 7100 # verify the required parameter 'resource_content_type' is set 7101 if ('resource_content_type' not in params) or (params['resource_content_type'] is None): 7102 raise ValueError("Missing the required parameter `resource_content_type` when calling `update_brand_resources_by_content_type`") 7103 # verify the required parameter 'file_xml' is set 7104 if ('file_xml' not in params) or (params['file_xml'] is None): 7105 raise ValueError("Missing the required parameter `file_xml` when calling `update_brand_resources_by_content_type`") 7106 7107 7108 collection_formats = {} 7109 7110 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources/{resourceContentType}'.replace('{format}', 'json') 7111 path_params = {} 7112 if 'account_id' in params: 7113 path_params['accountId'] = params['account_id'] 7114 if 'brand_id' in params: 7115 path_params['brandId'] = params['brand_id'] 7116 if 'resource_content_type' in params: 7117 path_params['resourceContentType'] = params['resource_content_type'] 7118 7119 query_params = {} 7120 7121 header_params = {} 7122 7123 form_params = [] 7124 local_var_files = {} 7125 if 'file_xml' in params: 7126 local_var_files['file.xml'] = params['file_xml'] 7127 7128 body_params = None 7129 # HTTP header `Accept` 7130 header_params['Accept'] = self.api_client.\ 7131 select_header_accept(['application/json']) 7132 7133 # HTTP header `Content-Type` 7134 header_params['Content-Type'] = self.api_client.\ 7135 select_header_content_type(['multipart/form-data']) 7136 7137 # Authentication setting 7138 auth_settings = [] 7139 7140 return self.api_client.call_api(resource_path, 'PUT', 7141 path_params, 7142 query_params, 7143 header_params, 7144 body=body_params, 7145 post_params=form_params, 7146 files=local_var_files, 7147 response_type='BrandResources', 7148 auth_settings=auth_settings, 7149 callback=params.get('callback'), 7150 _return_http_data_only=params.get('_return_http_data_only'), 7151 _preload_content=params.get('_preload_content', True), 7152 _request_timeout=params.get('_request_timeout'), 7153 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)
7155 def update_consumer_disclosure(self, account_id, lang_code, **kwargs): 7156 """ 7157 Update Consumer Disclosure. 7158 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. 7159 This method makes a synchronous HTTP request by default. To make an 7160 asynchronous HTTP request, please define a `callback` function 7161 to be invoked when receiving the response. 7162 >>> def callback_function(response): 7163 >>> pprint(response) 7164 >>> 7165 >>> thread = api.update_consumer_disclosure(account_id, lang_code, callback=callback_function) 7166 7167 :param callback function: The callback function 7168 for asynchronous request. (optional) 7169 :param str account_id: The external account number (int) or account ID Guid. (required) 7170 :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) 7171 :param str include_metadata: 7172 :param ConsumerDisclosure consumer_disclosure: 7173 :return: ConsumerDisclosure 7174 If the method is called asynchronously, 7175 returns the request thread. 7176 """ 7177 kwargs['_return_http_data_only'] = True 7178 if kwargs.get('callback'): 7179 return self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 7180 else: 7181 (data) = self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 7182 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)
7184 def update_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs): 7185 """ 7186 Update Consumer Disclosure. 7187 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. 7188 This method makes a synchronous HTTP request by default. To make an 7189 asynchronous HTTP request, please define a `callback` function 7190 to be invoked when receiving the response. 7191 >>> def callback_function(response): 7192 >>> pprint(response) 7193 >>> 7194 >>> thread = api.update_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function) 7195 7196 :param callback function: The callback function 7197 for asynchronous request. (optional) 7198 :param str account_id: The external account number (int) or account ID Guid. (required) 7199 :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) 7200 :param str include_metadata: 7201 :param ConsumerDisclosure consumer_disclosure: 7202 :return: ConsumerDisclosure 7203 If the method is called asynchronously, 7204 returns the request thread. 7205 """ 7206 7207 all_params = ['account_id', 'lang_code', 'include_metadata', 'consumer_disclosure'] 7208 all_params.append('callback') 7209 all_params.append('_return_http_data_only') 7210 all_params.append('_preload_content') 7211 all_params.append('_request_timeout') 7212 7213 params = locals() 7214 for key, val in iteritems(params['kwargs']): 7215 if key not in all_params: 7216 raise TypeError( 7217 "Got an unexpected keyword argument '%s'" 7218 " to method update_consumer_disclosure" % key 7219 ) 7220 params[key] = val 7221 del params['kwargs'] 7222 # verify the required parameter 'account_id' is set 7223 if ('account_id' not in params) or (params['account_id'] is None): 7224 raise ValueError("Missing the required parameter `account_id` when calling `update_consumer_disclosure`") 7225 # verify the required parameter 'lang_code' is set 7226 if ('lang_code' not in params) or (params['lang_code'] is None): 7227 raise ValueError("Missing the required parameter `lang_code` when calling `update_consumer_disclosure`") 7228 7229 7230 collection_formats = {} 7231 7232 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 7233 path_params = {} 7234 if 'account_id' in params: 7235 path_params['accountId'] = params['account_id'] 7236 if 'lang_code' in params: 7237 path_params['langCode'] = params['lang_code'] 7238 7239 query_params = {} 7240 if 'include_metadata' in params: 7241 query_params['include_metadata'] = params['include_metadata'] 7242 7243 header_params = {} 7244 7245 form_params = [] 7246 local_var_files = {} 7247 7248 body_params = None 7249 if 'consumer_disclosure' in params: 7250 body_params = params['consumer_disclosure'] 7251 # HTTP header `Accept` 7252 header_params['Accept'] = self.api_client.\ 7253 select_header_accept(['application/json']) 7254 7255 # Authentication setting 7256 auth_settings = [] 7257 7258 return self.api_client.call_api(resource_path, 'PUT', 7259 path_params, 7260 query_params, 7261 header_params, 7262 body=body_params, 7263 post_params=form_params, 7264 files=local_var_files, 7265 response_type='ConsumerDisclosure', 7266 auth_settings=auth_settings, 7267 callback=params.get('callback'), 7268 _return_http_data_only=params.get('_return_http_data_only'), 7269 _preload_content=params.get('_preload_content', True), 7270 _request_timeout=params.get('_request_timeout'), 7271 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)
7273 def update_custom_field(self, account_id, custom_field_id, **kwargs): 7274 """ 7275 Updates an existing account custom field. 7276 This method updates an existing account custom field. 7277 This method makes a synchronous HTTP request by default. To make an 7278 asynchronous HTTP request, please define a `callback` function 7279 to be invoked when receiving the response. 7280 >>> def callback_function(response): 7281 >>> pprint(response) 7282 >>> 7283 >>> thread = api.update_custom_field(account_id, custom_field_id, callback=callback_function) 7284 7285 :param callback function: The callback function 7286 for asynchronous request. (optional) 7287 :param str account_id: The external account number (int) or account ID Guid. (required) 7288 :param str custom_field_id: (required) 7289 :param str apply_to_templates: 7290 :param CustomField custom_field: 7291 :return: CustomFields 7292 If the method is called asynchronously, 7293 returns the request thread. 7294 """ 7295 kwargs['_return_http_data_only'] = True 7296 if kwargs.get('callback'): 7297 return self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 7298 else: 7299 (data) = self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 7300 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)
7302 def update_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs): 7303 """ 7304 Updates an existing account custom field. 7305 This method updates an existing account custom field. 7306 This method makes a synchronous HTTP request by default. To make an 7307 asynchronous HTTP request, please define a `callback` function 7308 to be invoked when receiving the response. 7309 >>> def callback_function(response): 7310 >>> pprint(response) 7311 >>> 7312 >>> thread = api.update_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function) 7313 7314 :param callback function: The callback function 7315 for asynchronous request. (optional) 7316 :param str account_id: The external account number (int) or account ID Guid. (required) 7317 :param str custom_field_id: (required) 7318 :param str apply_to_templates: 7319 :param CustomField custom_field: 7320 :return: CustomFields 7321 If the method is called asynchronously, 7322 returns the request thread. 7323 """ 7324 7325 all_params = ['account_id', 'custom_field_id', 'apply_to_templates', 'custom_field'] 7326 all_params.append('callback') 7327 all_params.append('_return_http_data_only') 7328 all_params.append('_preload_content') 7329 all_params.append('_request_timeout') 7330 7331 params = locals() 7332 for key, val in iteritems(params['kwargs']): 7333 if key not in all_params: 7334 raise TypeError( 7335 "Got an unexpected keyword argument '%s'" 7336 " to method update_custom_field" % key 7337 ) 7338 params[key] = val 7339 del params['kwargs'] 7340 # verify the required parameter 'account_id' is set 7341 if ('account_id' not in params) or (params['account_id'] is None): 7342 raise ValueError("Missing the required parameter `account_id` when calling `update_custom_field`") 7343 # verify the required parameter 'custom_field_id' is set 7344 if ('custom_field_id' not in params) or (params['custom_field_id'] is None): 7345 raise ValueError("Missing the required parameter `custom_field_id` when calling `update_custom_field`") 7346 7347 7348 collection_formats = {} 7349 7350 resource_path = '/v2.1/accounts/{accountId}/custom_fields/{customFieldId}'.replace('{format}', 'json') 7351 path_params = {} 7352 if 'account_id' in params: 7353 path_params['accountId'] = params['account_id'] 7354 if 'custom_field_id' in params: 7355 path_params['customFieldId'] = params['custom_field_id'] 7356 7357 query_params = {} 7358 if 'apply_to_templates' in params: 7359 query_params['apply_to_templates'] = params['apply_to_templates'] 7360 7361 header_params = {} 7362 7363 form_params = [] 7364 local_var_files = {} 7365 7366 body_params = None 7367 if 'custom_field' in params: 7368 body_params = params['custom_field'] 7369 # HTTP header `Accept` 7370 header_params['Accept'] = self.api_client.\ 7371 select_header_accept(['application/json']) 7372 7373 # Authentication setting 7374 auth_settings = [] 7375 7376 return self.api_client.call_api(resource_path, 'PUT', 7377 path_params, 7378 query_params, 7379 header_params, 7380 body=body_params, 7381 post_params=form_params, 7382 files=local_var_files, 7383 response_type='CustomFields', 7384 auth_settings=auth_settings, 7385 callback=params.get('callback'), 7386 _return_http_data_only=params.get('_return_http_data_only'), 7387 _preload_content=params.get('_preload_content', True), 7388 _request_timeout=params.get('_request_timeout'), 7389 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)
7391 def update_e_note_configuration(self, account_id, **kwargs): 7392 """ 7393 Updates configuration information for the eNote eOriginal integration. 7394 7395 This method makes a synchronous HTTP request by default. To make an 7396 asynchronous HTTP request, please define a `callback` function 7397 to be invoked when receiving the response. 7398 >>> def callback_function(response): 7399 >>> pprint(response) 7400 >>> 7401 >>> thread = api.update_e_note_configuration(account_id, callback=callback_function) 7402 7403 :param callback function: The callback function 7404 for asynchronous request. (optional) 7405 :param str account_id: The external account number (int) or account ID Guid. (required) 7406 :param ENoteConfiguration e_note_configuration: 7407 :return: ENoteConfiguration 7408 If the method is called asynchronously, 7409 returns the request thread. 7410 """ 7411 kwargs['_return_http_data_only'] = True 7412 if kwargs.get('callback'): 7413 return self.update_e_note_configuration_with_http_info(account_id, **kwargs) 7414 else: 7415 (data) = self.update_e_note_configuration_with_http_info(account_id, **kwargs) 7416 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)
7418 def update_e_note_configuration_with_http_info(self, account_id, **kwargs): 7419 """ 7420 Updates configuration information for the eNote eOriginal integration. 7421 7422 This method makes a synchronous HTTP request by default. To make an 7423 asynchronous HTTP request, please define a `callback` function 7424 to be invoked when receiving the response. 7425 >>> def callback_function(response): 7426 >>> pprint(response) 7427 >>> 7428 >>> thread = api.update_e_note_configuration_with_http_info(account_id, callback=callback_function) 7429 7430 :param callback function: The callback function 7431 for asynchronous request. (optional) 7432 :param str account_id: The external account number (int) or account ID Guid. (required) 7433 :param ENoteConfiguration e_note_configuration: 7434 :return: ENoteConfiguration 7435 If the method is called asynchronously, 7436 returns the request thread. 7437 """ 7438 7439 all_params = ['account_id', 'e_note_configuration'] 7440 all_params.append('callback') 7441 all_params.append('_return_http_data_only') 7442 all_params.append('_preload_content') 7443 all_params.append('_request_timeout') 7444 7445 params = locals() 7446 for key, val in iteritems(params['kwargs']): 7447 if key not in all_params: 7448 raise TypeError( 7449 "Got an unexpected keyword argument '%s'" 7450 " to method update_e_note_configuration" % key 7451 ) 7452 params[key] = val 7453 del params['kwargs'] 7454 # verify the required parameter 'account_id' is set 7455 if ('account_id' not in params) or (params['account_id'] is None): 7456 raise ValueError("Missing the required parameter `account_id` when calling `update_e_note_configuration`") 7457 7458 7459 collection_formats = {} 7460 7461 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 7462 path_params = {} 7463 if 'account_id' in params: 7464 path_params['accountId'] = params['account_id'] 7465 7466 query_params = {} 7467 7468 header_params = {} 7469 7470 form_params = [] 7471 local_var_files = {} 7472 7473 body_params = None 7474 if 'e_note_configuration' in params: 7475 body_params = params['e_note_configuration'] 7476 # HTTP header `Accept` 7477 header_params['Accept'] = self.api_client.\ 7478 select_header_accept(['application/json']) 7479 7480 # Authentication setting 7481 auth_settings = [] 7482 7483 return self.api_client.call_api(resource_path, 'PUT', 7484 path_params, 7485 query_params, 7486 header_params, 7487 body=body_params, 7488 post_params=form_params, 7489 files=local_var_files, 7490 response_type='ENoteConfiguration', 7491 auth_settings=auth_settings, 7492 callback=params.get('callback'), 7493 _return_http_data_only=params.get('_return_http_data_only'), 7494 _preload_content=params.get('_preload_content', True), 7495 _request_timeout=params.get('_request_timeout'), 7496 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)
7498 def update_envelope_purge_configuration(self, account_id, **kwargs): 7499 """ 7500 Updates envelope purge configuration. 7501 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). 7502 This method makes a synchronous HTTP request by default. To make an 7503 asynchronous HTTP request, please define a `callback` function 7504 to be invoked when receiving the response. 7505 >>> def callback_function(response): 7506 >>> pprint(response) 7507 >>> 7508 >>> thread = api.update_envelope_purge_configuration(account_id, callback=callback_function) 7509 7510 :param callback function: The callback function 7511 for asynchronous request. (optional) 7512 :param str account_id: The external account number (int) or account ID Guid. (required) 7513 :param EnvelopePurgeConfiguration envelope_purge_configuration: 7514 :return: EnvelopePurgeConfiguration 7515 If the method is called asynchronously, 7516 returns the request thread. 7517 """ 7518 kwargs['_return_http_data_only'] = True 7519 if kwargs.get('callback'): 7520 return self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs) 7521 else: 7522 (data) = self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs) 7523 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)
7525 def update_envelope_purge_configuration_with_http_info(self, account_id, **kwargs): 7526 """ 7527 Updates envelope purge configuration. 7528 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). 7529 This method makes a synchronous HTTP request by default. To make an 7530 asynchronous HTTP request, please define a `callback` function 7531 to be invoked when receiving the response. 7532 >>> def callback_function(response): 7533 >>> pprint(response) 7534 >>> 7535 >>> thread = api.update_envelope_purge_configuration_with_http_info(account_id, callback=callback_function) 7536 7537 :param callback function: The callback function 7538 for asynchronous request. (optional) 7539 :param str account_id: The external account number (int) or account ID Guid. (required) 7540 :param EnvelopePurgeConfiguration envelope_purge_configuration: 7541 :return: EnvelopePurgeConfiguration 7542 If the method is called asynchronously, 7543 returns the request thread. 7544 """ 7545 7546 all_params = ['account_id', 'envelope_purge_configuration'] 7547 all_params.append('callback') 7548 all_params.append('_return_http_data_only') 7549 all_params.append('_preload_content') 7550 all_params.append('_request_timeout') 7551 7552 params = locals() 7553 for key, val in iteritems(params['kwargs']): 7554 if key not in all_params: 7555 raise TypeError( 7556 "Got an unexpected keyword argument '%s'" 7557 " to method update_envelope_purge_configuration" % key 7558 ) 7559 params[key] = val 7560 del params['kwargs'] 7561 # verify the required parameter 'account_id' is set 7562 if ('account_id' not in params) or (params['account_id'] is None): 7563 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_purge_configuration`") 7564 7565 7566 collection_formats = {} 7567 7568 resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json') 7569 path_params = {} 7570 if 'account_id' in params: 7571 path_params['accountId'] = params['account_id'] 7572 7573 query_params = {} 7574 7575 header_params = {} 7576 7577 form_params = [] 7578 local_var_files = {} 7579 7580 body_params = None 7581 if 'envelope_purge_configuration' in params: 7582 body_params = params['envelope_purge_configuration'] 7583 # HTTP header `Accept` 7584 header_params['Accept'] = self.api_client.\ 7585 select_header_accept(['application/json']) 7586 7587 # Authentication setting 7588 auth_settings = [] 7589 7590 return self.api_client.call_api(resource_path, 'PUT', 7591 path_params, 7592 query_params, 7593 header_params, 7594 body=body_params, 7595 post_params=form_params, 7596 files=local_var_files, 7597 response_type='EnvelopePurgeConfiguration', 7598 auth_settings=auth_settings, 7599 callback=params.get('callback'), 7600 _return_http_data_only=params.get('_return_http_data_only'), 7601 _preload_content=params.get('_preload_content', True), 7602 _request_timeout=params.get('_request_timeout'), 7603 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)
7605 def update_favorite_template(self, account_id, **kwargs): 7606 """ 7607 Favorites a template 7608 7609 This method makes a synchronous HTTP request by default. To make an 7610 asynchronous HTTP request, please define a `callback` function 7611 to be invoked when receiving the response. 7612 >>> def callback_function(response): 7613 >>> pprint(response) 7614 >>> 7615 >>> thread = api.update_favorite_template(account_id, callback=callback_function) 7616 7617 :param callback function: The callback function 7618 for asynchronous request. (optional) 7619 :param str account_id: The external account number (int) or account ID Guid. (required) 7620 :param FavoriteTemplatesInfo favorite_templates_info: 7621 :return: FavoriteTemplatesInfo 7622 If the method is called asynchronously, 7623 returns the request thread. 7624 """ 7625 kwargs['_return_http_data_only'] = True 7626 if kwargs.get('callback'): 7627 return self.update_favorite_template_with_http_info(account_id, **kwargs) 7628 else: 7629 (data) = self.update_favorite_template_with_http_info(account_id, **kwargs) 7630 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)
7632 def update_favorite_template_with_http_info(self, account_id, **kwargs): 7633 """ 7634 Favorites a template 7635 7636 This method makes a synchronous HTTP request by default. To make an 7637 asynchronous HTTP request, please define a `callback` function 7638 to be invoked when receiving the response. 7639 >>> def callback_function(response): 7640 >>> pprint(response) 7641 >>> 7642 >>> thread = api.update_favorite_template_with_http_info(account_id, callback=callback_function) 7643 7644 :param callback function: The callback function 7645 for asynchronous request. (optional) 7646 :param str account_id: The external account number (int) or account ID Guid. (required) 7647 :param FavoriteTemplatesInfo favorite_templates_info: 7648 :return: FavoriteTemplatesInfo 7649 If the method is called asynchronously, 7650 returns the request thread. 7651 """ 7652 7653 all_params = ['account_id', 'favorite_templates_info'] 7654 all_params.append('callback') 7655 all_params.append('_return_http_data_only') 7656 all_params.append('_preload_content') 7657 all_params.append('_request_timeout') 7658 7659 params = locals() 7660 for key, val in iteritems(params['kwargs']): 7661 if key not in all_params: 7662 raise TypeError( 7663 "Got an unexpected keyword argument '%s'" 7664 " to method update_favorite_template" % key 7665 ) 7666 params[key] = val 7667 del params['kwargs'] 7668 # verify the required parameter 'account_id' is set 7669 if ('account_id' not in params) or (params['account_id'] is None): 7670 raise ValueError("Missing the required parameter `account_id` when calling `update_favorite_template`") 7671 7672 7673 collection_formats = {} 7674 7675 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 7676 path_params = {} 7677 if 'account_id' in params: 7678 path_params['accountId'] = params['account_id'] 7679 7680 query_params = {} 7681 7682 header_params = {} 7683 7684 form_params = [] 7685 local_var_files = {} 7686 7687 body_params = None 7688 if 'favorite_templates_info' in params: 7689 body_params = params['favorite_templates_info'] 7690 # HTTP header `Accept` 7691 header_params['Accept'] = self.api_client.\ 7692 select_header_accept(['application/json']) 7693 7694 # Authentication setting 7695 auth_settings = [] 7696 7697 return self.api_client.call_api(resource_path, 'PUT', 7698 path_params, 7699 query_params, 7700 header_params, 7701 body=body_params, 7702 post_params=form_params, 7703 files=local_var_files, 7704 response_type='FavoriteTemplatesInfo', 7705 auth_settings=auth_settings, 7706 callback=params.get('callback'), 7707 _return_http_data_only=params.get('_return_http_data_only'), 7708 _preload_content=params.get('_preload_content', True), 7709 _request_timeout=params.get('_request_timeout'), 7710 collection_formats=collection_formats)
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)
7712 def update_notification_defaults(self, account_id, **kwargs): 7713 """ 7714 Updates default user level settings for a specified account 7715 This method changes the default settings for the email notifications that signers and senders receive about envelopes. 7716 This method makes a synchronous HTTP request by default. To make an 7717 asynchronous HTTP request, please define a `callback` function 7718 to be invoked when receiving the response. 7719 >>> def callback_function(response): 7720 >>> pprint(response) 7721 >>> 7722 >>> thread = api.update_notification_defaults(account_id, callback=callback_function) 7723 7724 :param callback function: The callback function 7725 for asynchronous request. (optional) 7726 :param str account_id: The external account number (int) or account ID Guid. (required) 7727 :param NotificationDefaults notification_defaults: 7728 :return: NotificationDefaults 7729 If the method is called asynchronously, 7730 returns the request thread. 7731 """ 7732 kwargs['_return_http_data_only'] = True 7733 if kwargs.get('callback'): 7734 return self.update_notification_defaults_with_http_info(account_id, **kwargs) 7735 else: 7736 (data) = self.update_notification_defaults_with_http_info(account_id, **kwargs) 7737 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)
7739 def update_notification_defaults_with_http_info(self, account_id, **kwargs): 7740 """ 7741 Updates default user level settings for a specified account 7742 This method changes the default settings for the email notifications that signers and senders receive about envelopes. 7743 This method makes a synchronous HTTP request by default. To make an 7744 asynchronous HTTP request, please define a `callback` function 7745 to be invoked when receiving the response. 7746 >>> def callback_function(response): 7747 >>> pprint(response) 7748 >>> 7749 >>> thread = api.update_notification_defaults_with_http_info(account_id, callback=callback_function) 7750 7751 :param callback function: The callback function 7752 for asynchronous request. (optional) 7753 :param str account_id: The external account number (int) or account ID Guid. (required) 7754 :param NotificationDefaults notification_defaults: 7755 :return: NotificationDefaults 7756 If the method is called asynchronously, 7757 returns the request thread. 7758 """ 7759 7760 all_params = ['account_id', 'notification_defaults'] 7761 all_params.append('callback') 7762 all_params.append('_return_http_data_only') 7763 all_params.append('_preload_content') 7764 all_params.append('_request_timeout') 7765 7766 params = locals() 7767 for key, val in iteritems(params['kwargs']): 7768 if key not in all_params: 7769 raise TypeError( 7770 "Got an unexpected keyword argument '%s'" 7771 " to method update_notification_defaults" % key 7772 ) 7773 params[key] = val 7774 del params['kwargs'] 7775 # verify the required parameter 'account_id' is set 7776 if ('account_id' not in params) or (params['account_id'] is None): 7777 raise ValueError("Missing the required parameter `account_id` when calling `update_notification_defaults`") 7778 7779 7780 collection_formats = {} 7781 7782 resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json') 7783 path_params = {} 7784 if 'account_id' in params: 7785 path_params['accountId'] = params['account_id'] 7786 7787 query_params = {} 7788 7789 header_params = {} 7790 7791 form_params = [] 7792 local_var_files = {} 7793 7794 body_params = None 7795 if 'notification_defaults' in params: 7796 body_params = params['notification_defaults'] 7797 # HTTP header `Accept` 7798 header_params['Accept'] = self.api_client.\ 7799 select_header_accept(['application/json']) 7800 7801 # Authentication setting 7802 auth_settings = [] 7803 7804 return self.api_client.call_api(resource_path, 'PUT', 7805 path_params, 7806 query_params, 7807 header_params, 7808 body=body_params, 7809 post_params=form_params, 7810 files=local_var_files, 7811 response_type='NotificationDefaults', 7812 auth_settings=auth_settings, 7813 callback=params.get('callback'), 7814 _return_http_data_only=params.get('_return_http_data_only'), 7815 _preload_content=params.get('_preload_content', True), 7816 _request_timeout=params.get('_request_timeout'), 7817 collection_formats=collection_formats)
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)
7819 def update_password_rules(self, account_id, **kwargs): 7820 """ 7821 Update the password rules 7822 This method updates the password rules for an account. **Note:** To update the password rules for an account, you must be an account administrator. 7823 This method makes a synchronous HTTP request by default. To make an 7824 asynchronous HTTP request, please define a `callback` function 7825 to be invoked when receiving the response. 7826 >>> def callback_function(response): 7827 >>> pprint(response) 7828 >>> 7829 >>> thread = api.update_password_rules(account_id, callback=callback_function) 7830 7831 :param callback function: The callback function 7832 for asynchronous request. (optional) 7833 :param str account_id: The external account number (int) or account ID Guid. (required) 7834 :param AccountPasswordRules account_password_rules: 7835 :return: AccountPasswordRules 7836 If the method is called asynchronously, 7837 returns the request thread. 7838 """ 7839 kwargs['_return_http_data_only'] = True 7840 if kwargs.get('callback'): 7841 return self.update_password_rules_with_http_info(account_id, **kwargs) 7842 else: 7843 (data) = self.update_password_rules_with_http_info(account_id, **kwargs) 7844 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)
7846 def update_password_rules_with_http_info(self, account_id, **kwargs): 7847 """ 7848 Update the password rules 7849 This method updates the password rules for an account. **Note:** To update the password rules for an account, you must be an account administrator. 7850 This method makes a synchronous HTTP request by default. To make an 7851 asynchronous HTTP request, please define a `callback` function 7852 to be invoked when receiving the response. 7853 >>> def callback_function(response): 7854 >>> pprint(response) 7855 >>> 7856 >>> thread = api.update_password_rules_with_http_info(account_id, callback=callback_function) 7857 7858 :param callback function: The callback function 7859 for asynchronous request. (optional) 7860 :param str account_id: The external account number (int) or account ID Guid. (required) 7861 :param AccountPasswordRules account_password_rules: 7862 :return: AccountPasswordRules 7863 If the method is called asynchronously, 7864 returns the request thread. 7865 """ 7866 7867 all_params = ['account_id', 'account_password_rules'] 7868 all_params.append('callback') 7869 all_params.append('_return_http_data_only') 7870 all_params.append('_preload_content') 7871 all_params.append('_request_timeout') 7872 7873 params = locals() 7874 for key, val in iteritems(params['kwargs']): 7875 if key not in all_params: 7876 raise TypeError( 7877 "Got an unexpected keyword argument '%s'" 7878 " to method update_password_rules" % key 7879 ) 7880 params[key] = val 7881 del params['kwargs'] 7882 # verify the required parameter 'account_id' is set 7883 if ('account_id' not in params) or (params['account_id'] is None): 7884 raise ValueError("Missing the required parameter `account_id` when calling `update_password_rules`") 7885 7886 7887 collection_formats = {} 7888 7889 resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json') 7890 path_params = {} 7891 if 'account_id' in params: 7892 path_params['accountId'] = params['account_id'] 7893 7894 query_params = {} 7895 7896 header_params = {} 7897 7898 form_params = [] 7899 local_var_files = {} 7900 7901 body_params = None 7902 if 'account_password_rules' in params: 7903 body_params = params['account_password_rules'] 7904 # HTTP header `Accept` 7905 header_params['Accept'] = self.api_client.\ 7906 select_header_accept(['application/json']) 7907 7908 # Authentication setting 7909 auth_settings = [] 7910 7911 return self.api_client.call_api(resource_path, 'PUT', 7912 path_params, 7913 query_params, 7914 header_params, 7915 body=body_params, 7916 post_params=form_params, 7917 files=local_var_files, 7918 response_type='AccountPasswordRules', 7919 auth_settings=auth_settings, 7920 callback=params.get('callback'), 7921 _return_http_data_only=params.get('_return_http_data_only'), 7922 _preload_content=params.get('_preload_content', True), 7923 _request_timeout=params.get('_request_timeout'), 7924 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)
7926 def update_permission_profile(self, account_id, permission_profile_id, **kwargs): 7927 """ 7928 Updates a permission profile within the specified account. 7929 This method updates an account permission profile. ### Related topics - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 7930 This method makes a synchronous HTTP request by default. To make an 7931 asynchronous HTTP request, please define a `callback` function 7932 to be invoked when receiving the response. 7933 >>> def callback_function(response): 7934 >>> pprint(response) 7935 >>> 7936 >>> thread = api.update_permission_profile(account_id, permission_profile_id, callback=callback_function) 7937 7938 :param callback function: The callback function 7939 for asynchronous request. (optional) 7940 :param str account_id: The external account number (int) or account ID Guid. (required) 7941 :param str permission_profile_id: (required) 7942 :param str include: 7943 :param PermissionProfile permission_profile: 7944 :return: PermissionProfile 7945 If the method is called asynchronously, 7946 returns the request thread. 7947 """ 7948 kwargs['_return_http_data_only'] = True 7949 if kwargs.get('callback'): 7950 return self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 7951 else: 7952 (data) = self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 7953 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)
7955 def update_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 7956 """ 7957 Updates a permission profile within the specified account. 7958 This method updates an account permission profile. ### Related topics - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 7959 This method makes a synchronous HTTP request by default. To make an 7960 asynchronous HTTP request, please define a `callback` function 7961 to be invoked when receiving the response. 7962 >>> def callback_function(response): 7963 >>> pprint(response) 7964 >>> 7965 >>> thread = api.update_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 7966 7967 :param callback function: The callback function 7968 for asynchronous request. (optional) 7969 :param str account_id: The external account number (int) or account ID Guid. (required) 7970 :param str permission_profile_id: (required) 7971 :param str include: 7972 :param PermissionProfile permission_profile: 7973 :return: PermissionProfile 7974 If the method is called asynchronously, 7975 returns the request thread. 7976 """ 7977 7978 all_params = ['account_id', 'permission_profile_id', 'include', 'permission_profile'] 7979 all_params.append('callback') 7980 all_params.append('_return_http_data_only') 7981 all_params.append('_preload_content') 7982 all_params.append('_request_timeout') 7983 7984 params = locals() 7985 for key, val in iteritems(params['kwargs']): 7986 if key not in all_params: 7987 raise TypeError( 7988 "Got an unexpected keyword argument '%s'" 7989 " to method update_permission_profile" % key 7990 ) 7991 params[key] = val 7992 del params['kwargs'] 7993 # verify the required parameter 'account_id' is set 7994 if ('account_id' not in params) or (params['account_id'] is None): 7995 raise ValueError("Missing the required parameter `account_id` when calling `update_permission_profile`") 7996 # verify the required parameter 'permission_profile_id' is set 7997 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 7998 raise ValueError("Missing the required parameter `permission_profile_id` when calling `update_permission_profile`") 7999 8000 8001 collection_formats = {} 8002 8003 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 8004 path_params = {} 8005 if 'account_id' in params: 8006 path_params['accountId'] = params['account_id'] 8007 if 'permission_profile_id' in params: 8008 path_params['permissionProfileId'] = params['permission_profile_id'] 8009 8010 query_params = {} 8011 if 'include' in params: 8012 query_params['include'] = params['include'] 8013 8014 header_params = {} 8015 8016 form_params = [] 8017 local_var_files = {} 8018 8019 body_params = None 8020 if 'permission_profile' in params: 8021 body_params = params['permission_profile'] 8022 # HTTP header `Accept` 8023 header_params['Accept'] = self.api_client.\ 8024 select_header_accept(['application/json']) 8025 8026 # Authentication setting 8027 auth_settings = [] 8028 8029 return self.api_client.call_api(resource_path, 'PUT', 8030 path_params, 8031 query_params, 8032 header_params, 8033 body=body_params, 8034 post_params=form_params, 8035 files=local_var_files, 8036 response_type='PermissionProfile', 8037 auth_settings=auth_settings, 8038 callback=params.get('callback'), 8039 _return_http_data_only=params.get('_return_http_data_only'), 8040 _preload_content=params.get('_preload_content', True), 8041 _request_timeout=params.get('_request_timeout'), 8042 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)
8044 def update_settings(self, account_id, **kwargs): 8045 """ 8046 Updates the account settings for an account. 8047 Updates the account settings for the specified account. 8048 This method makes a synchronous HTTP request by default. To make an 8049 asynchronous HTTP request, please define a `callback` function 8050 to be invoked when receiving the response. 8051 >>> def callback_function(response): 8052 >>> pprint(response) 8053 >>> 8054 >>> thread = api.update_settings(account_id, callback=callback_function) 8055 8056 :param callback function: The callback function 8057 for asynchronous request. (optional) 8058 :param str account_id: The external account number (int) or account ID Guid. (required) 8059 :param AccountSettingsInformation account_settings_information: 8060 :return: None 8061 If the method is called asynchronously, 8062 returns the request thread. 8063 """ 8064 kwargs['_return_http_data_only'] = True 8065 if kwargs.get('callback'): 8066 return self.update_settings_with_http_info(account_id, **kwargs) 8067 else: 8068 (data) = self.update_settings_with_http_info(account_id, **kwargs) 8069 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)
8071 def update_settings_with_http_info(self, account_id, **kwargs): 8072 """ 8073 Updates the account settings for an account. 8074 Updates the account settings for the specified account. 8075 This method makes a synchronous HTTP request by default. To make an 8076 asynchronous HTTP request, please define a `callback` function 8077 to be invoked when receiving the response. 8078 >>> def callback_function(response): 8079 >>> pprint(response) 8080 >>> 8081 >>> thread = api.update_settings_with_http_info(account_id, callback=callback_function) 8082 8083 :param callback function: The callback function 8084 for asynchronous request. (optional) 8085 :param str account_id: The external account number (int) or account ID Guid. (required) 8086 :param AccountSettingsInformation account_settings_information: 8087 :return: None 8088 If the method is called asynchronously, 8089 returns the request thread. 8090 """ 8091 8092 all_params = ['account_id', 'account_settings_information'] 8093 all_params.append('callback') 8094 all_params.append('_return_http_data_only') 8095 all_params.append('_preload_content') 8096 all_params.append('_request_timeout') 8097 8098 params = locals() 8099 for key, val in iteritems(params['kwargs']): 8100 if key not in all_params: 8101 raise TypeError( 8102 "Got an unexpected keyword argument '%s'" 8103 " to method update_settings" % key 8104 ) 8105 params[key] = val 8106 del params['kwargs'] 8107 # verify the required parameter 'account_id' is set 8108 if ('account_id' not in params) or (params['account_id'] is None): 8109 raise ValueError("Missing the required parameter `account_id` when calling `update_settings`") 8110 8111 8112 collection_formats = {} 8113 8114 resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json') 8115 path_params = {} 8116 if 'account_id' in params: 8117 path_params['accountId'] = params['account_id'] 8118 8119 query_params = {} 8120 8121 header_params = {} 8122 8123 form_params = [] 8124 local_var_files = {} 8125 8126 body_params = None 8127 if 'account_settings_information' in params: 8128 body_params = params['account_settings_information'] 8129 # HTTP header `Accept` 8130 header_params['Accept'] = self.api_client.\ 8131 select_header_accept(['application/json']) 8132 8133 # Authentication setting 8134 auth_settings = [] 8135 8136 return self.api_client.call_api(resource_path, 'PUT', 8137 path_params, 8138 query_params, 8139 header_params, 8140 body=body_params, 8141 post_params=form_params, 8142 files=local_var_files, 8143 response_type=None, 8144 auth_settings=auth_settings, 8145 callback=params.get('callback'), 8146 _return_http_data_only=params.get('_return_http_data_only'), 8147 _preload_content=params.get('_preload_content', True), 8148 _request_timeout=params.get('_request_timeout'), 8149 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)
8389 def update_watermark(self, account_id, **kwargs): 8390 """ 8391 Update watermark information. 8392 8393 This method makes a synchronous HTTP request by default. To make an 8394 asynchronous HTTP request, please define a `callback` function 8395 to be invoked when receiving the response. 8396 >>> def callback_function(response): 8397 >>> pprint(response) 8398 >>> 8399 >>> thread = api.update_watermark(account_id, callback=callback_function) 8400 8401 :param callback function: The callback function 8402 for asynchronous request. (optional) 8403 :param str account_id: The external account number (int) or account ID Guid. (required) 8404 :param Watermark watermark: 8405 :return: Watermark 8406 If the method is called asynchronously, 8407 returns the request thread. 8408 """ 8409 kwargs['_return_http_data_only'] = True 8410 if kwargs.get('callback'): 8411 return self.update_watermark_with_http_info(account_id, **kwargs) 8412 else: 8413 (data) = self.update_watermark_with_http_info(account_id, **kwargs) 8414 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)
8416 def update_watermark_with_http_info(self, account_id, **kwargs): 8417 """ 8418 Update watermark information. 8419 8420 This method makes a synchronous HTTP request by default. To make an 8421 asynchronous HTTP request, please define a `callback` function 8422 to be invoked when receiving the response. 8423 >>> def callback_function(response): 8424 >>> pprint(response) 8425 >>> 8426 >>> thread = api.update_watermark_with_http_info(account_id, callback=callback_function) 8427 8428 :param callback function: The callback function 8429 for asynchronous request. (optional) 8430 :param str account_id: The external account number (int) or account ID Guid. (required) 8431 :param Watermark watermark: 8432 :return: Watermark 8433 If the method is called asynchronously, 8434 returns the request thread. 8435 """ 8436 8437 all_params = ['account_id', 'watermark'] 8438 all_params.append('callback') 8439 all_params.append('_return_http_data_only') 8440 all_params.append('_preload_content') 8441 all_params.append('_request_timeout') 8442 8443 params = locals() 8444 for key, val in iteritems(params['kwargs']): 8445 if key not in all_params: 8446 raise TypeError( 8447 "Got an unexpected keyword argument '%s'" 8448 " to method update_watermark" % key 8449 ) 8450 params[key] = val 8451 del params['kwargs'] 8452 # verify the required parameter 'account_id' is set 8453 if ('account_id' not in params) or (params['account_id'] is None): 8454 raise ValueError("Missing the required parameter `account_id` when calling `update_watermark`") 8455 8456 8457 collection_formats = {} 8458 8459 resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json') 8460 path_params = {} 8461 if 'account_id' in params: 8462 path_params['accountId'] = params['account_id'] 8463 8464 query_params = {} 8465 8466 header_params = {} 8467 8468 form_params = [] 8469 local_var_files = {} 8470 8471 body_params = None 8472 if 'watermark' in params: 8473 body_params = params['watermark'] 8474 # HTTP header `Accept` 8475 header_params['Accept'] = self.api_client.\ 8476 select_header_accept(['application/json']) 8477 8478 # Authentication setting 8479 auth_settings = [] 8480 8481 return self.api_client.call_api(resource_path, 'PUT', 8482 path_params, 8483 query_params, 8484 header_params, 8485 body=body_params, 8486 post_params=form_params, 8487 files=local_var_files, 8488 response_type='Watermark', 8489 auth_settings=auth_settings, 8490 callback=params.get('callback'), 8491 _return_http_data_only=params.get('_return_http_data_only'), 8492 _preload_content=params.get('_preload_content', True), 8493 _request_timeout=params.get('_request_timeout'), 8494 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.