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_completion_rate_for_template(self, account_id, template_id, **kwargs): 3745 """ 3746 Gets completion rate for the template 3747 This method makes a synchronous HTTP request by default. To make an 3748 asynchronous HTTP request, please define a `callback` function 3749 to be invoked when receiving the response. 3750 >>> def callback_function(response): 3751 >>> pprint(response) 3752 >>> 3753 >>> thread = api.get_completion_rate_for_template(account_id, template_id, callback=callback_function) 3754 3755 :param callback function: The callback function 3756 for asynchronous request. (optional) 3757 :param str account_id: The external account number (int) or account ID Guid. (required) 3758 :param str template_id: The ID of the template being accessed. (required) 3759 :return: TemplateCompletionRateResponse 3760 If the method is called asynchronously, 3761 returns the request thread. 3762 """ 3763 kwargs['_return_http_data_only'] = True 3764 if kwargs.get('callback'): 3765 return self.get_completion_rate_for_template_with_http_info(account_id, template_id, **kwargs) 3766 else: 3767 (data) = self.get_completion_rate_for_template_with_http_info(account_id, template_id, **kwargs) 3768 return data 3769 3770 def get_completion_rate_for_template_with_http_info(self, account_id, template_id, **kwargs): 3771 """ 3772 Gets completion rate for the template 3773 This method makes a synchronous HTTP request by default. To make an 3774 asynchronous HTTP request, please define a `callback` function 3775 to be invoked when receiving the response. 3776 >>> def callback_function(response): 3777 >>> pprint(response) 3778 >>> 3779 >>> thread = api.get_completion_rate_for_template_with_http_info(account_id, template_id, callback=callback_function) 3780 3781 :param callback function: The callback function 3782 for asynchronous request. (optional) 3783 :param str account_id: The external account number (int) or account ID Guid. (required) 3784 :param str template_id: The ID of the template being accessed. (required) 3785 :return: TemplateCompletionRateResponse 3786 If the method is called asynchronously, 3787 returns the request thread. 3788 """ 3789 3790 all_params = ['account_id', 'template_id'] 3791 all_params.append('callback') 3792 all_params.append('_return_http_data_only') 3793 all_params.append('_preload_content') 3794 all_params.append('_request_timeout') 3795 3796 params = locals() 3797 for key, val in iteritems(params['kwargs']): 3798 if key not in all_params: 3799 raise TypeError( 3800 "Got an unexpected keyword argument '%s'" 3801 " to method get_completion_rate_for_template" % key 3802 ) 3803 params[key] = val 3804 del params['kwargs'] 3805 # verify the required parameter 'account_id' is set 3806 if ('account_id' not in params) or (params['account_id'] is None): 3807 raise ValueError("Missing the required parameter `account_id` when calling `get_completion_rate_for_template`") 3808 # verify the required parameter 'template_id' is set 3809 if ('template_id' not in params) or (params['template_id'] is None): 3810 raise ValueError("Missing the required parameter `template_id` when calling `get_completion_rate_for_template`") 3811 3812 3813 collection_formats = {} 3814 3815 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/insights/completionRate'.replace('{format}', 'json') 3816 path_params = {} 3817 if 'account_id' in params: 3818 path_params['accountId'] = params['account_id'] 3819 if 'template_id' in params: 3820 path_params['templateId'] = params['template_id'] 3821 3822 query_params = {} 3823 3824 header_params = {} 3825 3826 form_params = [] 3827 local_var_files = {} 3828 3829 body_params = None 3830 # HTTP header `Accept` 3831 header_params['Accept'] = self.api_client.\ 3832 select_header_accept(['application/json']) 3833 3834 # Authentication setting 3835 auth_settings = [] 3836 3837 return self.api_client.call_api(resource_path, 'GET', 3838 path_params, 3839 query_params, 3840 header_params, 3841 body=body_params, 3842 post_params=form_params, 3843 files=local_var_files, 3844 response_type='TemplateCompletionRateResponse', 3845 auth_settings=auth_settings, 3846 callback=params.get('callback'), 3847 _return_http_data_only=params.get('_return_http_data_only'), 3848 _preload_content=params.get('_preload_content', True), 3849 _request_timeout=params.get('_request_timeout'), 3850 collection_formats=collection_formats) 3851 3852 def get_completion_rate_for_template_owner(self, account_id, **kwargs): 3853 """ 3854 Gets completion rate for the user 3855 This method makes a synchronous HTTP request by default. To make an 3856 asynchronous HTTP request, please define a `callback` function 3857 to be invoked when receiving the response. 3858 >>> def callback_function(response): 3859 >>> pprint(response) 3860 >>> 3861 >>> thread = api.get_completion_rate_for_template_owner(account_id, callback=callback_function) 3862 3863 :param callback function: The callback function 3864 for asynchronous request. (optional) 3865 :param str account_id: The external account number (int) or account ID Guid. (required) 3866 :return: UserCompletionRateResponse 3867 If the method is called asynchronously, 3868 returns the request thread. 3869 """ 3870 kwargs['_return_http_data_only'] = True 3871 if kwargs.get('callback'): 3872 return self.get_completion_rate_for_template_owner_with_http_info(account_id, **kwargs) 3873 else: 3874 (data) = self.get_completion_rate_for_template_owner_with_http_info(account_id, **kwargs) 3875 return data 3876 3877 def get_completion_rate_for_template_owner_with_http_info(self, account_id, **kwargs): 3878 """ 3879 Gets completion rate for the user 3880 This method makes a synchronous HTTP request by default. To make an 3881 asynchronous HTTP request, please define a `callback` function 3882 to be invoked when receiving the response. 3883 >>> def callback_function(response): 3884 >>> pprint(response) 3885 >>> 3886 >>> thread = api.get_completion_rate_for_template_owner_with_http_info(account_id, callback=callback_function) 3887 3888 :param callback function: The callback function 3889 for asynchronous request. (optional) 3890 :param str account_id: The external account number (int) or account ID Guid. (required) 3891 :return: UserCompletionRateResponse 3892 If the method is called asynchronously, 3893 returns the request thread. 3894 """ 3895 3896 all_params = ['account_id'] 3897 all_params.append('callback') 3898 all_params.append('_return_http_data_only') 3899 all_params.append('_preload_content') 3900 all_params.append('_request_timeout') 3901 3902 params = locals() 3903 for key, val in iteritems(params['kwargs']): 3904 if key not in all_params: 3905 raise TypeError( 3906 "Got an unexpected keyword argument '%s'" 3907 " to method get_completion_rate_for_template_owner" % key 3908 ) 3909 params[key] = val 3910 del params['kwargs'] 3911 # verify the required parameter 'account_id' is set 3912 if ('account_id' not in params) or (params['account_id'] is None): 3913 raise ValueError("Missing the required parameter `account_id` when calling `get_completion_rate_for_template_owner`") 3914 3915 3916 collection_formats = {} 3917 3918 resource_path = '/v2.1/accounts/{accountId}/templates/insights/completionRate'.replace('{format}', 'json') 3919 path_params = {} 3920 if 'account_id' in params: 3921 path_params['accountId'] = params['account_id'] 3922 3923 query_params = {} 3924 3925 header_params = {} 3926 3927 form_params = [] 3928 local_var_files = {} 3929 3930 body_params = None 3931 # HTTP header `Accept` 3932 header_params['Accept'] = self.api_client.\ 3933 select_header_accept(['application/json']) 3934 3935 # Authentication setting 3936 auth_settings = [] 3937 3938 return self.api_client.call_api(resource_path, 'GET', 3939 path_params, 3940 query_params, 3941 header_params, 3942 body=body_params, 3943 post_params=form_params, 3944 files=local_var_files, 3945 response_type='UserCompletionRateResponse', 3946 auth_settings=auth_settings, 3947 callback=params.get('callback'), 3948 _return_http_data_only=params.get('_return_http_data_only'), 3949 _preload_content=params.get('_preload_content', True), 3950 _request_timeout=params.get('_request_timeout'), 3951 collection_formats=collection_formats) 3952 3953 def get_consumer_disclosure(self, account_id, lang_code, **kwargs): 3954 """ 3955 Gets the Electronic Record and Signature Disclosure. 3956 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. 3957 This method makes a synchronous HTTP request by default. To make an 3958 asynchronous HTTP request, please define a `callback` function 3959 to be invoked when receiving the response. 3960 >>> def callback_function(response): 3961 >>> pprint(response) 3962 >>> 3963 >>> thread = api.get_consumer_disclosure(account_id, lang_code, callback=callback_function) 3964 3965 :param callback function: The callback function 3966 for asynchronous request. (optional) 3967 :param str account_id: The external account number (int) or account ID Guid. (required) 3968 :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) 3969 :return: ConsumerDisclosure 3970 If the method is called asynchronously, 3971 returns the request thread. 3972 """ 3973 kwargs['_return_http_data_only'] = True 3974 if kwargs.get('callback'): 3975 return self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 3976 else: 3977 (data) = self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 3978 return data 3979 3980 def get_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs): 3981 """ 3982 Gets the Electronic Record and Signature Disclosure. 3983 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. 3984 This method makes a synchronous HTTP request by default. To make an 3985 asynchronous HTTP request, please define a `callback` function 3986 to be invoked when receiving the response. 3987 >>> def callback_function(response): 3988 >>> pprint(response) 3989 >>> 3990 >>> thread = api.get_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function) 3991 3992 :param callback function: The callback function 3993 for asynchronous request. (optional) 3994 :param str account_id: The external account number (int) or account ID Guid. (required) 3995 :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) 3996 :return: ConsumerDisclosure 3997 If the method is called asynchronously, 3998 returns the request thread. 3999 """ 4000 4001 all_params = ['account_id', 'lang_code'] 4002 all_params.append('callback') 4003 all_params.append('_return_http_data_only') 4004 all_params.append('_preload_content') 4005 all_params.append('_request_timeout') 4006 4007 params = locals() 4008 for key, val in iteritems(params['kwargs']): 4009 if key not in all_params: 4010 raise TypeError( 4011 "Got an unexpected keyword argument '%s'" 4012 " to method get_consumer_disclosure" % key 4013 ) 4014 params[key] = val 4015 del params['kwargs'] 4016 # verify the required parameter 'account_id' is set 4017 if ('account_id' not in params) or (params['account_id'] is None): 4018 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure`") 4019 # verify the required parameter 'lang_code' is set 4020 if ('lang_code' not in params) or (params['lang_code'] is None): 4021 raise ValueError("Missing the required parameter `lang_code` when calling `get_consumer_disclosure`") 4022 4023 4024 collection_formats = {} 4025 4026 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 4027 path_params = {} 4028 if 'account_id' in params: 4029 path_params['accountId'] = params['account_id'] 4030 if 'lang_code' in params: 4031 path_params['langCode'] = params['lang_code'] 4032 4033 query_params = {} 4034 4035 header_params = {} 4036 4037 form_params = [] 4038 local_var_files = {} 4039 4040 body_params = None 4041 # HTTP header `Accept` 4042 header_params['Accept'] = self.api_client.\ 4043 select_header_accept(['application/json']) 4044 4045 # Authentication setting 4046 auth_settings = [] 4047 4048 return self.api_client.call_api(resource_path, 'GET', 4049 path_params, 4050 query_params, 4051 header_params, 4052 body=body_params, 4053 post_params=form_params, 4054 files=local_var_files, 4055 response_type='ConsumerDisclosure', 4056 auth_settings=auth_settings, 4057 callback=params.get('callback'), 4058 _return_http_data_only=params.get('_return_http_data_only'), 4059 _preload_content=params.get('_preload_content', True), 4060 _request_timeout=params.get('_request_timeout'), 4061 collection_formats=collection_formats) 4062 4063 def get_consumer_disclosure_default(self, account_id, **kwargs): 4064 """ 4065 Gets the Electronic Record and Signature Disclosure for the account. 4066 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. 4067 This method makes a synchronous HTTP request by default. To make an 4068 asynchronous HTTP request, please define a `callback` function 4069 to be invoked when receiving the response. 4070 >>> def callback_function(response): 4071 >>> pprint(response) 4072 >>> 4073 >>> thread = api.get_consumer_disclosure_default(account_id, callback=callback_function) 4074 4075 :param callback function: The callback function 4076 for asynchronous request. (optional) 4077 :param str account_id: The external account number (int) or account ID Guid. (required) 4078 :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. 4079 :return: ConsumerDisclosure 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_consumer_disclosure_default_with_http_info(account_id, **kwargs) 4086 else: 4087 (data) = self.get_consumer_disclosure_default_with_http_info(account_id, **kwargs) 4088 return data 4089 4090 def get_consumer_disclosure_default_with_http_info(self, account_id, **kwargs): 4091 """ 4092 Gets the Electronic Record and Signature Disclosure for the account. 4093 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. 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_consumer_disclosure_default_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 :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. 4106 :return: ConsumerDisclosure 4107 If the method is called asynchronously, 4108 returns the request thread. 4109 """ 4110 4111 all_params = ['account_id', 'lang_code'] 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_consumer_disclosure_default" % 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_consumer_disclosure_default`") 4129 4130 4131 collection_formats = {} 4132 4133 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure'.replace('{format}', 'json') 4134 path_params = {} 4135 if 'account_id' in params: 4136 path_params['accountId'] = params['account_id'] 4137 4138 query_params = {} 4139 if 'lang_code' in params: 4140 query_params['langCode'] = params['lang_code'] 4141 4142 header_params = {} 4143 4144 form_params = [] 4145 local_var_files = {} 4146 4147 body_params = None 4148 # HTTP header `Accept` 4149 header_params['Accept'] = self.api_client.\ 4150 select_header_accept(['application/json']) 4151 4152 # Authentication setting 4153 auth_settings = [] 4154 4155 return self.api_client.call_api(resource_path, 'GET', 4156 path_params, 4157 query_params, 4158 header_params, 4159 body=body_params, 4160 post_params=form_params, 4161 files=local_var_files, 4162 response_type='ConsumerDisclosure', 4163 auth_settings=auth_settings, 4164 callback=params.get('callback'), 4165 _return_http_data_only=params.get('_return_http_data_only'), 4166 _preload_content=params.get('_preload_content', True), 4167 _request_timeout=params.get('_request_timeout'), 4168 collection_formats=collection_formats) 4169 4170 def get_e_note_configuration(self, account_id, **kwargs): 4171 """ 4172 Returns the configuration information for the eNote eOriginal integration. 4173 4174 This method makes a synchronous HTTP request by default. To make an 4175 asynchronous HTTP request, please define a `callback` function 4176 to be invoked when receiving the response. 4177 >>> def callback_function(response): 4178 >>> pprint(response) 4179 >>> 4180 >>> thread = api.get_e_note_configuration(account_id, callback=callback_function) 4181 4182 :param callback function: The callback function 4183 for asynchronous request. (optional) 4184 :param str account_id: The external account number (int) or account ID Guid. (required) 4185 :return: ENoteConfiguration 4186 If the method is called asynchronously, 4187 returns the request thread. 4188 """ 4189 kwargs['_return_http_data_only'] = True 4190 if kwargs.get('callback'): 4191 return self.get_e_note_configuration_with_http_info(account_id, **kwargs) 4192 else: 4193 (data) = self.get_e_note_configuration_with_http_info(account_id, **kwargs) 4194 return data 4195 4196 def get_e_note_configuration_with_http_info(self, account_id, **kwargs): 4197 """ 4198 Returns the configuration information for the eNote eOriginal integration. 4199 4200 This method makes a synchronous HTTP request by default. To make an 4201 asynchronous HTTP request, please define a `callback` function 4202 to be invoked when receiving the response. 4203 >>> def callback_function(response): 4204 >>> pprint(response) 4205 >>> 4206 >>> thread = api.get_e_note_configuration_with_http_info(account_id, callback=callback_function) 4207 4208 :param callback function: The callback function 4209 for asynchronous request. (optional) 4210 :param str account_id: The external account number (int) or account ID Guid. (required) 4211 :return: ENoteConfiguration 4212 If the method is called asynchronously, 4213 returns the request thread. 4214 """ 4215 4216 all_params = ['account_id'] 4217 all_params.append('callback') 4218 all_params.append('_return_http_data_only') 4219 all_params.append('_preload_content') 4220 all_params.append('_request_timeout') 4221 4222 params = locals() 4223 for key, val in iteritems(params['kwargs']): 4224 if key not in all_params: 4225 raise TypeError( 4226 "Got an unexpected keyword argument '%s'" 4227 " to method get_e_note_configuration" % key 4228 ) 4229 params[key] = val 4230 del params['kwargs'] 4231 # verify the required parameter 'account_id' is set 4232 if ('account_id' not in params) or (params['account_id'] is None): 4233 raise ValueError("Missing the required parameter `account_id` when calling `get_e_note_configuration`") 4234 4235 4236 collection_formats = {} 4237 4238 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 4239 path_params = {} 4240 if 'account_id' in params: 4241 path_params['accountId'] = params['account_id'] 4242 4243 query_params = {} 4244 4245 header_params = {} 4246 4247 form_params = [] 4248 local_var_files = {} 4249 4250 body_params = None 4251 # HTTP header `Accept` 4252 header_params['Accept'] = self.api_client.\ 4253 select_header_accept(['application/json']) 4254 4255 # Authentication setting 4256 auth_settings = [] 4257 4258 return self.api_client.call_api(resource_path, 'GET', 4259 path_params, 4260 query_params, 4261 header_params, 4262 body=body_params, 4263 post_params=form_params, 4264 files=local_var_files, 4265 response_type='ENoteConfiguration', 4266 auth_settings=auth_settings, 4267 callback=params.get('callback'), 4268 _return_http_data_only=params.get('_return_http_data_only'), 4269 _preload_content=params.get('_preload_content', True), 4270 _request_timeout=params.get('_request_timeout'), 4271 collection_formats=collection_formats) 4272 4273 def get_envelope_purge_configuration(self, account_id, **kwargs): 4274 """ 4275 Select envelope purge configuration. 4276 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. 4277 This method makes a synchronous HTTP request by default. To make an 4278 asynchronous HTTP request, please define a `callback` function 4279 to be invoked when receiving the response. 4280 >>> def callback_function(response): 4281 >>> pprint(response) 4282 >>> 4283 >>> thread = api.get_envelope_purge_configuration(account_id, callback=callback_function) 4284 4285 :param callback function: The callback function 4286 for asynchronous request. (optional) 4287 :param str account_id: The external account number (int) or account ID Guid. (required) 4288 :return: EnvelopePurgeConfiguration 4289 If the method is called asynchronously, 4290 returns the request thread. 4291 """ 4292 kwargs['_return_http_data_only'] = True 4293 if kwargs.get('callback'): 4294 return self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs) 4295 else: 4296 (data) = self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs) 4297 return data 4298 4299 def get_envelope_purge_configuration_with_http_info(self, account_id, **kwargs): 4300 """ 4301 Select envelope purge configuration. 4302 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. 4303 This method makes a synchronous HTTP request by default. To make an 4304 asynchronous HTTP request, please define a `callback` function 4305 to be invoked when receiving the response. 4306 >>> def callback_function(response): 4307 >>> pprint(response) 4308 >>> 4309 >>> thread = api.get_envelope_purge_configuration_with_http_info(account_id, callback=callback_function) 4310 4311 :param callback function: The callback function 4312 for asynchronous request. (optional) 4313 :param str account_id: The external account number (int) or account ID Guid. (required) 4314 :return: EnvelopePurgeConfiguration 4315 If the method is called asynchronously, 4316 returns the request thread. 4317 """ 4318 4319 all_params = ['account_id'] 4320 all_params.append('callback') 4321 all_params.append('_return_http_data_only') 4322 all_params.append('_preload_content') 4323 all_params.append('_request_timeout') 4324 4325 params = locals() 4326 for key, val in iteritems(params['kwargs']): 4327 if key not in all_params: 4328 raise TypeError( 4329 "Got an unexpected keyword argument '%s'" 4330 " to method get_envelope_purge_configuration" % key 4331 ) 4332 params[key] = val 4333 del params['kwargs'] 4334 # verify the required parameter 'account_id' is set 4335 if ('account_id' not in params) or (params['account_id'] is None): 4336 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_purge_configuration`") 4337 4338 4339 collection_formats = {} 4340 4341 resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json') 4342 path_params = {} 4343 if 'account_id' in params: 4344 path_params['accountId'] = params['account_id'] 4345 4346 query_params = {} 4347 4348 header_params = {} 4349 4350 form_params = [] 4351 local_var_files = {} 4352 4353 body_params = None 4354 # HTTP header `Accept` 4355 header_params['Accept'] = self.api_client.\ 4356 select_header_accept(['application/json']) 4357 4358 # Authentication setting 4359 auth_settings = [] 4360 4361 return self.api_client.call_api(resource_path, 'GET', 4362 path_params, 4363 query_params, 4364 header_params, 4365 body=body_params, 4366 post_params=form_params, 4367 files=local_var_files, 4368 response_type='EnvelopePurgeConfiguration', 4369 auth_settings=auth_settings, 4370 callback=params.get('callback'), 4371 _return_http_data_only=params.get('_return_http_data_only'), 4372 _preload_content=params.get('_preload_content', True), 4373 _request_timeout=params.get('_request_timeout'), 4374 collection_formats=collection_formats) 4375 4376 def get_favorite_templates(self, account_id, **kwargs): 4377 """ 4378 Retrieves the list of favorited templates for this caller 4379 4380 This method makes a synchronous HTTP request by default. To make an 4381 asynchronous HTTP request, please define a `callback` function 4382 to be invoked when receiving the response. 4383 >>> def callback_function(response): 4384 >>> pprint(response) 4385 >>> 4386 >>> thread = api.get_favorite_templates(account_id, callback=callback_function) 4387 4388 :param callback function: The callback function 4389 for asynchronous request. (optional) 4390 :param str account_id: The external account number (int) or account ID Guid. (required) 4391 :return: FavoriteTemplatesInfo 4392 If the method is called asynchronously, 4393 returns the request thread. 4394 """ 4395 kwargs['_return_http_data_only'] = True 4396 if kwargs.get('callback'): 4397 return self.get_favorite_templates_with_http_info(account_id, **kwargs) 4398 else: 4399 (data) = self.get_favorite_templates_with_http_info(account_id, **kwargs) 4400 return data 4401 4402 def get_favorite_templates_with_http_info(self, account_id, **kwargs): 4403 """ 4404 Retrieves the list of favorited templates for this caller 4405 4406 This method makes a synchronous HTTP request by default. To make an 4407 asynchronous HTTP request, please define a `callback` function 4408 to be invoked when receiving the response. 4409 >>> def callback_function(response): 4410 >>> pprint(response) 4411 >>> 4412 >>> thread = api.get_favorite_templates_with_http_info(account_id, callback=callback_function) 4413 4414 :param callback function: The callback function 4415 for asynchronous request. (optional) 4416 :param str account_id: The external account number (int) or account ID Guid. (required) 4417 :return: FavoriteTemplatesInfo 4418 If the method is called asynchronously, 4419 returns the request thread. 4420 """ 4421 4422 all_params = ['account_id'] 4423 all_params.append('callback') 4424 all_params.append('_return_http_data_only') 4425 all_params.append('_preload_content') 4426 all_params.append('_request_timeout') 4427 4428 params = locals() 4429 for key, val in iteritems(params['kwargs']): 4430 if key not in all_params: 4431 raise TypeError( 4432 "Got an unexpected keyword argument '%s'" 4433 " to method get_favorite_templates" % key 4434 ) 4435 params[key] = val 4436 del params['kwargs'] 4437 # verify the required parameter 'account_id' is set 4438 if ('account_id' not in params) or (params['account_id'] is None): 4439 raise ValueError("Missing the required parameter `account_id` when calling `get_favorite_templates`") 4440 4441 4442 collection_formats = {} 4443 4444 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 4445 path_params = {} 4446 if 'account_id' in params: 4447 path_params['accountId'] = params['account_id'] 4448 4449 query_params = {} 4450 4451 header_params = {} 4452 4453 form_params = [] 4454 local_var_files = {} 4455 4456 body_params = None 4457 # HTTP header `Accept` 4458 header_params['Accept'] = self.api_client.\ 4459 select_header_accept(['application/json']) 4460 4461 # Authentication setting 4462 auth_settings = [] 4463 4464 return self.api_client.call_api(resource_path, 'GET', 4465 path_params, 4466 query_params, 4467 header_params, 4468 body=body_params, 4469 post_params=form_params, 4470 files=local_var_files, 4471 response_type='FavoriteTemplatesInfo', 4472 auth_settings=auth_settings, 4473 callback=params.get('callback'), 4474 _return_http_data_only=params.get('_return_http_data_only'), 4475 _preload_content=params.get('_preload_content', True), 4476 _request_timeout=params.get('_request_timeout'), 4477 collection_formats=collection_formats) 4478 4479 def get_notification_defaults(self, account_id, **kwargs): 4480 """ 4481 Returns default user level settings for a specified account 4482 This method returns the default settings for the email notifications that signers and senders receive about envelopes. 4483 This method makes a synchronous HTTP request by default. To make an 4484 asynchronous HTTP request, please define a `callback` function 4485 to be invoked when receiving the response. 4486 >>> def callback_function(response): 4487 >>> pprint(response) 4488 >>> 4489 >>> thread = api.get_notification_defaults(account_id, callback=callback_function) 4490 4491 :param callback function: The callback function 4492 for asynchronous request. (optional) 4493 :param str account_id: The external account number (int) or account ID Guid. (required) 4494 :return: NotificationDefaults 4495 If the method is called asynchronously, 4496 returns the request thread. 4497 """ 4498 kwargs['_return_http_data_only'] = True 4499 if kwargs.get('callback'): 4500 return self.get_notification_defaults_with_http_info(account_id, **kwargs) 4501 else: 4502 (data) = self.get_notification_defaults_with_http_info(account_id, **kwargs) 4503 return data 4504 4505 def get_notification_defaults_with_http_info(self, account_id, **kwargs): 4506 """ 4507 Returns default user level settings for a specified account 4508 This method returns the default settings for the email notifications that signers and senders receive about envelopes. 4509 This method makes a synchronous HTTP request by default. To make an 4510 asynchronous HTTP request, please define a `callback` function 4511 to be invoked when receiving the response. 4512 >>> def callback_function(response): 4513 >>> pprint(response) 4514 >>> 4515 >>> thread = api.get_notification_defaults_with_http_info(account_id, callback=callback_function) 4516 4517 :param callback function: The callback function 4518 for asynchronous request. (optional) 4519 :param str account_id: The external account number (int) or account ID Guid. (required) 4520 :return: NotificationDefaults 4521 If the method is called asynchronously, 4522 returns the request thread. 4523 """ 4524 4525 all_params = ['account_id'] 4526 all_params.append('callback') 4527 all_params.append('_return_http_data_only') 4528 all_params.append('_preload_content') 4529 all_params.append('_request_timeout') 4530 4531 params = locals() 4532 for key, val in iteritems(params['kwargs']): 4533 if key not in all_params: 4534 raise TypeError( 4535 "Got an unexpected keyword argument '%s'" 4536 " to method get_notification_defaults" % key 4537 ) 4538 params[key] = val 4539 del params['kwargs'] 4540 # verify the required parameter 'account_id' is set 4541 if ('account_id' not in params) or (params['account_id'] is None): 4542 raise ValueError("Missing the required parameter `account_id` when calling `get_notification_defaults`") 4543 4544 4545 collection_formats = {} 4546 4547 resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json') 4548 path_params = {} 4549 if 'account_id' in params: 4550 path_params['accountId'] = params['account_id'] 4551 4552 query_params = {} 4553 4554 header_params = {} 4555 4556 form_params = [] 4557 local_var_files = {} 4558 4559 body_params = None 4560 # HTTP header `Accept` 4561 header_params['Accept'] = self.api_client.\ 4562 select_header_accept(['application/json']) 4563 4564 # Authentication setting 4565 auth_settings = [] 4566 4567 return self.api_client.call_api(resource_path, 'GET', 4568 path_params, 4569 query_params, 4570 header_params, 4571 body=body_params, 4572 post_params=form_params, 4573 files=local_var_files, 4574 response_type='NotificationDefaults', 4575 auth_settings=auth_settings, 4576 callback=params.get('callback'), 4577 _return_http_data_only=params.get('_return_http_data_only'), 4578 _preload_content=params.get('_preload_content', True), 4579 _request_timeout=params.get('_request_timeout'), 4580 collection_formats=collection_formats) 4581 4582 def get_password_rules(self, account_id, **kwargs): 4583 """ 4584 Get the password rules 4585 This method retrieves the password rules for an account. 4586 This method makes a synchronous HTTP request by default. To make an 4587 asynchronous HTTP request, please define a `callback` function 4588 to be invoked when receiving the response. 4589 >>> def callback_function(response): 4590 >>> pprint(response) 4591 >>> 4592 >>> thread = api.get_password_rules(account_id, callback=callback_function) 4593 4594 :param callback function: The callback function 4595 for asynchronous request. (optional) 4596 :param str account_id: The external account number (int) or account ID Guid. (required) 4597 :return: AccountPasswordRules 4598 If the method is called asynchronously, 4599 returns the request thread. 4600 """ 4601 kwargs['_return_http_data_only'] = True 4602 if kwargs.get('callback'): 4603 return self.get_password_rules_with_http_info(account_id, **kwargs) 4604 else: 4605 (data) = self.get_password_rules_with_http_info(account_id, **kwargs) 4606 return data 4607 4608 def get_password_rules_with_http_info(self, account_id, **kwargs): 4609 """ 4610 Get the password rules 4611 This method retrieves the password rules for an account. 4612 This method makes a synchronous HTTP request by default. To make an 4613 asynchronous HTTP request, please define a `callback` function 4614 to be invoked when receiving the response. 4615 >>> def callback_function(response): 4616 >>> pprint(response) 4617 >>> 4618 >>> thread = api.get_password_rules_with_http_info(account_id, callback=callback_function) 4619 4620 :param callback function: The callback function 4621 for asynchronous request. (optional) 4622 :param str account_id: The external account number (int) or account ID Guid. (required) 4623 :return: AccountPasswordRules 4624 If the method is called asynchronously, 4625 returns the request thread. 4626 """ 4627 4628 all_params = ['account_id'] 4629 all_params.append('callback') 4630 all_params.append('_return_http_data_only') 4631 all_params.append('_preload_content') 4632 all_params.append('_request_timeout') 4633 4634 params = locals() 4635 for key, val in iteritems(params['kwargs']): 4636 if key not in all_params: 4637 raise TypeError( 4638 "Got an unexpected keyword argument '%s'" 4639 " to method get_password_rules" % key 4640 ) 4641 params[key] = val 4642 del params['kwargs'] 4643 # verify the required parameter 'account_id' is set 4644 if ('account_id' not in params) or (params['account_id'] is None): 4645 raise ValueError("Missing the required parameter `account_id` when calling `get_password_rules`") 4646 4647 4648 collection_formats = {} 4649 4650 resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json') 4651 path_params = {} 4652 if 'account_id' in params: 4653 path_params['accountId'] = params['account_id'] 4654 4655 query_params = {} 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='AccountPasswordRules', 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_password_rules_0(self, **kwargs): 4686 """ 4687 Get membership account password rules 4688 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_password_rules_0(callback=callback_function) 4696 4697 :param callback function: The callback function 4698 for asynchronous request. (optional) 4699 :return: UserPasswordRules 4700 If the method is called asynchronously, 4701 returns the request thread. 4702 """ 4703 kwargs['_return_http_data_only'] = True 4704 if kwargs.get('callback'): 4705 return self.get_password_rules_0_with_http_info(**kwargs) 4706 else: 4707 (data) = self.get_password_rules_0_with_http_info(**kwargs) 4708 return data 4709 4710 def get_password_rules_0_with_http_info(self, **kwargs): 4711 """ 4712 Get membership account password rules 4713 4714 This method makes a synchronous HTTP request by default. To make an 4715 asynchronous HTTP request, please define a `callback` function 4716 to be invoked when receiving the response. 4717 >>> def callback_function(response): 4718 >>> pprint(response) 4719 >>> 4720 >>> thread = api.get_password_rules_0_with_http_info(callback=callback_function) 4721 4722 :param callback function: The callback function 4723 for asynchronous request. (optional) 4724 :return: UserPasswordRules 4725 If the method is called asynchronously, 4726 returns the request thread. 4727 """ 4728 4729 all_params = [] 4730 all_params.append('callback') 4731 all_params.append('_return_http_data_only') 4732 all_params.append('_preload_content') 4733 all_params.append('_request_timeout') 4734 4735 params = locals() 4736 for key, val in iteritems(params['kwargs']): 4737 if key not in all_params: 4738 raise TypeError( 4739 "Got an unexpected keyword argument '%s'" 4740 " to method get_password_rules_0" % key 4741 ) 4742 params[key] = val 4743 del params['kwargs'] 4744 4745 collection_formats = {} 4746 4747 resource_path = '/v2.1/current_user/password_rules'.replace('{format}', 'json') 4748 path_params = {} 4749 4750 query_params = {} 4751 4752 header_params = {} 4753 4754 form_params = [] 4755 local_var_files = {} 4756 4757 body_params = None 4758 # HTTP header `Accept` 4759 header_params['Accept'] = self.api_client.\ 4760 select_header_accept(['application/json']) 4761 4762 # Authentication setting 4763 auth_settings = [] 4764 4765 return self.api_client.call_api(resource_path, 'GET', 4766 path_params, 4767 query_params, 4768 header_params, 4769 body=body_params, 4770 post_params=form_params, 4771 files=local_var_files, 4772 response_type='UserPasswordRules', 4773 auth_settings=auth_settings, 4774 callback=params.get('callback'), 4775 _return_http_data_only=params.get('_return_http_data_only'), 4776 _preload_content=params.get('_preload_content', True), 4777 _request_timeout=params.get('_request_timeout'), 4778 collection_formats=collection_formats) 4779 4780 def get_permission_profile(self, account_id, permission_profile_id, **kwargs): 4781 """ 4782 Returns a permissions profile in the specified account. 4783 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/) 4784 This method makes a synchronous HTTP request by default. To make an 4785 asynchronous HTTP request, please define a `callback` function 4786 to be invoked when receiving the response. 4787 >>> def callback_function(response): 4788 >>> pprint(response) 4789 >>> 4790 >>> thread = api.get_permission_profile(account_id, permission_profile_id, callback=callback_function) 4791 4792 :param callback function: The callback function 4793 for asynchronous request. (optional) 4794 :param str account_id: The external account number (int) or account ID Guid. (required) 4795 :param str permission_profile_id: (required) 4796 :param str include: 4797 :return: PermissionProfile 4798 If the method is called asynchronously, 4799 returns the request thread. 4800 """ 4801 kwargs['_return_http_data_only'] = True 4802 if kwargs.get('callback'): 4803 return self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 4804 else: 4805 (data) = self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 4806 return data 4807 4808 def get_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 4809 """ 4810 Returns a permissions profile in the specified account. 4811 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/) 4812 This method makes a synchronous HTTP request by default. To make an 4813 asynchronous HTTP request, please define a `callback` function 4814 to be invoked when receiving the response. 4815 >>> def callback_function(response): 4816 >>> pprint(response) 4817 >>> 4818 >>> thread = api.get_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 4819 4820 :param callback function: The callback function 4821 for asynchronous request. (optional) 4822 :param str account_id: The external account number (int) or account ID Guid. (required) 4823 :param str permission_profile_id: (required) 4824 :param str include: 4825 :return: PermissionProfile 4826 If the method is called asynchronously, 4827 returns the request thread. 4828 """ 4829 4830 all_params = ['account_id', 'permission_profile_id', 'include'] 4831 all_params.append('callback') 4832 all_params.append('_return_http_data_only') 4833 all_params.append('_preload_content') 4834 all_params.append('_request_timeout') 4835 4836 params = locals() 4837 for key, val in iteritems(params['kwargs']): 4838 if key not in all_params: 4839 raise TypeError( 4840 "Got an unexpected keyword argument '%s'" 4841 " to method get_permission_profile" % key 4842 ) 4843 params[key] = val 4844 del params['kwargs'] 4845 # verify the required parameter 'account_id' is set 4846 if ('account_id' not in params) or (params['account_id'] is None): 4847 raise ValueError("Missing the required parameter `account_id` when calling `get_permission_profile`") 4848 # verify the required parameter 'permission_profile_id' is set 4849 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 4850 raise ValueError("Missing the required parameter `permission_profile_id` when calling `get_permission_profile`") 4851 4852 4853 collection_formats = {} 4854 4855 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 4856 path_params = {} 4857 if 'account_id' in params: 4858 path_params['accountId'] = params['account_id'] 4859 if 'permission_profile_id' in params: 4860 path_params['permissionProfileId'] = params['permission_profile_id'] 4861 4862 query_params = {} 4863 if 'include' in params: 4864 query_params['include'] = params['include'] 4865 4866 header_params = {} 4867 4868 form_params = [] 4869 local_var_files = {} 4870 4871 body_params = None 4872 # HTTP header `Accept` 4873 header_params['Accept'] = self.api_client.\ 4874 select_header_accept(['application/json']) 4875 4876 # Authentication setting 4877 auth_settings = [] 4878 4879 return self.api_client.call_api(resource_path, 'GET', 4880 path_params, 4881 query_params, 4882 header_params, 4883 body=body_params, 4884 post_params=form_params, 4885 files=local_var_files, 4886 response_type='PermissionProfile', 4887 auth_settings=auth_settings, 4888 callback=params.get('callback'), 4889 _return_http_data_only=params.get('_return_http_data_only'), 4890 _preload_content=params.get('_preload_content', True), 4891 _request_timeout=params.get('_request_timeout'), 4892 collection_formats=collection_formats) 4893 4894 def get_principal_user_authorizations(self, account_id, user_id, **kwargs): 4895 """ 4896 Returns the principal user authorizations 4897 This method makes a synchronous HTTP request by default. To make an 4898 asynchronous HTTP request, please define a `callback` function 4899 to be invoked when receiving the response. 4900 >>> def callback_function(response): 4901 >>> pprint(response) 4902 >>> 4903 >>> thread = api.get_principal_user_authorizations(account_id, user_id, callback=callback_function) 4904 4905 :param callback function: The callback function 4906 for asynchronous request. (optional) 4907 :param str account_id: The external account number (int) or account ID Guid. (required) 4908 :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) 4909 :param str active_only: 4910 :param str count: 4911 :param str email_substring: Part (substring) of email we are searching for. 4912 :param str include_closed_users: 4913 :param str permissions: 4914 :param str start_position: 4915 :param str user_name_substring: 4916 :return: UserAuthorizations 4917 If the method is called asynchronously, 4918 returns the request thread. 4919 """ 4920 kwargs['_return_http_data_only'] = True 4921 if kwargs.get('callback'): 4922 return self.get_principal_user_authorizations_with_http_info(account_id, user_id, **kwargs) 4923 else: 4924 (data) = self.get_principal_user_authorizations_with_http_info(account_id, user_id, **kwargs) 4925 return data 4926 4927 def get_principal_user_authorizations_with_http_info(self, account_id, user_id, **kwargs): 4928 """ 4929 Returns the principal user authorizations 4930 This method makes a synchronous HTTP request by default. To make an 4931 asynchronous HTTP request, please define a `callback` function 4932 to be invoked when receiving the response. 4933 >>> def callback_function(response): 4934 >>> pprint(response) 4935 >>> 4936 >>> thread = api.get_principal_user_authorizations_with_http_info(account_id, user_id, callback=callback_function) 4937 4938 :param callback function: The callback function 4939 for asynchronous request. (optional) 4940 :param str account_id: The external account number (int) or account ID Guid. (required) 4941 :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) 4942 :param str active_only: 4943 :param str count: 4944 :param str email_substring: Part (substring) of email we are searching for. 4945 :param str include_closed_users: 4946 :param str permissions: 4947 :param str start_position: 4948 :param str user_name_substring: 4949 :return: UserAuthorizations 4950 If the method is called asynchronously, 4951 returns the request thread. 4952 """ 4953 4954 all_params = ['account_id', 'user_id', 'active_only', 'count', 'email_substring', 'include_closed_users', 'permissions', 'start_position', 'user_name_substring'] 4955 all_params.append('callback') 4956 all_params.append('_return_http_data_only') 4957 all_params.append('_preload_content') 4958 all_params.append('_request_timeout') 4959 4960 params = locals() 4961 for key, val in iteritems(params['kwargs']): 4962 if key not in all_params: 4963 raise TypeError( 4964 "Got an unexpected keyword argument '%s'" 4965 " to method get_principal_user_authorizations" % key 4966 ) 4967 params[key] = val 4968 del params['kwargs'] 4969 # verify the required parameter 'account_id' is set 4970 if ('account_id' not in params) or (params['account_id'] is None): 4971 raise ValueError("Missing the required parameter `account_id` when calling `get_principal_user_authorizations`") 4972 # verify the required parameter 'user_id' is set 4973 if ('user_id' not in params) or (params['user_id'] is None): 4974 raise ValueError("Missing the required parameter `user_id` when calling `get_principal_user_authorizations`") 4975 4976 4977 collection_formats = {} 4978 4979 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorizations'.replace('{format}', 'json') 4980 path_params = {} 4981 if 'account_id' in params: 4982 path_params['accountId'] = params['account_id'] 4983 if 'user_id' in params: 4984 path_params['userId'] = params['user_id'] 4985 4986 query_params = {} 4987 if 'active_only' in params: 4988 query_params['active_only'] = params['active_only'] 4989 if 'count' in params: 4990 query_params['count'] = params['count'] 4991 if 'email_substring' in params: 4992 query_params['email_substring'] = params['email_substring'] 4993 if 'include_closed_users' in params: 4994 query_params['include_closed_users'] = params['include_closed_users'] 4995 if 'permissions' in params: 4996 query_params['permissions'] = params['permissions'] 4997 if 'start_position' in params: 4998 query_params['start_position'] = params['start_position'] 4999 if 'user_name_substring' in params: 5000 query_params['user_name_substring'] = params['user_name_substring'] 5001 5002 header_params = {} 5003 5004 form_params = [] 5005 local_var_files = {} 5006 5007 body_params = None 5008 # HTTP header `Accept` 5009 header_params['Accept'] = self.api_client.\ 5010 select_header_accept(['application/json']) 5011 5012 # Authentication setting 5013 auth_settings = [] 5014 5015 return self.api_client.call_api(resource_path, 'GET', 5016 path_params, 5017 query_params, 5018 header_params, 5019 body=body_params, 5020 post_params=form_params, 5021 files=local_var_files, 5022 response_type='UserAuthorizations', 5023 auth_settings=auth_settings, 5024 callback=params.get('callback'), 5025 _return_http_data_only=params.get('_return_http_data_only'), 5026 _preload_content=params.get('_preload_content', True), 5027 _request_timeout=params.get('_request_timeout'), 5028 collection_formats=collection_formats) 5029 5030 def get_provisioning(self, **kwargs): 5031 """ 5032 Retrieves the account provisioning information for the account. 5033 Retrieves the account provisioning information for the account. 5034 This method makes a synchronous HTTP request by default. To make an 5035 asynchronous HTTP request, please define a `callback` function 5036 to be invoked when receiving the response. 5037 >>> def callback_function(response): 5038 >>> pprint(response) 5039 >>> 5040 >>> thread = api.get_provisioning(callback=callback_function) 5041 5042 :param callback function: The callback function 5043 for asynchronous request. (optional) 5044 :return: ProvisioningInformation 5045 If the method is called asynchronously, 5046 returns the request thread. 5047 """ 5048 kwargs['_return_http_data_only'] = True 5049 if kwargs.get('callback'): 5050 return self.get_provisioning_with_http_info(**kwargs) 5051 else: 5052 (data) = self.get_provisioning_with_http_info(**kwargs) 5053 return data 5054 5055 def get_provisioning_with_http_info(self, **kwargs): 5056 """ 5057 Retrieves the account provisioning information for the account. 5058 Retrieves the account provisioning information for the account. 5059 This method makes a synchronous HTTP request by default. To make an 5060 asynchronous HTTP request, please define a `callback` function 5061 to be invoked when receiving the response. 5062 >>> def callback_function(response): 5063 >>> pprint(response) 5064 >>> 5065 >>> thread = api.get_provisioning_with_http_info(callback=callback_function) 5066 5067 :param callback function: The callback function 5068 for asynchronous request. (optional) 5069 :return: ProvisioningInformation 5070 If the method is called asynchronously, 5071 returns the request thread. 5072 """ 5073 5074 all_params = [] 5075 all_params.append('callback') 5076 all_params.append('_return_http_data_only') 5077 all_params.append('_preload_content') 5078 all_params.append('_request_timeout') 5079 5080 params = locals() 5081 for key, val in iteritems(params['kwargs']): 5082 if key not in all_params: 5083 raise TypeError( 5084 "Got an unexpected keyword argument '%s'" 5085 " to method get_provisioning" % key 5086 ) 5087 params[key] = val 5088 del params['kwargs'] 5089 5090 collection_formats = {} 5091 5092 resource_path = '/v2.1/accounts/provisioning'.replace('{format}', 'json') 5093 path_params = {} 5094 5095 query_params = {} 5096 5097 header_params = {} 5098 5099 form_params = [] 5100 local_var_files = {} 5101 5102 body_params = None 5103 # HTTP header `Accept` 5104 header_params['Accept'] = self.api_client.\ 5105 select_header_accept(['application/json']) 5106 5107 # Authentication setting 5108 auth_settings = [] 5109 5110 return self.api_client.call_api(resource_path, 'GET', 5111 path_params, 5112 query_params, 5113 header_params, 5114 body=body_params, 5115 post_params=form_params, 5116 files=local_var_files, 5117 response_type='ProvisioningInformation', 5118 auth_settings=auth_settings, 5119 callback=params.get('callback'), 5120 _return_http_data_only=params.get('_return_http_data_only'), 5121 _preload_content=params.get('_preload_content', True), 5122 _request_timeout=params.get('_request_timeout'), 5123 collection_formats=collection_formats) 5124 5125 def get_supported_languages(self, account_id, **kwargs): 5126 """ 5127 Gets list of supported languages for recipient language setting. 5128 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). 5129 This method makes a synchronous HTTP request by default. To make an 5130 asynchronous HTTP request, please define a `callback` function 5131 to be invoked when receiving the response. 5132 >>> def callback_function(response): 5133 >>> pprint(response) 5134 >>> 5135 >>> thread = api.get_supported_languages(account_id, callback=callback_function) 5136 5137 :param callback function: The callback function 5138 for asynchronous request. (optional) 5139 :param str account_id: The external account number (int) or account ID Guid. (required) 5140 :return: SupportedLanguages 5141 If the method is called asynchronously, 5142 returns the request thread. 5143 """ 5144 kwargs['_return_http_data_only'] = True 5145 if kwargs.get('callback'): 5146 return self.get_supported_languages_with_http_info(account_id, **kwargs) 5147 else: 5148 (data) = self.get_supported_languages_with_http_info(account_id, **kwargs) 5149 return data 5150 5151 def get_supported_languages_with_http_info(self, account_id, **kwargs): 5152 """ 5153 Gets list of supported languages for recipient language setting. 5154 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). 5155 This method makes a synchronous HTTP request by default. To make an 5156 asynchronous HTTP request, please define a `callback` function 5157 to be invoked when receiving the response. 5158 >>> def callback_function(response): 5159 >>> pprint(response) 5160 >>> 5161 >>> thread = api.get_supported_languages_with_http_info(account_id, callback=callback_function) 5162 5163 :param callback function: The callback function 5164 for asynchronous request. (optional) 5165 :param str account_id: The external account number (int) or account ID Guid. (required) 5166 :return: SupportedLanguages 5167 If the method is called asynchronously, 5168 returns the request thread. 5169 """ 5170 5171 all_params = ['account_id'] 5172 all_params.append('callback') 5173 all_params.append('_return_http_data_only') 5174 all_params.append('_preload_content') 5175 all_params.append('_request_timeout') 5176 5177 params = locals() 5178 for key, val in iteritems(params['kwargs']): 5179 if key not in all_params: 5180 raise TypeError( 5181 "Got an unexpected keyword argument '%s'" 5182 " to method get_supported_languages" % key 5183 ) 5184 params[key] = val 5185 del params['kwargs'] 5186 # verify the required parameter 'account_id' is set 5187 if ('account_id' not in params) or (params['account_id'] is None): 5188 raise ValueError("Missing the required parameter `account_id` when calling `get_supported_languages`") 5189 5190 5191 collection_formats = {} 5192 5193 resource_path = '/v2.1/accounts/{accountId}/supported_languages'.replace('{format}', 'json') 5194 path_params = {} 5195 if 'account_id' in params: 5196 path_params['accountId'] = params['account_id'] 5197 5198 query_params = {} 5199 5200 header_params = {} 5201 5202 form_params = [] 5203 local_var_files = {} 5204 5205 body_params = None 5206 # HTTP header `Accept` 5207 header_params['Accept'] = self.api_client.\ 5208 select_header_accept(['application/json']) 5209 5210 # Authentication setting 5211 auth_settings = [] 5212 5213 return self.api_client.call_api(resource_path, 'GET', 5214 path_params, 5215 query_params, 5216 header_params, 5217 body=body_params, 5218 post_params=form_params, 5219 files=local_var_files, 5220 response_type='SupportedLanguages', 5221 auth_settings=auth_settings, 5222 callback=params.get('callback'), 5223 _return_http_data_only=params.get('_return_http_data_only'), 5224 _preload_content=params.get('_preload_content', True), 5225 _request_timeout=params.get('_request_timeout'), 5226 collection_formats=collection_formats) 5227 5228 def get_user_authorization(self, account_id, authorization_id, user_id, **kwargs): 5229 """ 5230 Returns the user authorization for a given authorization id 5231 This method makes a synchronous HTTP request by default. To make an 5232 asynchronous HTTP request, please define a `callback` function 5233 to be invoked when receiving the response. 5234 >>> def callback_function(response): 5235 >>> pprint(response) 5236 >>> 5237 >>> thread = api.get_user_authorization(account_id, authorization_id, user_id, callback=callback_function) 5238 5239 :param callback function: The callback function 5240 for asynchronous request. (optional) 5241 :param str account_id: The external account number (int) or account ID Guid. (required) 5242 :param str authorization_id: (required) 5243 :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) 5244 :return: UserAuthorization 5245 If the method is called asynchronously, 5246 returns the request thread. 5247 """ 5248 kwargs['_return_http_data_only'] = True 5249 if kwargs.get('callback'): 5250 return self.get_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 5251 else: 5252 (data) = self.get_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 5253 return data 5254 5255 def get_user_authorization_with_http_info(self, account_id, authorization_id, user_id, **kwargs): 5256 """ 5257 Returns the user authorization for a given authorization id 5258 This method makes a synchronous HTTP request by default. To make an 5259 asynchronous HTTP request, please define a `callback` function 5260 to be invoked when receiving the response. 5261 >>> def callback_function(response): 5262 >>> pprint(response) 5263 >>> 5264 >>> thread = api.get_user_authorization_with_http_info(account_id, authorization_id, user_id, callback=callback_function) 5265 5266 :param callback function: The callback function 5267 for asynchronous request. (optional) 5268 :param str account_id: The external account number (int) or account ID Guid. (required) 5269 :param str authorization_id: (required) 5270 :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) 5271 :return: UserAuthorization 5272 If the method is called asynchronously, 5273 returns the request thread. 5274 """ 5275 5276 all_params = ['account_id', 'authorization_id', 'user_id'] 5277 all_params.append('callback') 5278 all_params.append('_return_http_data_only') 5279 all_params.append('_preload_content') 5280 all_params.append('_request_timeout') 5281 5282 params = locals() 5283 for key, val in iteritems(params['kwargs']): 5284 if key not in all_params: 5285 raise TypeError( 5286 "Got an unexpected keyword argument '%s'" 5287 " to method get_user_authorization" % key 5288 ) 5289 params[key] = val 5290 del params['kwargs'] 5291 # verify the required parameter 'account_id' is set 5292 if ('account_id' not in params) or (params['account_id'] is None): 5293 raise ValueError("Missing the required parameter `account_id` when calling `get_user_authorization`") 5294 # verify the required parameter 'authorization_id' is set 5295 if ('authorization_id' not in params) or (params['authorization_id'] is None): 5296 raise ValueError("Missing the required parameter `authorization_id` when calling `get_user_authorization`") 5297 # verify the required parameter 'user_id' is set 5298 if ('user_id' not in params) or (params['user_id'] is None): 5299 raise ValueError("Missing the required parameter `user_id` when calling `get_user_authorization`") 5300 5301 5302 collection_formats = {} 5303 5304 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorization/{authorizationId}'.replace('{format}', 'json') 5305 path_params = {} 5306 if 'account_id' in params: 5307 path_params['accountId'] = params['account_id'] 5308 if 'authorization_id' in params: 5309 path_params['authorizationId'] = params['authorization_id'] 5310 if 'user_id' in params: 5311 path_params['userId'] = params['user_id'] 5312 5313 query_params = {} 5314 5315 header_params = {} 5316 5317 form_params = [] 5318 local_var_files = {} 5319 5320 body_params = None 5321 # HTTP header `Accept` 5322 header_params['Accept'] = self.api_client.\ 5323 select_header_accept(['application/json']) 5324 5325 # Authentication setting 5326 auth_settings = [] 5327 5328 return self.api_client.call_api(resource_path, 'GET', 5329 path_params, 5330 query_params, 5331 header_params, 5332 body=body_params, 5333 post_params=form_params, 5334 files=local_var_files, 5335 response_type='UserAuthorization', 5336 auth_settings=auth_settings, 5337 callback=params.get('callback'), 5338 _return_http_data_only=params.get('_return_http_data_only'), 5339 _preload_content=params.get('_preload_content', True), 5340 _request_timeout=params.get('_request_timeout'), 5341 collection_formats=collection_formats) 5342 5343 def get_watermark(self, account_id, **kwargs): 5344 """ 5345 Get watermark information. 5346 5347 This method makes a synchronous HTTP request by default. To make an 5348 asynchronous HTTP request, please define a `callback` function 5349 to be invoked when receiving the response. 5350 >>> def callback_function(response): 5351 >>> pprint(response) 5352 >>> 5353 >>> thread = api.get_watermark(account_id, callback=callback_function) 5354 5355 :param callback function: The callback function 5356 for asynchronous request. (optional) 5357 :param str account_id: The external account number (int) or account ID Guid. (required) 5358 :return: Watermark 5359 If the method is called asynchronously, 5360 returns the request thread. 5361 """ 5362 kwargs['_return_http_data_only'] = True 5363 if kwargs.get('callback'): 5364 return self.get_watermark_with_http_info(account_id, **kwargs) 5365 else: 5366 (data) = self.get_watermark_with_http_info(account_id, **kwargs) 5367 return data 5368 5369 def get_watermark_with_http_info(self, account_id, **kwargs): 5370 """ 5371 Get watermark information. 5372 5373 This method makes a synchronous HTTP request by default. To make an 5374 asynchronous HTTP request, please define a `callback` function 5375 to be invoked when receiving the response. 5376 >>> def callback_function(response): 5377 >>> pprint(response) 5378 >>> 5379 >>> thread = api.get_watermark_with_http_info(account_id, callback=callback_function) 5380 5381 :param callback function: The callback function 5382 for asynchronous request. (optional) 5383 :param str account_id: The external account number (int) or account ID Guid. (required) 5384 :return: Watermark 5385 If the method is called asynchronously, 5386 returns the request thread. 5387 """ 5388 5389 all_params = ['account_id'] 5390 all_params.append('callback') 5391 all_params.append('_return_http_data_only') 5392 all_params.append('_preload_content') 5393 all_params.append('_request_timeout') 5394 5395 params = locals() 5396 for key, val in iteritems(params['kwargs']): 5397 if key not in all_params: 5398 raise TypeError( 5399 "Got an unexpected keyword argument '%s'" 5400 " to method get_watermark" % key 5401 ) 5402 params[key] = val 5403 del params['kwargs'] 5404 # verify the required parameter 'account_id' is set 5405 if ('account_id' not in params) or (params['account_id'] is None): 5406 raise ValueError("Missing the required parameter `account_id` when calling `get_watermark`") 5407 5408 5409 collection_formats = {} 5410 5411 resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json') 5412 path_params = {} 5413 if 'account_id' in params: 5414 path_params['accountId'] = params['account_id'] 5415 5416 query_params = {} 5417 5418 header_params = {} 5419 5420 form_params = [] 5421 local_var_files = {} 5422 5423 body_params = None 5424 # HTTP header `Accept` 5425 header_params['Accept'] = self.api_client.\ 5426 select_header_accept(['application/json']) 5427 5428 # Authentication setting 5429 auth_settings = [] 5430 5431 return self.api_client.call_api(resource_path, 'GET', 5432 path_params, 5433 query_params, 5434 header_params, 5435 body=body_params, 5436 post_params=form_params, 5437 files=local_var_files, 5438 response_type='Watermark', 5439 auth_settings=auth_settings, 5440 callback=params.get('callback'), 5441 _return_http_data_only=params.get('_return_http_data_only'), 5442 _preload_content=params.get('_preload_content', True), 5443 _request_timeout=params.get('_request_timeout'), 5444 collection_formats=collection_formats) 5445 5446 def get_watermark_preview(self, account_id, **kwargs): 5447 """ 5448 Get watermark preview. 5449 5450 This method makes a synchronous HTTP request by default. To make an 5451 asynchronous HTTP request, please define a `callback` function 5452 to be invoked when receiving the response. 5453 >>> def callback_function(response): 5454 >>> pprint(response) 5455 >>> 5456 >>> thread = api.get_watermark_preview(account_id, callback=callback_function) 5457 5458 :param callback function: The callback function 5459 for asynchronous request. (optional) 5460 :param str account_id: The external account number (int) or account ID Guid. (required) 5461 :param Watermark watermark: 5462 :return: Watermark 5463 If the method is called asynchronously, 5464 returns the request thread. 5465 """ 5466 kwargs['_return_http_data_only'] = True 5467 if kwargs.get('callback'): 5468 return self.get_watermark_preview_with_http_info(account_id, **kwargs) 5469 else: 5470 (data) = self.get_watermark_preview_with_http_info(account_id, **kwargs) 5471 return data 5472 5473 def get_watermark_preview_with_http_info(self, account_id, **kwargs): 5474 """ 5475 Get watermark preview. 5476 5477 This method makes a synchronous HTTP request by default. To make an 5478 asynchronous HTTP request, please define a `callback` function 5479 to be invoked when receiving the response. 5480 >>> def callback_function(response): 5481 >>> pprint(response) 5482 >>> 5483 >>> thread = api.get_watermark_preview_with_http_info(account_id, callback=callback_function) 5484 5485 :param callback function: The callback function 5486 for asynchronous request. (optional) 5487 :param str account_id: The external account number (int) or account ID Guid. (required) 5488 :param Watermark watermark: 5489 :return: Watermark 5490 If the method is called asynchronously, 5491 returns the request thread. 5492 """ 5493 5494 all_params = ['account_id', 'watermark'] 5495 all_params.append('callback') 5496 all_params.append('_return_http_data_only') 5497 all_params.append('_preload_content') 5498 all_params.append('_request_timeout') 5499 5500 params = locals() 5501 for key, val in iteritems(params['kwargs']): 5502 if key not in all_params: 5503 raise TypeError( 5504 "Got an unexpected keyword argument '%s'" 5505 " to method get_watermark_preview" % key 5506 ) 5507 params[key] = val 5508 del params['kwargs'] 5509 # verify the required parameter 'account_id' is set 5510 if ('account_id' not in params) or (params['account_id'] is None): 5511 raise ValueError("Missing the required parameter `account_id` when calling `get_watermark_preview`") 5512 5513 5514 collection_formats = {} 5515 5516 resource_path = '/v2.1/accounts/{accountId}/watermark/preview'.replace('{format}', 'json') 5517 path_params = {} 5518 if 'account_id' in params: 5519 path_params['accountId'] = params['account_id'] 5520 5521 query_params = {} 5522 5523 header_params = {} 5524 5525 form_params = [] 5526 local_var_files = {} 5527 5528 body_params = None 5529 if 'watermark' in params: 5530 body_params = params['watermark'] 5531 # HTTP header `Accept` 5532 header_params['Accept'] = self.api_client.\ 5533 select_header_accept(['application/json']) 5534 5535 # Authentication setting 5536 auth_settings = [] 5537 5538 return self.api_client.call_api(resource_path, 'PUT', 5539 path_params, 5540 query_params, 5541 header_params, 5542 body=body_params, 5543 post_params=form_params, 5544 files=local_var_files, 5545 response_type='Watermark', 5546 auth_settings=auth_settings, 5547 callback=params.get('callback'), 5548 _return_http_data_only=params.get('_return_http_data_only'), 5549 _preload_content=params.get('_preload_content', True), 5550 _request_timeout=params.get('_request_timeout'), 5551 collection_formats=collection_formats) 5552 5553 def list_brands(self, account_id, **kwargs): 5554 """ 5555 Gets a list of brand profiles. 5556 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. 5557 This method makes a synchronous HTTP request by default. To make an 5558 asynchronous HTTP request, please define a `callback` function 5559 to be invoked when receiving the response. 5560 >>> def callback_function(response): 5561 >>> pprint(response) 5562 >>> 5563 >>> thread = api.list_brands(account_id, callback=callback_function) 5564 5565 :param callback function: The callback function 5566 for asynchronous request. (optional) 5567 :param str account_id: The external account number (int) or account ID Guid. (required) 5568 :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set. 5569 :param str include_logos: When set to **true**, returns the logos associated with the brand. 5570 :return: BrandsResponse 5571 If the method is called asynchronously, 5572 returns the request thread. 5573 """ 5574 kwargs['_return_http_data_only'] = True 5575 if kwargs.get('callback'): 5576 return self.list_brands_with_http_info(account_id, **kwargs) 5577 else: 5578 (data) = self.list_brands_with_http_info(account_id, **kwargs) 5579 return data 5580 5581 def list_brands_with_http_info(self, account_id, **kwargs): 5582 """ 5583 Gets a list of brand profiles. 5584 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. 5585 This method makes a synchronous HTTP request by default. To make an 5586 asynchronous HTTP request, please define a `callback` function 5587 to be invoked when receiving the response. 5588 >>> def callback_function(response): 5589 >>> pprint(response) 5590 >>> 5591 >>> thread = api.list_brands_with_http_info(account_id, callback=callback_function) 5592 5593 :param callback function: The callback function 5594 for asynchronous request. (optional) 5595 :param str account_id: The external account number (int) or account ID Guid. (required) 5596 :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set. 5597 :param str include_logos: When set to **true**, returns the logos associated with the brand. 5598 :return: BrandsResponse 5599 If the method is called asynchronously, 5600 returns the request thread. 5601 """ 5602 5603 all_params = ['account_id', 'exclude_distributor_brand', 'include_logos'] 5604 all_params.append('callback') 5605 all_params.append('_return_http_data_only') 5606 all_params.append('_preload_content') 5607 all_params.append('_request_timeout') 5608 5609 params = locals() 5610 for key, val in iteritems(params['kwargs']): 5611 if key not in all_params: 5612 raise TypeError( 5613 "Got an unexpected keyword argument '%s'" 5614 " to method list_brands" % key 5615 ) 5616 params[key] = val 5617 del params['kwargs'] 5618 # verify the required parameter 'account_id' is set 5619 if ('account_id' not in params) or (params['account_id'] is None): 5620 raise ValueError("Missing the required parameter `account_id` when calling `list_brands`") 5621 5622 5623 collection_formats = {} 5624 5625 resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json') 5626 path_params = {} 5627 if 'account_id' in params: 5628 path_params['accountId'] = params['account_id'] 5629 5630 query_params = {} 5631 if 'exclude_distributor_brand' in params: 5632 query_params['exclude_distributor_brand'] = params['exclude_distributor_brand'] 5633 if 'include_logos' in params: 5634 query_params['include_logos'] = params['include_logos'] 5635 5636 header_params = {} 5637 5638 form_params = [] 5639 local_var_files = {} 5640 5641 body_params = None 5642 # HTTP header `Accept` 5643 header_params['Accept'] = self.api_client.\ 5644 select_header_accept(['application/json']) 5645 5646 # Authentication setting 5647 auth_settings = [] 5648 5649 return self.api_client.call_api(resource_path, 'GET', 5650 path_params, 5651 query_params, 5652 header_params, 5653 body=body_params, 5654 post_params=form_params, 5655 files=local_var_files, 5656 response_type='BrandsResponse', 5657 auth_settings=auth_settings, 5658 callback=params.get('callback'), 5659 _return_http_data_only=params.get('_return_http_data_only'), 5660 _preload_content=params.get('_preload_content', True), 5661 _request_timeout=params.get('_request_timeout'), 5662 collection_formats=collection_formats) 5663 5664 def list_custom_fields(self, account_id, **kwargs): 5665 """ 5666 Gets a list of custom fields associated with the account. 5667 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. 5668 This method makes a synchronous HTTP request by default. To make an 5669 asynchronous HTTP request, please define a `callback` function 5670 to be invoked when receiving the response. 5671 >>> def callback_function(response): 5672 >>> pprint(response) 5673 >>> 5674 >>> thread = api.list_custom_fields(account_id, callback=callback_function) 5675 5676 :param callback function: The callback function 5677 for asynchronous request. (optional) 5678 :param str account_id: The external account number (int) or account ID Guid. (required) 5679 :return: CustomFields 5680 If the method is called asynchronously, 5681 returns the request thread. 5682 """ 5683 kwargs['_return_http_data_only'] = True 5684 if kwargs.get('callback'): 5685 return self.list_custom_fields_with_http_info(account_id, **kwargs) 5686 else: 5687 (data) = self.list_custom_fields_with_http_info(account_id, **kwargs) 5688 return data 5689 5690 def list_custom_fields_with_http_info(self, account_id, **kwargs): 5691 """ 5692 Gets a list of custom fields associated with the account. 5693 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. 5694 This method makes a synchronous HTTP request by default. To make an 5695 asynchronous HTTP request, please define a `callback` function 5696 to be invoked when receiving the response. 5697 >>> def callback_function(response): 5698 >>> pprint(response) 5699 >>> 5700 >>> thread = api.list_custom_fields_with_http_info(account_id, callback=callback_function) 5701 5702 :param callback function: The callback function 5703 for asynchronous request. (optional) 5704 :param str account_id: The external account number (int) or account ID Guid. (required) 5705 :return: CustomFields 5706 If the method is called asynchronously, 5707 returns the request thread. 5708 """ 5709 5710 all_params = ['account_id'] 5711 all_params.append('callback') 5712 all_params.append('_return_http_data_only') 5713 all_params.append('_preload_content') 5714 all_params.append('_request_timeout') 5715 5716 params = locals() 5717 for key, val in iteritems(params['kwargs']): 5718 if key not in all_params: 5719 raise TypeError( 5720 "Got an unexpected keyword argument '%s'" 5721 " to method list_custom_fields" % key 5722 ) 5723 params[key] = val 5724 del params['kwargs'] 5725 # verify the required parameter 'account_id' is set 5726 if ('account_id' not in params) or (params['account_id'] is None): 5727 raise ValueError("Missing the required parameter `account_id` when calling `list_custom_fields`") 5728 5729 5730 collection_formats = {} 5731 5732 resource_path = '/v2.1/accounts/{accountId}/custom_fields'.replace('{format}', 'json') 5733 path_params = {} 5734 if 'account_id' in params: 5735 path_params['accountId'] = params['account_id'] 5736 5737 query_params = {} 5738 5739 header_params = {} 5740 5741 form_params = [] 5742 local_var_files = {} 5743 5744 body_params = None 5745 # HTTP header `Accept` 5746 header_params['Accept'] = self.api_client.\ 5747 select_header_accept(['application/json']) 5748 5749 # Authentication setting 5750 auth_settings = [] 5751 5752 return self.api_client.call_api(resource_path, 'GET', 5753 path_params, 5754 query_params, 5755 header_params, 5756 body=body_params, 5757 post_params=form_params, 5758 files=local_var_files, 5759 response_type='CustomFields', 5760 auth_settings=auth_settings, 5761 callback=params.get('callback'), 5762 _return_http_data_only=params.get('_return_http_data_only'), 5763 _preload_content=params.get('_preload_content', True), 5764 _request_timeout=params.get('_request_timeout'), 5765 collection_formats=collection_formats) 5766 5767 def list_permissions(self, account_id, **kwargs): 5768 """ 5769 Gets a list of permission profiles. 5770 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. 5771 This method makes a synchronous HTTP request by default. To make an 5772 asynchronous HTTP request, please define a `callback` function 5773 to be invoked when receiving the response. 5774 >>> def callback_function(response): 5775 >>> pprint(response) 5776 >>> 5777 >>> thread = api.list_permissions(account_id, callback=callback_function) 5778 5779 :param callback function: The callback function 5780 for asynchronous request. (optional) 5781 :param str account_id: The external account number (int) or account ID Guid. (required) 5782 :param str include: 5783 :return: PermissionProfileInformation 5784 If the method is called asynchronously, 5785 returns the request thread. 5786 """ 5787 kwargs['_return_http_data_only'] = True 5788 if kwargs.get('callback'): 5789 return self.list_permissions_with_http_info(account_id, **kwargs) 5790 else: 5791 (data) = self.list_permissions_with_http_info(account_id, **kwargs) 5792 return data 5793 5794 def list_permissions_with_http_info(self, account_id, **kwargs): 5795 """ 5796 Gets a list of permission profiles. 5797 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. 5798 This method makes a synchronous HTTP request by default. To make an 5799 asynchronous HTTP request, please define a `callback` function 5800 to be invoked when receiving the response. 5801 >>> def callback_function(response): 5802 >>> pprint(response) 5803 >>> 5804 >>> thread = api.list_permissions_with_http_info(account_id, callback=callback_function) 5805 5806 :param callback function: The callback function 5807 for asynchronous request. (optional) 5808 :param str account_id: The external account number (int) or account ID Guid. (required) 5809 :param str include: 5810 :return: PermissionProfileInformation 5811 If the method is called asynchronously, 5812 returns the request thread. 5813 """ 5814 5815 all_params = ['account_id', 'include'] 5816 all_params.append('callback') 5817 all_params.append('_return_http_data_only') 5818 all_params.append('_preload_content') 5819 all_params.append('_request_timeout') 5820 5821 params = locals() 5822 for key, val in iteritems(params['kwargs']): 5823 if key not in all_params: 5824 raise TypeError( 5825 "Got an unexpected keyword argument '%s'" 5826 " to method list_permissions" % key 5827 ) 5828 params[key] = val 5829 del params['kwargs'] 5830 # verify the required parameter 'account_id' is set 5831 if ('account_id' not in params) or (params['account_id'] is None): 5832 raise ValueError("Missing the required parameter `account_id` when calling `list_permissions`") 5833 5834 5835 collection_formats = {} 5836 5837 resource_path = '/v2.1/accounts/{accountId}/permission_profiles'.replace('{format}', 'json') 5838 path_params = {} 5839 if 'account_id' in params: 5840 path_params['accountId'] = params['account_id'] 5841 5842 query_params = {} 5843 if 'include' in params: 5844 query_params['include'] = params['include'] 5845 5846 header_params = {} 5847 5848 form_params = [] 5849 local_var_files = {} 5850 5851 body_params = None 5852 # HTTP header `Accept` 5853 header_params['Accept'] = self.api_client.\ 5854 select_header_accept(['application/json']) 5855 5856 # Authentication setting 5857 auth_settings = [] 5858 5859 return self.api_client.call_api(resource_path, 'GET', 5860 path_params, 5861 query_params, 5862 header_params, 5863 body=body_params, 5864 post_params=form_params, 5865 files=local_var_files, 5866 response_type='PermissionProfileInformation', 5867 auth_settings=auth_settings, 5868 callback=params.get('callback'), 5869 _return_http_data_only=params.get('_return_http_data_only'), 5870 _preload_content=params.get('_preload_content', True), 5871 _request_timeout=params.get('_request_timeout'), 5872 collection_formats=collection_formats) 5873 5874 def list_settings(self, account_id, **kwargs): 5875 """ 5876 Gets account settings information. 5877 Retrieves the account settings information for the specified account. 5878 This method makes a synchronous HTTP request by default. To make an 5879 asynchronous HTTP request, please define a `callback` function 5880 to be invoked when receiving the response. 5881 >>> def callback_function(response): 5882 >>> pprint(response) 5883 >>> 5884 >>> thread = api.list_settings(account_id, callback=callback_function) 5885 5886 :param callback function: The callback function 5887 for asynchronous request. (optional) 5888 :param str account_id: The external account number (int) or account ID Guid. (required) 5889 :return: AccountSettingsInformation 5890 If the method is called asynchronously, 5891 returns the request thread. 5892 """ 5893 kwargs['_return_http_data_only'] = True 5894 if kwargs.get('callback'): 5895 return self.list_settings_with_http_info(account_id, **kwargs) 5896 else: 5897 (data) = self.list_settings_with_http_info(account_id, **kwargs) 5898 return data 5899 5900 def list_settings_with_http_info(self, account_id, **kwargs): 5901 """ 5902 Gets account settings information. 5903 Retrieves the account settings information for the specified account. 5904 This method makes a synchronous HTTP request by default. To make an 5905 asynchronous HTTP request, please define a `callback` function 5906 to be invoked when receiving the response. 5907 >>> def callback_function(response): 5908 >>> pprint(response) 5909 >>> 5910 >>> thread = api.list_settings_with_http_info(account_id, callback=callback_function) 5911 5912 :param callback function: The callback function 5913 for asynchronous request. (optional) 5914 :param str account_id: The external account number (int) or account ID Guid. (required) 5915 :return: AccountSettingsInformation 5916 If the method is called asynchronously, 5917 returns the request thread. 5918 """ 5919 5920 all_params = ['account_id'] 5921 all_params.append('callback') 5922 all_params.append('_return_http_data_only') 5923 all_params.append('_preload_content') 5924 all_params.append('_request_timeout') 5925 5926 params = locals() 5927 for key, val in iteritems(params['kwargs']): 5928 if key not in all_params: 5929 raise TypeError( 5930 "Got an unexpected keyword argument '%s'" 5931 " to method list_settings" % key 5932 ) 5933 params[key] = val 5934 del params['kwargs'] 5935 # verify the required parameter 'account_id' is set 5936 if ('account_id' not in params) or (params['account_id'] is None): 5937 raise ValueError("Missing the required parameter `account_id` when calling `list_settings`") 5938 5939 5940 collection_formats = {} 5941 5942 resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json') 5943 path_params = {} 5944 if 'account_id' in params: 5945 path_params['accountId'] = params['account_id'] 5946 5947 query_params = {} 5948 5949 header_params = {} 5950 5951 form_params = [] 5952 local_var_files = {} 5953 5954 body_params = None 5955 # HTTP header `Accept` 5956 header_params['Accept'] = self.api_client.\ 5957 select_header_accept(['application/json']) 5958 5959 # Authentication setting 5960 auth_settings = [] 5961 5962 return self.api_client.call_api(resource_path, 'GET', 5963 path_params, 5964 query_params, 5965 header_params, 5966 body=body_params, 5967 post_params=form_params, 5968 files=local_var_files, 5969 response_type='AccountSettingsInformation', 5970 auth_settings=auth_settings, 5971 callback=params.get('callback'), 5972 _return_http_data_only=params.get('_return_http_data_only'), 5973 _preload_content=params.get('_preload_content', True), 5974 _request_timeout=params.get('_request_timeout'), 5975 collection_formats=collection_formats) 5976 5977 def list_shared_access(self, account_id, **kwargs): 5978 """ 5979 Reserved: Gets the shared item status for one or more users. 5980 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. 5981 This method makes a synchronous HTTP request by default. To make an 5982 asynchronous HTTP request, please define a `callback` function 5983 to be invoked when receiving the response. 5984 >>> def callback_function(response): 5985 >>> pprint(response) 5986 >>> 5987 >>> thread = api.list_shared_access(account_id, callback=callback_function) 5988 5989 :param callback function: The callback function 5990 for asynchronous request. (optional) 5991 :param str account_id: The external account number (int) or account ID Guid. (required) 5992 :param str count: Specifies maximum number of results included in the response. If no value is specified, this defaults to 1000. 5993 :param str envelopes_not_shared_user_status: 5994 :param str folder_ids: 5995 :param str item_type: Specifies the type of shared item being requested. The accepted values are: -envelopes: returns information about envelope sharing between users. 5996 :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. 5997 :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 5998 :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. 5999 :param str user_ids: A comma separated list of userIds for whom the shared item information is being requested. 6000 :return: AccountSharedAccess 6001 If the method is called asynchronously, 6002 returns the request thread. 6003 """ 6004 kwargs['_return_http_data_only'] = True 6005 if kwargs.get('callback'): 6006 return self.list_shared_access_with_http_info(account_id, **kwargs) 6007 else: 6008 (data) = self.list_shared_access_with_http_info(account_id, **kwargs) 6009 return data 6010 6011 def list_shared_access_with_http_info(self, account_id, **kwargs): 6012 """ 6013 Reserved: Gets the shared item status for one or more users. 6014 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. 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_shared_access_with_http_info(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 :param str count: Specifies maximum number of results included in the response. If no value is specified, this defaults to 1000. 6027 :param str envelopes_not_shared_user_status: 6028 :param str folder_ids: 6029 :param str item_type: Specifies the type of shared item being requested. The accepted values are: -envelopes: returns information about envelope sharing between users. 6030 :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. 6031 :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 6032 :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. 6033 :param str user_ids: A comma separated list of userIds for whom the shared item information is being requested. 6034 :return: AccountSharedAccess 6035 If the method is called asynchronously, 6036 returns the request thread. 6037 """ 6038 6039 all_params = ['account_id', 'count', 'envelopes_not_shared_user_status', 'folder_ids', 'item_type', 'search_text', 'shared', 'start_position', 'user_ids'] 6040 all_params.append('callback') 6041 all_params.append('_return_http_data_only') 6042 all_params.append('_preload_content') 6043 all_params.append('_request_timeout') 6044 6045 params = locals() 6046 for key, val in iteritems(params['kwargs']): 6047 if key not in all_params: 6048 raise TypeError( 6049 "Got an unexpected keyword argument '%s'" 6050 " to method list_shared_access" % key 6051 ) 6052 params[key] = val 6053 del params['kwargs'] 6054 # verify the required parameter 'account_id' is set 6055 if ('account_id' not in params) or (params['account_id'] is None): 6056 raise ValueError("Missing the required parameter `account_id` when calling `list_shared_access`") 6057 6058 6059 collection_formats = {} 6060 6061 resource_path = '/v2.1/accounts/{accountId}/shared_access'.replace('{format}', 'json') 6062 path_params = {} 6063 if 'account_id' in params: 6064 path_params['accountId'] = params['account_id'] 6065 6066 query_params = {} 6067 if 'count' in params: 6068 query_params['count'] = params['count'] 6069 if 'envelopes_not_shared_user_status' in params: 6070 query_params['envelopes_not_shared_user_status'] = params['envelopes_not_shared_user_status'] 6071 if 'folder_ids' in params: 6072 query_params['folder_ids'] = params['folder_ids'] 6073 if 'item_type' in params: 6074 query_params['item_type'] = params['item_type'] 6075 if 'search_text' in params: 6076 query_params['search_text'] = params['search_text'] 6077 if 'shared' in params: 6078 query_params['shared'] = params['shared'] 6079 if 'start_position' in params: 6080 query_params['start_position'] = params['start_position'] 6081 if 'user_ids' in params: 6082 query_params['user_ids'] = params['user_ids'] 6083 6084 header_params = {} 6085 6086 form_params = [] 6087 local_var_files = {} 6088 6089 body_params = None 6090 # HTTP header `Accept` 6091 header_params['Accept'] = self.api_client.\ 6092 select_header_accept(['application/json']) 6093 6094 # Authentication setting 6095 auth_settings = [] 6096 6097 return self.api_client.call_api(resource_path, 'GET', 6098 path_params, 6099 query_params, 6100 header_params, 6101 body=body_params, 6102 post_params=form_params, 6103 files=local_var_files, 6104 response_type='AccountSharedAccess', 6105 auth_settings=auth_settings, 6106 callback=params.get('callback'), 6107 _return_http_data_only=params.get('_return_http_data_only'), 6108 _preload_content=params.get('_preload_content', True), 6109 _request_timeout=params.get('_request_timeout'), 6110 collection_formats=collection_formats) 6111 6112 def list_signature_providers(self, account_id, **kwargs): 6113 """ 6114 Returns Account available signature providers for specified account. 6115 Returns a list of signature providers that the specified account can use. 6116 This method makes a synchronous HTTP request by default. To make an 6117 asynchronous HTTP request, please define a `callback` function 6118 to be invoked when receiving the response. 6119 >>> def callback_function(response): 6120 >>> pprint(response) 6121 >>> 6122 >>> thread = api.list_signature_providers(account_id, callback=callback_function) 6123 6124 :param callback function: The callback function 6125 for asynchronous request. (optional) 6126 :param str account_id: The external account number (int) or account ID Guid. (required) 6127 :return: AccountSignatureProviders 6128 If the method is called asynchronously, 6129 returns the request thread. 6130 """ 6131 kwargs['_return_http_data_only'] = True 6132 if kwargs.get('callback'): 6133 return self.list_signature_providers_with_http_info(account_id, **kwargs) 6134 else: 6135 (data) = self.list_signature_providers_with_http_info(account_id, **kwargs) 6136 return data 6137 6138 def list_signature_providers_with_http_info(self, account_id, **kwargs): 6139 """ 6140 Returns Account available signature providers for specified account. 6141 Returns a list of signature providers that the specified account can use. 6142 This method makes a synchronous HTTP request by default. To make an 6143 asynchronous HTTP request, please define a `callback` function 6144 to be invoked when receiving the response. 6145 >>> def callback_function(response): 6146 >>> pprint(response) 6147 >>> 6148 >>> thread = api.list_signature_providers_with_http_info(account_id, callback=callback_function) 6149 6150 :param callback function: The callback function 6151 for asynchronous request. (optional) 6152 :param str account_id: The external account number (int) or account ID Guid. (required) 6153 :return: AccountSignatureProviders 6154 If the method is called asynchronously, 6155 returns the request thread. 6156 """ 6157 6158 all_params = ['account_id'] 6159 all_params.append('callback') 6160 all_params.append('_return_http_data_only') 6161 all_params.append('_preload_content') 6162 all_params.append('_request_timeout') 6163 6164 params = locals() 6165 for key, val in iteritems(params['kwargs']): 6166 if key not in all_params: 6167 raise TypeError( 6168 "Got an unexpected keyword argument '%s'" 6169 " to method list_signature_providers" % key 6170 ) 6171 params[key] = val 6172 del params['kwargs'] 6173 # verify the required parameter 'account_id' is set 6174 if ('account_id' not in params) or (params['account_id'] is None): 6175 raise ValueError("Missing the required parameter `account_id` when calling `list_signature_providers`") 6176 6177 6178 collection_formats = {} 6179 6180 resource_path = '/v2.1/accounts/{accountId}/signatureProviders'.replace('{format}', 'json') 6181 path_params = {} 6182 if 'account_id' in params: 6183 path_params['accountId'] = params['account_id'] 6184 6185 query_params = {} 6186 6187 header_params = {} 6188 6189 form_params = [] 6190 local_var_files = {} 6191 6192 body_params = None 6193 # HTTP header `Accept` 6194 header_params['Accept'] = self.api_client.\ 6195 select_header_accept(['application/json']) 6196 6197 # Authentication setting 6198 auth_settings = [] 6199 6200 return self.api_client.call_api(resource_path, 'GET', 6201 path_params, 6202 query_params, 6203 header_params, 6204 body=body_params, 6205 post_params=form_params, 6206 files=local_var_files, 6207 response_type='AccountSignatureProviders', 6208 auth_settings=auth_settings, 6209 callback=params.get('callback'), 6210 _return_http_data_only=params.get('_return_http_data_only'), 6211 _preload_content=params.get('_preload_content', True), 6212 _request_timeout=params.get('_request_timeout'), 6213 collection_formats=collection_formats) 6214 6215 def list_unsupported_file_types(self, account_id, **kwargs): 6216 """ 6217 Gets a list of unsupported file types. 6218 Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system. 6219 This method makes a synchronous HTTP request by default. To make an 6220 asynchronous HTTP request, please define a `callback` function 6221 to be invoked when receiving the response. 6222 >>> def callback_function(response): 6223 >>> pprint(response) 6224 >>> 6225 >>> thread = api.list_unsupported_file_types(account_id, callback=callback_function) 6226 6227 :param callback function: The callback function 6228 for asynchronous request. (optional) 6229 :param str account_id: The external account number (int) or account ID Guid. (required) 6230 :return: FileTypeList 6231 If the method is called asynchronously, 6232 returns the request thread. 6233 """ 6234 kwargs['_return_http_data_only'] = True 6235 if kwargs.get('callback'): 6236 return self.list_unsupported_file_types_with_http_info(account_id, **kwargs) 6237 else: 6238 (data) = self.list_unsupported_file_types_with_http_info(account_id, **kwargs) 6239 return data 6240 6241 def list_unsupported_file_types_with_http_info(self, account_id, **kwargs): 6242 """ 6243 Gets a list of unsupported file types. 6244 Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system. 6245 This method makes a synchronous HTTP request by default. To make an 6246 asynchronous HTTP request, please define a `callback` function 6247 to be invoked when receiving the response. 6248 >>> def callback_function(response): 6249 >>> pprint(response) 6250 >>> 6251 >>> thread = api.list_unsupported_file_types_with_http_info(account_id, callback=callback_function) 6252 6253 :param callback function: The callback function 6254 for asynchronous request. (optional) 6255 :param str account_id: The external account number (int) or account ID Guid. (required) 6256 :return: FileTypeList 6257 If the method is called asynchronously, 6258 returns the request thread. 6259 """ 6260 6261 all_params = ['account_id'] 6262 all_params.append('callback') 6263 all_params.append('_return_http_data_only') 6264 all_params.append('_preload_content') 6265 all_params.append('_request_timeout') 6266 6267 params = locals() 6268 for key, val in iteritems(params['kwargs']): 6269 if key not in all_params: 6270 raise TypeError( 6271 "Got an unexpected keyword argument '%s'" 6272 " to method list_unsupported_file_types" % key 6273 ) 6274 params[key] = val 6275 del params['kwargs'] 6276 # verify the required parameter 'account_id' is set 6277 if ('account_id' not in params) or (params['account_id'] is None): 6278 raise ValueError("Missing the required parameter `account_id` when calling `list_unsupported_file_types`") 6279 6280 6281 collection_formats = {} 6282 6283 resource_path = '/v2.1/accounts/{accountId}/unsupported_file_types'.replace('{format}', 'json') 6284 path_params = {} 6285 if 'account_id' in params: 6286 path_params['accountId'] = params['account_id'] 6287 6288 query_params = {} 6289 6290 header_params = {} 6291 6292 form_params = [] 6293 local_var_files = {} 6294 6295 body_params = None 6296 # HTTP header `Accept` 6297 header_params['Accept'] = self.api_client.\ 6298 select_header_accept(['application/json']) 6299 6300 # Authentication setting 6301 auth_settings = [] 6302 6303 return self.api_client.call_api(resource_path, 'GET', 6304 path_params, 6305 query_params, 6306 header_params, 6307 body=body_params, 6308 post_params=form_params, 6309 files=local_var_files, 6310 response_type='FileTypeList', 6311 auth_settings=auth_settings, 6312 callback=params.get('callback'), 6313 _return_http_data_only=params.get('_return_http_data_only'), 6314 _preload_content=params.get('_preload_content', True), 6315 _request_timeout=params.get('_request_timeout'), 6316 collection_formats=collection_formats) 6317 6318 def un_favorite_template(self, account_id, **kwargs): 6319 """ 6320 Unfavorite a template 6321 6322 This method makes a synchronous HTTP request by default. To make an 6323 asynchronous HTTP request, please define a `callback` function 6324 to be invoked when receiving the response. 6325 >>> def callback_function(response): 6326 >>> pprint(response) 6327 >>> 6328 >>> thread = api.un_favorite_template(account_id, callback=callback_function) 6329 6330 :param callback function: The callback function 6331 for asynchronous request. (optional) 6332 :param str account_id: The external account number (int) or account ID Guid. (required) 6333 :param FavoriteTemplatesInfo favorite_templates_info: 6334 :return: FavoriteTemplatesInfo 6335 If the method is called asynchronously, 6336 returns the request thread. 6337 """ 6338 kwargs['_return_http_data_only'] = True 6339 if kwargs.get('callback'): 6340 return self.un_favorite_template_with_http_info(account_id, **kwargs) 6341 else: 6342 (data) = self.un_favorite_template_with_http_info(account_id, **kwargs) 6343 return data 6344 6345 def un_favorite_template_with_http_info(self, account_id, **kwargs): 6346 """ 6347 Unfavorite a template 6348 6349 This method makes a synchronous HTTP request by default. To make an 6350 asynchronous HTTP request, please define a `callback` function 6351 to be invoked when receiving the response. 6352 >>> def callback_function(response): 6353 >>> pprint(response) 6354 >>> 6355 >>> thread = api.un_favorite_template_with_http_info(account_id, callback=callback_function) 6356 6357 :param callback function: The callback function 6358 for asynchronous request. (optional) 6359 :param str account_id: The external account number (int) or account ID Guid. (required) 6360 :param FavoriteTemplatesInfo favorite_templates_info: 6361 :return: FavoriteTemplatesInfo 6362 If the method is called asynchronously, 6363 returns the request thread. 6364 """ 6365 6366 all_params = ['account_id', 'favorite_templates_info'] 6367 all_params.append('callback') 6368 all_params.append('_return_http_data_only') 6369 all_params.append('_preload_content') 6370 all_params.append('_request_timeout') 6371 6372 params = locals() 6373 for key, val in iteritems(params['kwargs']): 6374 if key not in all_params: 6375 raise TypeError( 6376 "Got an unexpected keyword argument '%s'" 6377 " to method un_favorite_template" % key 6378 ) 6379 params[key] = val 6380 del params['kwargs'] 6381 # verify the required parameter 'account_id' is set 6382 if ('account_id' not in params) or (params['account_id'] is None): 6383 raise ValueError("Missing the required parameter `account_id` when calling `un_favorite_template`") 6384 6385 6386 collection_formats = {} 6387 6388 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 6389 path_params = {} 6390 if 'account_id' in params: 6391 path_params['accountId'] = params['account_id'] 6392 6393 query_params = {} 6394 6395 header_params = {} 6396 6397 form_params = [] 6398 local_var_files = {} 6399 6400 body_params = None 6401 if 'favorite_templates_info' in params: 6402 body_params = params['favorite_templates_info'] 6403 # HTTP header `Accept` 6404 header_params['Accept'] = self.api_client.\ 6405 select_header_accept(['application/json']) 6406 6407 # Authentication setting 6408 auth_settings = [] 6409 6410 return self.api_client.call_api(resource_path, 'DELETE', 6411 path_params, 6412 query_params, 6413 header_params, 6414 body=body_params, 6415 post_params=form_params, 6416 files=local_var_files, 6417 response_type='FavoriteTemplatesInfo', 6418 auth_settings=auth_settings, 6419 callback=params.get('callback'), 6420 _return_http_data_only=params.get('_return_http_data_only'), 6421 _preload_content=params.get('_preload_content', True), 6422 _request_timeout=params.get('_request_timeout'), 6423 collection_formats=collection_formats) 6424 6425 def update_account_signature(self, account_id, **kwargs): 6426 """ 6427 Updates a account signature. 6428 6429 This method makes a synchronous HTTP request by default. To make an 6430 asynchronous HTTP request, please define a `callback` function 6431 to be invoked when receiving the response. 6432 >>> def callback_function(response): 6433 >>> pprint(response) 6434 >>> 6435 >>> thread = api.update_account_signature(account_id, callback=callback_function) 6436 6437 :param callback function: The callback function 6438 for asynchronous request. (optional) 6439 :param str account_id: The external account number (int) or account ID Guid. (required) 6440 :param AccountSignaturesInformation account_signatures_information: 6441 :return: AccountSignaturesInformation 6442 If the method is called asynchronously, 6443 returns the request thread. 6444 """ 6445 kwargs['_return_http_data_only'] = True 6446 if kwargs.get('callback'): 6447 return self.update_account_signature_with_http_info(account_id, **kwargs) 6448 else: 6449 (data) = self.update_account_signature_with_http_info(account_id, **kwargs) 6450 return data 6451 6452 def update_account_signature_with_http_info(self, account_id, **kwargs): 6453 """ 6454 Updates a account signature. 6455 6456 This method makes a synchronous HTTP request by default. To make an 6457 asynchronous HTTP request, please define a `callback` function 6458 to be invoked when receiving the response. 6459 >>> def callback_function(response): 6460 >>> pprint(response) 6461 >>> 6462 >>> thread = api.update_account_signature_with_http_info(account_id, callback=callback_function) 6463 6464 :param callback function: The callback function 6465 for asynchronous request. (optional) 6466 :param str account_id: The external account number (int) or account ID Guid. (required) 6467 :param AccountSignaturesInformation account_signatures_information: 6468 :return: AccountSignaturesInformation 6469 If the method is called asynchronously, 6470 returns the request thread. 6471 """ 6472 6473 all_params = ['account_id', 'account_signatures_information'] 6474 all_params.append('callback') 6475 all_params.append('_return_http_data_only') 6476 all_params.append('_preload_content') 6477 all_params.append('_request_timeout') 6478 6479 params = locals() 6480 for key, val in iteritems(params['kwargs']): 6481 if key not in all_params: 6482 raise TypeError( 6483 "Got an unexpected keyword argument '%s'" 6484 " to method update_account_signature" % key 6485 ) 6486 params[key] = val 6487 del params['kwargs'] 6488 # verify the required parameter 'account_id' is set 6489 if ('account_id' not in params) or (params['account_id'] is None): 6490 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature`") 6491 6492 6493 collection_formats = {} 6494 6495 resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json') 6496 path_params = {} 6497 if 'account_id' in params: 6498 path_params['accountId'] = params['account_id'] 6499 6500 query_params = {} 6501 6502 header_params = {} 6503 6504 form_params = [] 6505 local_var_files = {} 6506 6507 body_params = None 6508 if 'account_signatures_information' in params: 6509 body_params = params['account_signatures_information'] 6510 # HTTP header `Accept` 6511 header_params['Accept'] = self.api_client.\ 6512 select_header_accept(['application/json']) 6513 6514 # Authentication setting 6515 auth_settings = [] 6516 6517 return self.api_client.call_api(resource_path, 'PUT', 6518 path_params, 6519 query_params, 6520 header_params, 6521 body=body_params, 6522 post_params=form_params, 6523 files=local_var_files, 6524 response_type='AccountSignaturesInformation', 6525 auth_settings=auth_settings, 6526 callback=params.get('callback'), 6527 _return_http_data_only=params.get('_return_http_data_only'), 6528 _preload_content=params.get('_preload_content', True), 6529 _request_timeout=params.get('_request_timeout'), 6530 collection_formats=collection_formats) 6531 6532 def update_account_signature_by_id(self, account_id, signature_id, **kwargs): 6533 """ 6534 Updates a account signature. 6535 6536 This method makes a synchronous HTTP request by default. To make an 6537 asynchronous HTTP request, please define a `callback` function 6538 to be invoked when receiving the response. 6539 >>> def callback_function(response): 6540 >>> pprint(response) 6541 >>> 6542 >>> thread = api.update_account_signature_by_id(account_id, signature_id, callback=callback_function) 6543 6544 :param callback function: The callback function 6545 for asynchronous request. (optional) 6546 :param str account_id: The external account number (int) or account ID Guid. (required) 6547 :param str signature_id: The ID of the signature being accessed. (required) 6548 :param str close_existing_signature: 6549 :param AccountSignatureDefinition account_signature_definition: 6550 :return: AccountSignature 6551 If the method is called asynchronously, 6552 returns the request thread. 6553 """ 6554 kwargs['_return_http_data_only'] = True 6555 if kwargs.get('callback'): 6556 return self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs) 6557 else: 6558 (data) = self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs) 6559 return data 6560 6561 def update_account_signature_by_id_with_http_info(self, account_id, signature_id, **kwargs): 6562 """ 6563 Updates a account signature. 6564 6565 This method makes a synchronous HTTP request by default. To make an 6566 asynchronous HTTP request, please define a `callback` function 6567 to be invoked when receiving the response. 6568 >>> def callback_function(response): 6569 >>> pprint(response) 6570 >>> 6571 >>> thread = api.update_account_signature_by_id_with_http_info(account_id, signature_id, callback=callback_function) 6572 6573 :param callback function: The callback function 6574 for asynchronous request. (optional) 6575 :param str account_id: The external account number (int) or account ID Guid. (required) 6576 :param str signature_id: The ID of the signature being accessed. (required) 6577 :param str close_existing_signature: 6578 :param AccountSignatureDefinition account_signature_definition: 6579 :return: AccountSignature 6580 If the method is called asynchronously, 6581 returns the request thread. 6582 """ 6583 6584 all_params = ['account_id', 'signature_id', 'close_existing_signature', 'account_signature_definition'] 6585 all_params.append('callback') 6586 all_params.append('_return_http_data_only') 6587 all_params.append('_preload_content') 6588 all_params.append('_request_timeout') 6589 6590 params = locals() 6591 for key, val in iteritems(params['kwargs']): 6592 if key not in all_params: 6593 raise TypeError( 6594 "Got an unexpected keyword argument '%s'" 6595 " to method update_account_signature_by_id" % key 6596 ) 6597 params[key] = val 6598 del params['kwargs'] 6599 # verify the required parameter 'account_id' is set 6600 if ('account_id' not in params) or (params['account_id'] is None): 6601 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_by_id`") 6602 # verify the required parameter 'signature_id' is set 6603 if ('signature_id' not in params) or (params['signature_id'] is None): 6604 raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_by_id`") 6605 6606 6607 collection_formats = {} 6608 6609 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 6610 path_params = {} 6611 if 'account_id' in params: 6612 path_params['accountId'] = params['account_id'] 6613 if 'signature_id' in params: 6614 path_params['signatureId'] = params['signature_id'] 6615 6616 query_params = {} 6617 if 'close_existing_signature' in params: 6618 query_params['close_existing_signature'] = params['close_existing_signature'] 6619 6620 header_params = {} 6621 6622 form_params = [] 6623 local_var_files = {} 6624 6625 body_params = None 6626 if 'account_signature_definition' in params: 6627 body_params = params['account_signature_definition'] 6628 # HTTP header `Accept` 6629 header_params['Accept'] = self.api_client.\ 6630 select_header_accept(['application/json']) 6631 6632 # Authentication setting 6633 auth_settings = [] 6634 6635 return self.api_client.call_api(resource_path, 'PUT', 6636 path_params, 6637 query_params, 6638 header_params, 6639 body=body_params, 6640 post_params=form_params, 6641 files=local_var_files, 6642 response_type='AccountSignature', 6643 auth_settings=auth_settings, 6644 callback=params.get('callback'), 6645 _return_http_data_only=params.get('_return_http_data_only'), 6646 _preload_content=params.get('_preload_content', True), 6647 _request_timeout=params.get('_request_timeout'), 6648 collection_formats=collection_formats) 6649 6650 def update_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 6651 """ 6652 Sets a signature, initials, or stamps image. 6653 6654 This method makes a synchronous HTTP request by default. To make an 6655 asynchronous HTTP request, please define a `callback` function 6656 to be invoked when receiving the response. 6657 >>> def callback_function(response): 6658 >>> pprint(response) 6659 >>> 6660 >>> thread = api.update_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 6661 6662 :param callback function: The callback function 6663 for asynchronous request. (optional) 6664 :param str account_id: The external account number (int) or account ID Guid. (required) 6665 :param str image_type: One of **signature_image** or **initials_image**. (required) 6666 :param str signature_id: The ID of the signature being accessed. (required) 6667 :param str transparent_png: 6668 :return: AccountSignature 6669 If the method is called asynchronously, 6670 returns the request thread. 6671 """ 6672 kwargs['_return_http_data_only'] = True 6673 if kwargs.get('callback'): 6674 return self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 6675 else: 6676 (data) = self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 6677 return data 6678 6679 def update_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 6680 """ 6681 Sets a signature, initials, or stamps image. 6682 6683 This method makes a synchronous HTTP request by default. To make an 6684 asynchronous HTTP request, please define a `callback` function 6685 to be invoked when receiving the response. 6686 >>> def callback_function(response): 6687 >>> pprint(response) 6688 >>> 6689 >>> thread = api.update_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 6690 6691 :param callback function: The callback function 6692 for asynchronous request. (optional) 6693 :param str account_id: The external account number (int) or account ID Guid. (required) 6694 :param str image_type: One of **signature_image** or **initials_image**. (required) 6695 :param str signature_id: The ID of the signature being accessed. (required) 6696 :param str transparent_png: 6697 :return: AccountSignature 6698 If the method is called asynchronously, 6699 returns the request thread. 6700 """ 6701 6702 all_params = ['account_id', 'image_type', 'signature_id', 'transparent_png'] 6703 all_params.append('callback') 6704 all_params.append('_return_http_data_only') 6705 all_params.append('_preload_content') 6706 all_params.append('_request_timeout') 6707 6708 params = locals() 6709 for key, val in iteritems(params['kwargs']): 6710 if key not in all_params: 6711 raise TypeError( 6712 "Got an unexpected keyword argument '%s'" 6713 " to method update_account_signature_image" % key 6714 ) 6715 params[key] = val 6716 del params['kwargs'] 6717 # verify the required parameter 'account_id' is set 6718 if ('account_id' not in params) or (params['account_id'] is None): 6719 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_image`") 6720 # verify the required parameter 'image_type' is set 6721 if ('image_type' not in params) or (params['image_type'] is None): 6722 raise ValueError("Missing the required parameter `image_type` when calling `update_account_signature_image`") 6723 # verify the required parameter 'signature_id' is set 6724 if ('signature_id' not in params) or (params['signature_id'] is None): 6725 raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_image`") 6726 6727 6728 collection_formats = {} 6729 6730 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 6731 path_params = {} 6732 if 'account_id' in params: 6733 path_params['accountId'] = params['account_id'] 6734 if 'image_type' in params: 6735 path_params['imageType'] = params['image_type'] 6736 if 'signature_id' in params: 6737 path_params['signatureId'] = params['signature_id'] 6738 6739 query_params = {} 6740 if 'transparent_png' in params: 6741 query_params['transparent_png'] = params['transparent_png'] 6742 6743 header_params = {} 6744 6745 form_params = [] 6746 local_var_files = {} 6747 6748 body_params = None 6749 # HTTP header `Accept` 6750 header_params['Accept'] = self.api_client.\ 6751 select_header_accept(['application/json']) 6752 6753 # HTTP header `Content-Type` 6754 header_params['Content-Type'] = self.api_client.\ 6755 select_header_content_type(['image/gif']) 6756 6757 # Authentication setting 6758 auth_settings = [] 6759 6760 return self.api_client.call_api(resource_path, 'PUT', 6761 path_params, 6762 query_params, 6763 header_params, 6764 body=body_params, 6765 post_params=form_params, 6766 files=local_var_files, 6767 response_type='AccountSignature', 6768 auth_settings=auth_settings, 6769 callback=params.get('callback'), 6770 _return_http_data_only=params.get('_return_http_data_only'), 6771 _preload_content=params.get('_preload_content', True), 6772 _request_timeout=params.get('_request_timeout'), 6773 collection_formats=collection_formats) 6774 6775 def update_account_tab_settings(self, account_id, **kwargs): 6776 """ 6777 Modifies tab settings for specified account 6778 This method modifies the tab types and tab functionality that is enabled for an account. 6779 This method makes a synchronous HTTP request by default. To make an 6780 asynchronous HTTP request, please define a `callback` function 6781 to be invoked when receiving the response. 6782 >>> def callback_function(response): 6783 >>> pprint(response) 6784 >>> 6785 >>> thread = api.update_account_tab_settings(account_id, callback=callback_function) 6786 6787 :param callback function: The callback function 6788 for asynchronous request. (optional) 6789 :param str account_id: The external account number (int) or account ID Guid. (required) 6790 :param TabAccountSettings tab_account_settings: 6791 :return: TabAccountSettings 6792 If the method is called asynchronously, 6793 returns the request thread. 6794 """ 6795 kwargs['_return_http_data_only'] = True 6796 if kwargs.get('callback'): 6797 return self.update_account_tab_settings_with_http_info(account_id, **kwargs) 6798 else: 6799 (data) = self.update_account_tab_settings_with_http_info(account_id, **kwargs) 6800 return data 6801 6802 def update_account_tab_settings_with_http_info(self, account_id, **kwargs): 6803 """ 6804 Modifies tab settings for specified account 6805 This method modifies the tab types and tab functionality that is enabled for an account. 6806 This method makes a synchronous HTTP request by default. To make an 6807 asynchronous HTTP request, please define a `callback` function 6808 to be invoked when receiving the response. 6809 >>> def callback_function(response): 6810 >>> pprint(response) 6811 >>> 6812 >>> thread = api.update_account_tab_settings_with_http_info(account_id, callback=callback_function) 6813 6814 :param callback function: The callback function 6815 for asynchronous request. (optional) 6816 :param str account_id: The external account number (int) or account ID Guid. (required) 6817 :param TabAccountSettings tab_account_settings: 6818 :return: TabAccountSettings 6819 If the method is called asynchronously, 6820 returns the request thread. 6821 """ 6822 6823 all_params = ['account_id', 'tab_account_settings'] 6824 all_params.append('callback') 6825 all_params.append('_return_http_data_only') 6826 all_params.append('_preload_content') 6827 all_params.append('_request_timeout') 6828 6829 params = locals() 6830 for key, val in iteritems(params['kwargs']): 6831 if key not in all_params: 6832 raise TypeError( 6833 "Got an unexpected keyword argument '%s'" 6834 " to method update_account_tab_settings" % key 6835 ) 6836 params[key] = val 6837 del params['kwargs'] 6838 # verify the required parameter 'account_id' is set 6839 if ('account_id' not in params) or (params['account_id'] is None): 6840 raise ValueError("Missing the required parameter `account_id` when calling `update_account_tab_settings`") 6841 6842 6843 collection_formats = {} 6844 6845 resource_path = '/v2.1/accounts/{accountId}/settings/tabs'.replace('{format}', 'json') 6846 path_params = {} 6847 if 'account_id' in params: 6848 path_params['accountId'] = params['account_id'] 6849 6850 query_params = {} 6851 6852 header_params = {} 6853 6854 form_params = [] 6855 local_var_files = {} 6856 6857 body_params = None 6858 if 'tab_account_settings' in params: 6859 body_params = params['tab_account_settings'] 6860 # HTTP header `Accept` 6861 header_params['Accept'] = self.api_client.\ 6862 select_header_accept(['application/json']) 6863 6864 # Authentication setting 6865 auth_settings = [] 6866 6867 return self.api_client.call_api(resource_path, 'PUT', 6868 path_params, 6869 query_params, 6870 header_params, 6871 body=body_params, 6872 post_params=form_params, 6873 files=local_var_files, 6874 response_type='TabAccountSettings', 6875 auth_settings=auth_settings, 6876 callback=params.get('callback'), 6877 _return_http_data_only=params.get('_return_http_data_only'), 6878 _preload_content=params.get('_preload_content', True), 6879 _request_timeout=params.get('_request_timeout'), 6880 collection_formats=collection_formats) 6881 6882 def update_brand(self, account_id, brand_id, **kwargs): 6883 """ 6884 Updates an existing brand. 6885 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**). 6886 This method makes a synchronous HTTP request by default. To make an 6887 asynchronous HTTP request, please define a `callback` function 6888 to be invoked when receiving the response. 6889 >>> def callback_function(response): 6890 >>> pprint(response) 6891 >>> 6892 >>> thread = api.update_brand(account_id, brand_id, callback=callback_function) 6893 6894 :param callback function: The callback function 6895 for asynchronous request. (optional) 6896 :param str account_id: The external account number (int) or account ID Guid. (required) 6897 :param str brand_id: The unique identifier of a brand. (required) 6898 :param str replace_brand: 6899 :param Brand brand: 6900 :return: Brand 6901 If the method is called asynchronously, 6902 returns the request thread. 6903 """ 6904 kwargs['_return_http_data_only'] = True 6905 if kwargs.get('callback'): 6906 return self.update_brand_with_http_info(account_id, brand_id, **kwargs) 6907 else: 6908 (data) = self.update_brand_with_http_info(account_id, brand_id, **kwargs) 6909 return data 6910 6911 def update_brand_with_http_info(self, account_id, brand_id, **kwargs): 6912 """ 6913 Updates an existing brand. 6914 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**). 6915 This method makes a synchronous HTTP request by default. To make an 6916 asynchronous HTTP request, please define a `callback` function 6917 to be invoked when receiving the response. 6918 >>> def callback_function(response): 6919 >>> pprint(response) 6920 >>> 6921 >>> thread = api.update_brand_with_http_info(account_id, brand_id, callback=callback_function) 6922 6923 :param callback function: The callback function 6924 for asynchronous request. (optional) 6925 :param str account_id: The external account number (int) or account ID Guid. (required) 6926 :param str brand_id: The unique identifier of a brand. (required) 6927 :param str replace_brand: 6928 :param Brand brand: 6929 :return: Brand 6930 If the method is called asynchronously, 6931 returns the request thread. 6932 """ 6933 6934 all_params = ['account_id', 'brand_id', 'replace_brand', 'brand'] 6935 all_params.append('callback') 6936 all_params.append('_return_http_data_only') 6937 all_params.append('_preload_content') 6938 all_params.append('_request_timeout') 6939 6940 params = locals() 6941 for key, val in iteritems(params['kwargs']): 6942 if key not in all_params: 6943 raise TypeError( 6944 "Got an unexpected keyword argument '%s'" 6945 " to method update_brand" % key 6946 ) 6947 params[key] = val 6948 del params['kwargs'] 6949 # verify the required parameter 'account_id' is set 6950 if ('account_id' not in params) or (params['account_id'] is None): 6951 raise ValueError("Missing the required parameter `account_id` when calling `update_brand`") 6952 # verify the required parameter 'brand_id' is set 6953 if ('brand_id' not in params) or (params['brand_id'] is None): 6954 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand`") 6955 6956 6957 collection_formats = {} 6958 6959 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 6960 path_params = {} 6961 if 'account_id' in params: 6962 path_params['accountId'] = params['account_id'] 6963 if 'brand_id' in params: 6964 path_params['brandId'] = params['brand_id'] 6965 6966 query_params = {} 6967 if 'replace_brand' in params: 6968 query_params['replace_brand'] = params['replace_brand'] 6969 6970 header_params = {} 6971 6972 form_params = [] 6973 local_var_files = {} 6974 6975 body_params = None 6976 if 'brand' in params: 6977 body_params = params['brand'] 6978 # HTTP header `Accept` 6979 header_params['Accept'] = self.api_client.\ 6980 select_header_accept(['application/json']) 6981 6982 # Authentication setting 6983 auth_settings = [] 6984 6985 return self.api_client.call_api(resource_path, 'PUT', 6986 path_params, 6987 query_params, 6988 header_params, 6989 body=body_params, 6990 post_params=form_params, 6991 files=local_var_files, 6992 response_type='Brand', 6993 auth_settings=auth_settings, 6994 callback=params.get('callback'), 6995 _return_http_data_only=params.get('_return_http_data_only'), 6996 _preload_content=params.get('_preload_content', True), 6997 _request_timeout=params.get('_request_timeout'), 6998 collection_formats=collection_formats) 6999 7000 def update_brand_logo_by_type(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs): 7001 """ 7002 Put one branding logo. 7003 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**). 7004 This method makes a synchronous HTTP request by default. To make an 7005 asynchronous HTTP request, please define a `callback` function 7006 to be invoked when receiving the response. 7007 >>> def callback_function(response): 7008 >>> pprint(response) 7009 >>> 7010 >>> thread = api.update_brand_logo_by_type(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function) 7011 7012 :param callback function: The callback function 7013 for asynchronous request. (optional) 7014 :param str account_id: The external account number (int) or account ID GUID. (required) 7015 :param str brand_id: The ID of the brand. (required) 7016 :param str logo_type: The type of logo. Valid values are: - `primary` - `secondary` - `email` (required) 7017 :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) 7018 :return: None 7019 If the method is called asynchronously, 7020 returns the request thread. 7021 """ 7022 kwargs['_return_http_data_only'] = True 7023 if kwargs.get('callback'): 7024 return self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs) 7025 else: 7026 (data) = self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs) 7027 return data 7028 7029 def update_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs): 7030 """ 7031 Put one branding logo. 7032 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**). 7033 This method makes a synchronous HTTP request by default. To make an 7034 asynchronous HTTP request, please define a `callback` function 7035 to be invoked when receiving the response. 7036 >>> def callback_function(response): 7037 >>> pprint(response) 7038 >>> 7039 >>> thread = api.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function) 7040 7041 :param callback function: The callback function 7042 for asynchronous request. (optional) 7043 :param str account_id: The external account number (int) or account ID GUID. (required) 7044 :param str brand_id: The ID of the brand. (required) 7045 :param str logo_type: The type of logo. Valid values are: - `primary` - `secondary` - `email` (required) 7046 :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) 7047 :return: None 7048 If the method is called asynchronously, 7049 returns the request thread. 7050 """ 7051 7052 all_params = ['account_id', 'brand_id', 'logo_type', 'logo_file_bytes'] 7053 all_params.append('callback') 7054 all_params.append('_return_http_data_only') 7055 all_params.append('_preload_content') 7056 all_params.append('_request_timeout') 7057 7058 params = locals() 7059 for key, val in iteritems(params['kwargs']): 7060 if key not in all_params: 7061 raise TypeError( 7062 "Got an unexpected keyword argument '%s'" 7063 " to method update_brand_logo_by_type" % key 7064 ) 7065 params[key] = val 7066 del params['kwargs'] 7067 # verify the required parameter 'account_id' is set 7068 if ('account_id' not in params) or (params['account_id'] is None): 7069 raise ValueError("Missing the required parameter `account_id` when calling `update_brand_logo_by_type`") 7070 # verify the required parameter 'brand_id' is set 7071 if ('brand_id' not in params) or (params['brand_id'] is None): 7072 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_logo_by_type`") 7073 # verify the required parameter 'logo_type' is set 7074 if ('logo_type' not in params) or (params['logo_type'] is None): 7075 raise ValueError("Missing the required parameter `logo_type` when calling `update_brand_logo_by_type`") 7076 # verify the required parameter 'logo_file_bytes' is set 7077 if ('logo_file_bytes' not in params) or (params['logo_file_bytes'] is None): 7078 raise ValueError("Missing the required parameter `logo_file_bytes` when calling `update_brand_logo_by_type`") 7079 7080 7081 collection_formats = {} 7082 7083 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 7084 path_params = {} 7085 if 'account_id' in params: 7086 path_params['accountId'] = params['account_id'] 7087 if 'brand_id' in params: 7088 path_params['brandId'] = params['brand_id'] 7089 if 'logo_type' in params: 7090 path_params['logoType'] = params['logo_type'] 7091 7092 query_params = {} 7093 7094 header_params = {} 7095 7096 form_params = [] 7097 local_var_files = {} 7098 7099 body_params = None 7100 if 'logo_file_bytes' in params: 7101 body_params = params['logo_file_bytes'] 7102 # HTTP header `Accept` 7103 header_params['Accept'] = self.api_client.\ 7104 select_header_accept(['application/json']) 7105 7106 # HTTP header `Content-Type` 7107 header_params['Content-Type'] = self.api_client.\ 7108 select_header_content_type(['image/png']) 7109 7110 # Authentication setting 7111 auth_settings = [] 7112 7113 return self.api_client.call_api(resource_path, 'PUT', 7114 path_params, 7115 query_params, 7116 header_params, 7117 body=body_params, 7118 post_params=form_params, 7119 files=local_var_files, 7120 response_type=None, 7121 auth_settings=auth_settings, 7122 callback=params.get('callback'), 7123 _return_http_data_only=params.get('_return_http_data_only'), 7124 _preload_content=params.get('_preload_content', True), 7125 _request_timeout=params.get('_request_timeout'), 7126 collection_formats=collection_formats) 7127 7128 def update_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, file_xml, **kwargs): 7129 """ 7130 Uploads a branding resource file. 7131 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. 7132 This method makes a synchronous HTTP request by default. To make an 7133 asynchronous HTTP request, please define a `callback` function 7134 to be invoked when receiving the response. 7135 >>> def callback_function(response): 7136 >>> pprint(response) 7137 >>> 7138 >>> thread = api.update_brand_resources_by_content_type(account_id, brand_id, resource_content_type, file_xml, callback=callback_function) 7139 7140 :param callback function: The callback function 7141 for asynchronous request. (optional) 7142 :param str account_id: The external account number (int) or account ID GUID. (required) 7143 :param str brand_id: The ID of the brand. (required) 7144 :param str resource_content_type: The type of brand resource file that you are updating. Valid values are: - `sending` - `signing` - `email` - `signing_captive` (required) 7145 :param file file_xml: Brand resource XML file. (required) 7146 :return: BrandResources 7147 If the method is called asynchronously, 7148 returns the request thread. 7149 """ 7150 kwargs['_return_http_data_only'] = True 7151 if kwargs.get('callback'): 7152 return self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs) 7153 else: 7154 (data) = self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs) 7155 return data 7156 7157 def update_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, file_xml, **kwargs): 7158 """ 7159 Uploads a branding resource file. 7160 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. 7161 This method makes a synchronous HTTP request by default. To make an 7162 asynchronous HTTP request, please define a `callback` function 7163 to be invoked when receiving the response. 7164 >>> def callback_function(response): 7165 >>> pprint(response) 7166 >>> 7167 >>> thread = api.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, callback=callback_function) 7168 7169 :param callback function: The callback function 7170 for asynchronous request. (optional) 7171 :param str account_id: The external account number (int) or account ID GUID. (required) 7172 :param str brand_id: The ID of the brand. (required) 7173 :param str resource_content_type: The type of brand resource file that you are updating. Valid values are: - `sending` - `signing` - `email` - `signing_captive` (required) 7174 :param file file_xml: Brand resource XML file. (required) 7175 :return: BrandResources 7176 If the method is called asynchronously, 7177 returns the request thread. 7178 """ 7179 7180 all_params = ['account_id', 'brand_id', 'resource_content_type', 'file_xml'] 7181 all_params.append('callback') 7182 all_params.append('_return_http_data_only') 7183 all_params.append('_preload_content') 7184 all_params.append('_request_timeout') 7185 7186 params = locals() 7187 for key, val in iteritems(params['kwargs']): 7188 if key not in all_params: 7189 raise TypeError( 7190 "Got an unexpected keyword argument '%s'" 7191 " to method update_brand_resources_by_content_type" % key 7192 ) 7193 params[key] = val 7194 del params['kwargs'] 7195 # verify the required parameter 'account_id' is set 7196 if ('account_id' not in params) or (params['account_id'] is None): 7197 raise ValueError("Missing the required parameter `account_id` when calling `update_brand_resources_by_content_type`") 7198 # verify the required parameter 'brand_id' is set 7199 if ('brand_id' not in params) or (params['brand_id'] is None): 7200 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_resources_by_content_type`") 7201 # verify the required parameter 'resource_content_type' is set 7202 if ('resource_content_type' not in params) or (params['resource_content_type'] is None): 7203 raise ValueError("Missing the required parameter `resource_content_type` when calling `update_brand_resources_by_content_type`") 7204 # verify the required parameter 'file_xml' is set 7205 if ('file_xml' not in params) or (params['file_xml'] is None): 7206 raise ValueError("Missing the required parameter `file_xml` when calling `update_brand_resources_by_content_type`") 7207 7208 7209 collection_formats = {} 7210 7211 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources/{resourceContentType}'.replace('{format}', 'json') 7212 path_params = {} 7213 if 'account_id' in params: 7214 path_params['accountId'] = params['account_id'] 7215 if 'brand_id' in params: 7216 path_params['brandId'] = params['brand_id'] 7217 if 'resource_content_type' in params: 7218 path_params['resourceContentType'] = params['resource_content_type'] 7219 7220 query_params = {} 7221 7222 header_params = {} 7223 7224 form_params = [] 7225 local_var_files = {} 7226 if 'file_xml' in params: 7227 local_var_files['file.xml'] = params['file_xml'] 7228 7229 body_params = None 7230 # HTTP header `Accept` 7231 header_params['Accept'] = self.api_client.\ 7232 select_header_accept(['application/json']) 7233 7234 # HTTP header `Content-Type` 7235 header_params['Content-Type'] = self.api_client.\ 7236 select_header_content_type(['multipart/form-data']) 7237 7238 # Authentication setting 7239 auth_settings = [] 7240 7241 return self.api_client.call_api(resource_path, 'PUT', 7242 path_params, 7243 query_params, 7244 header_params, 7245 body=body_params, 7246 post_params=form_params, 7247 files=local_var_files, 7248 response_type='BrandResources', 7249 auth_settings=auth_settings, 7250 callback=params.get('callback'), 7251 _return_http_data_only=params.get('_return_http_data_only'), 7252 _preload_content=params.get('_preload_content', True), 7253 _request_timeout=params.get('_request_timeout'), 7254 collection_formats=collection_formats) 7255 7256 def update_consumer_disclosure(self, account_id, lang_code, **kwargs): 7257 """ 7258 Update Consumer Disclosure. 7259 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. 7260 This method makes a synchronous HTTP request by default. To make an 7261 asynchronous HTTP request, please define a `callback` function 7262 to be invoked when receiving the response. 7263 >>> def callback_function(response): 7264 >>> pprint(response) 7265 >>> 7266 >>> thread = api.update_consumer_disclosure(account_id, lang_code, callback=callback_function) 7267 7268 :param callback function: The callback function 7269 for asynchronous request. (optional) 7270 :param str account_id: The external account number (int) or account ID Guid. (required) 7271 :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) 7272 :param str include_metadata: 7273 :param ConsumerDisclosure consumer_disclosure: 7274 :return: ConsumerDisclosure 7275 If the method is called asynchronously, 7276 returns the request thread. 7277 """ 7278 kwargs['_return_http_data_only'] = True 7279 if kwargs.get('callback'): 7280 return self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 7281 else: 7282 (data) = self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 7283 return data 7284 7285 def update_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs): 7286 """ 7287 Update Consumer Disclosure. 7288 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. 7289 This method makes a synchronous HTTP request by default. To make an 7290 asynchronous HTTP request, please define a `callback` function 7291 to be invoked when receiving the response. 7292 >>> def callback_function(response): 7293 >>> pprint(response) 7294 >>> 7295 >>> thread = api.update_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function) 7296 7297 :param callback function: The callback function 7298 for asynchronous request. (optional) 7299 :param str account_id: The external account number (int) or account ID Guid. (required) 7300 :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) 7301 :param str include_metadata: 7302 :param ConsumerDisclosure consumer_disclosure: 7303 :return: ConsumerDisclosure 7304 If the method is called asynchronously, 7305 returns the request thread. 7306 """ 7307 7308 all_params = ['account_id', 'lang_code', 'include_metadata', 'consumer_disclosure'] 7309 all_params.append('callback') 7310 all_params.append('_return_http_data_only') 7311 all_params.append('_preload_content') 7312 all_params.append('_request_timeout') 7313 7314 params = locals() 7315 for key, val in iteritems(params['kwargs']): 7316 if key not in all_params: 7317 raise TypeError( 7318 "Got an unexpected keyword argument '%s'" 7319 " to method update_consumer_disclosure" % key 7320 ) 7321 params[key] = val 7322 del params['kwargs'] 7323 # verify the required parameter 'account_id' is set 7324 if ('account_id' not in params) or (params['account_id'] is None): 7325 raise ValueError("Missing the required parameter `account_id` when calling `update_consumer_disclosure`") 7326 # verify the required parameter 'lang_code' is set 7327 if ('lang_code' not in params) or (params['lang_code'] is None): 7328 raise ValueError("Missing the required parameter `lang_code` when calling `update_consumer_disclosure`") 7329 7330 7331 collection_formats = {} 7332 7333 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 7334 path_params = {} 7335 if 'account_id' in params: 7336 path_params['accountId'] = params['account_id'] 7337 if 'lang_code' in params: 7338 path_params['langCode'] = params['lang_code'] 7339 7340 query_params = {} 7341 if 'include_metadata' in params: 7342 query_params['include_metadata'] = params['include_metadata'] 7343 7344 header_params = {} 7345 7346 form_params = [] 7347 local_var_files = {} 7348 7349 body_params = None 7350 if 'consumer_disclosure' in params: 7351 body_params = params['consumer_disclosure'] 7352 # HTTP header `Accept` 7353 header_params['Accept'] = self.api_client.\ 7354 select_header_accept(['application/json']) 7355 7356 # Authentication setting 7357 auth_settings = [] 7358 7359 return self.api_client.call_api(resource_path, 'PUT', 7360 path_params, 7361 query_params, 7362 header_params, 7363 body=body_params, 7364 post_params=form_params, 7365 files=local_var_files, 7366 response_type='ConsumerDisclosure', 7367 auth_settings=auth_settings, 7368 callback=params.get('callback'), 7369 _return_http_data_only=params.get('_return_http_data_only'), 7370 _preload_content=params.get('_preload_content', True), 7371 _request_timeout=params.get('_request_timeout'), 7372 collection_formats=collection_formats) 7373 7374 def update_custom_field(self, account_id, custom_field_id, **kwargs): 7375 """ 7376 Updates an existing account custom field. 7377 This method updates an existing account custom field. 7378 This method makes a synchronous HTTP request by default. To make an 7379 asynchronous HTTP request, please define a `callback` function 7380 to be invoked when receiving the response. 7381 >>> def callback_function(response): 7382 >>> pprint(response) 7383 >>> 7384 >>> thread = api.update_custom_field(account_id, custom_field_id, callback=callback_function) 7385 7386 :param callback function: The callback function 7387 for asynchronous request. (optional) 7388 :param str account_id: The external account number (int) or account ID Guid. (required) 7389 :param str custom_field_id: (required) 7390 :param str apply_to_templates: 7391 :param CustomField custom_field: 7392 :return: CustomFields 7393 If the method is called asynchronously, 7394 returns the request thread. 7395 """ 7396 kwargs['_return_http_data_only'] = True 7397 if kwargs.get('callback'): 7398 return self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 7399 else: 7400 (data) = self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 7401 return data 7402 7403 def update_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs): 7404 """ 7405 Updates an existing account custom field. 7406 This method updates an existing account custom field. 7407 This method makes a synchronous HTTP request by default. To make an 7408 asynchronous HTTP request, please define a `callback` function 7409 to be invoked when receiving the response. 7410 >>> def callback_function(response): 7411 >>> pprint(response) 7412 >>> 7413 >>> thread = api.update_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function) 7414 7415 :param callback function: The callback function 7416 for asynchronous request. (optional) 7417 :param str account_id: The external account number (int) or account ID Guid. (required) 7418 :param str custom_field_id: (required) 7419 :param str apply_to_templates: 7420 :param CustomField custom_field: 7421 :return: CustomFields 7422 If the method is called asynchronously, 7423 returns the request thread. 7424 """ 7425 7426 all_params = ['account_id', 'custom_field_id', 'apply_to_templates', 'custom_field'] 7427 all_params.append('callback') 7428 all_params.append('_return_http_data_only') 7429 all_params.append('_preload_content') 7430 all_params.append('_request_timeout') 7431 7432 params = locals() 7433 for key, val in iteritems(params['kwargs']): 7434 if key not in all_params: 7435 raise TypeError( 7436 "Got an unexpected keyword argument '%s'" 7437 " to method update_custom_field" % key 7438 ) 7439 params[key] = val 7440 del params['kwargs'] 7441 # verify the required parameter 'account_id' is set 7442 if ('account_id' not in params) or (params['account_id'] is None): 7443 raise ValueError("Missing the required parameter `account_id` when calling `update_custom_field`") 7444 # verify the required parameter 'custom_field_id' is set 7445 if ('custom_field_id' not in params) or (params['custom_field_id'] is None): 7446 raise ValueError("Missing the required parameter `custom_field_id` when calling `update_custom_field`") 7447 7448 7449 collection_formats = {} 7450 7451 resource_path = '/v2.1/accounts/{accountId}/custom_fields/{customFieldId}'.replace('{format}', 'json') 7452 path_params = {} 7453 if 'account_id' in params: 7454 path_params['accountId'] = params['account_id'] 7455 if 'custom_field_id' in params: 7456 path_params['customFieldId'] = params['custom_field_id'] 7457 7458 query_params = {} 7459 if 'apply_to_templates' in params: 7460 query_params['apply_to_templates'] = params['apply_to_templates'] 7461 7462 header_params = {} 7463 7464 form_params = [] 7465 local_var_files = {} 7466 7467 body_params = None 7468 if 'custom_field' in params: 7469 body_params = params['custom_field'] 7470 # HTTP header `Accept` 7471 header_params['Accept'] = self.api_client.\ 7472 select_header_accept(['application/json']) 7473 7474 # Authentication setting 7475 auth_settings = [] 7476 7477 return self.api_client.call_api(resource_path, 'PUT', 7478 path_params, 7479 query_params, 7480 header_params, 7481 body=body_params, 7482 post_params=form_params, 7483 files=local_var_files, 7484 response_type='CustomFields', 7485 auth_settings=auth_settings, 7486 callback=params.get('callback'), 7487 _return_http_data_only=params.get('_return_http_data_only'), 7488 _preload_content=params.get('_preload_content', True), 7489 _request_timeout=params.get('_request_timeout'), 7490 collection_formats=collection_formats) 7491 7492 def update_e_note_configuration(self, account_id, **kwargs): 7493 """ 7494 Updates configuration information for the eNote eOriginal integration. 7495 7496 This method makes a synchronous HTTP request by default. To make an 7497 asynchronous HTTP request, please define a `callback` function 7498 to be invoked when receiving the response. 7499 >>> def callback_function(response): 7500 >>> pprint(response) 7501 >>> 7502 >>> thread = api.update_e_note_configuration(account_id, callback=callback_function) 7503 7504 :param callback function: The callback function 7505 for asynchronous request. (optional) 7506 :param str account_id: The external account number (int) or account ID Guid. (required) 7507 :param ENoteConfiguration e_note_configuration: 7508 :return: ENoteConfiguration 7509 If the method is called asynchronously, 7510 returns the request thread. 7511 """ 7512 kwargs['_return_http_data_only'] = True 7513 if kwargs.get('callback'): 7514 return self.update_e_note_configuration_with_http_info(account_id, **kwargs) 7515 else: 7516 (data) = self.update_e_note_configuration_with_http_info(account_id, **kwargs) 7517 return data 7518 7519 def update_e_note_configuration_with_http_info(self, account_id, **kwargs): 7520 """ 7521 Updates configuration information for the eNote eOriginal integration. 7522 7523 This method makes a synchronous HTTP request by default. To make an 7524 asynchronous HTTP request, please define a `callback` function 7525 to be invoked when receiving the response. 7526 >>> def callback_function(response): 7527 >>> pprint(response) 7528 >>> 7529 >>> thread = api.update_e_note_configuration_with_http_info(account_id, callback=callback_function) 7530 7531 :param callback function: The callback function 7532 for asynchronous request. (optional) 7533 :param str account_id: The external account number (int) or account ID Guid. (required) 7534 :param ENoteConfiguration e_note_configuration: 7535 :return: ENoteConfiguration 7536 If the method is called asynchronously, 7537 returns the request thread. 7538 """ 7539 7540 all_params = ['account_id', 'e_note_configuration'] 7541 all_params.append('callback') 7542 all_params.append('_return_http_data_only') 7543 all_params.append('_preload_content') 7544 all_params.append('_request_timeout') 7545 7546 params = locals() 7547 for key, val in iteritems(params['kwargs']): 7548 if key not in all_params: 7549 raise TypeError( 7550 "Got an unexpected keyword argument '%s'" 7551 " to method update_e_note_configuration" % key 7552 ) 7553 params[key] = val 7554 del params['kwargs'] 7555 # verify the required parameter 'account_id' is set 7556 if ('account_id' not in params) or (params['account_id'] is None): 7557 raise ValueError("Missing the required parameter `account_id` when calling `update_e_note_configuration`") 7558 7559 7560 collection_formats = {} 7561 7562 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 7563 path_params = {} 7564 if 'account_id' in params: 7565 path_params['accountId'] = params['account_id'] 7566 7567 query_params = {} 7568 7569 header_params = {} 7570 7571 form_params = [] 7572 local_var_files = {} 7573 7574 body_params = None 7575 if 'e_note_configuration' in params: 7576 body_params = params['e_note_configuration'] 7577 # HTTP header `Accept` 7578 header_params['Accept'] = self.api_client.\ 7579 select_header_accept(['application/json']) 7580 7581 # Authentication setting 7582 auth_settings = [] 7583 7584 return self.api_client.call_api(resource_path, 'PUT', 7585 path_params, 7586 query_params, 7587 header_params, 7588 body=body_params, 7589 post_params=form_params, 7590 files=local_var_files, 7591 response_type='ENoteConfiguration', 7592 auth_settings=auth_settings, 7593 callback=params.get('callback'), 7594 _return_http_data_only=params.get('_return_http_data_only'), 7595 _preload_content=params.get('_preload_content', True), 7596 _request_timeout=params.get('_request_timeout'), 7597 collection_formats=collection_formats) 7598 7599 def update_envelope_purge_configuration(self, account_id, **kwargs): 7600 """ 7601 Updates envelope purge configuration. 7602 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). 7603 This method makes a synchronous HTTP request by default. To make an 7604 asynchronous HTTP request, please define a `callback` function 7605 to be invoked when receiving the response. 7606 >>> def callback_function(response): 7607 >>> pprint(response) 7608 >>> 7609 >>> thread = api.update_envelope_purge_configuration(account_id, callback=callback_function) 7610 7611 :param callback function: The callback function 7612 for asynchronous request. (optional) 7613 :param str account_id: The external account number (int) or account ID Guid. (required) 7614 :param EnvelopePurgeConfiguration envelope_purge_configuration: 7615 :return: EnvelopePurgeConfiguration 7616 If the method is called asynchronously, 7617 returns the request thread. 7618 """ 7619 kwargs['_return_http_data_only'] = True 7620 if kwargs.get('callback'): 7621 return self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs) 7622 else: 7623 (data) = self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs) 7624 return data 7625 7626 def update_envelope_purge_configuration_with_http_info(self, account_id, **kwargs): 7627 """ 7628 Updates envelope purge configuration. 7629 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). 7630 This method makes a synchronous HTTP request by default. To make an 7631 asynchronous HTTP request, please define a `callback` function 7632 to be invoked when receiving the response. 7633 >>> def callback_function(response): 7634 >>> pprint(response) 7635 >>> 7636 >>> thread = api.update_envelope_purge_configuration_with_http_info(account_id, callback=callback_function) 7637 7638 :param callback function: The callback function 7639 for asynchronous request. (optional) 7640 :param str account_id: The external account number (int) or account ID Guid. (required) 7641 :param EnvelopePurgeConfiguration envelope_purge_configuration: 7642 :return: EnvelopePurgeConfiguration 7643 If the method is called asynchronously, 7644 returns the request thread. 7645 """ 7646 7647 all_params = ['account_id', 'envelope_purge_configuration'] 7648 all_params.append('callback') 7649 all_params.append('_return_http_data_only') 7650 all_params.append('_preload_content') 7651 all_params.append('_request_timeout') 7652 7653 params = locals() 7654 for key, val in iteritems(params['kwargs']): 7655 if key not in all_params: 7656 raise TypeError( 7657 "Got an unexpected keyword argument '%s'" 7658 " to method update_envelope_purge_configuration" % key 7659 ) 7660 params[key] = val 7661 del params['kwargs'] 7662 # verify the required parameter 'account_id' is set 7663 if ('account_id' not in params) or (params['account_id'] is None): 7664 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_purge_configuration`") 7665 7666 7667 collection_formats = {} 7668 7669 resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json') 7670 path_params = {} 7671 if 'account_id' in params: 7672 path_params['accountId'] = params['account_id'] 7673 7674 query_params = {} 7675 7676 header_params = {} 7677 7678 form_params = [] 7679 local_var_files = {} 7680 7681 body_params = None 7682 if 'envelope_purge_configuration' in params: 7683 body_params = params['envelope_purge_configuration'] 7684 # HTTP header `Accept` 7685 header_params['Accept'] = self.api_client.\ 7686 select_header_accept(['application/json']) 7687 7688 # Authentication setting 7689 auth_settings = [] 7690 7691 return self.api_client.call_api(resource_path, 'PUT', 7692 path_params, 7693 query_params, 7694 header_params, 7695 body=body_params, 7696 post_params=form_params, 7697 files=local_var_files, 7698 response_type='EnvelopePurgeConfiguration', 7699 auth_settings=auth_settings, 7700 callback=params.get('callback'), 7701 _return_http_data_only=params.get('_return_http_data_only'), 7702 _preload_content=params.get('_preload_content', True), 7703 _request_timeout=params.get('_request_timeout'), 7704 collection_formats=collection_formats) 7705 7706 def update_favorite_template(self, account_id, **kwargs): 7707 """ 7708 Favorites a template 7709 7710 This method makes a synchronous HTTP request by default. To make an 7711 asynchronous HTTP request, please define a `callback` function 7712 to be invoked when receiving the response. 7713 >>> def callback_function(response): 7714 >>> pprint(response) 7715 >>> 7716 >>> thread = api.update_favorite_template(account_id, callback=callback_function) 7717 7718 :param callback function: The callback function 7719 for asynchronous request. (optional) 7720 :param str account_id: The external account number (int) or account ID Guid. (required) 7721 :param FavoriteTemplatesInfo favorite_templates_info: 7722 :return: FavoriteTemplatesInfo 7723 If the method is called asynchronously, 7724 returns the request thread. 7725 """ 7726 kwargs['_return_http_data_only'] = True 7727 if kwargs.get('callback'): 7728 return self.update_favorite_template_with_http_info(account_id, **kwargs) 7729 else: 7730 (data) = self.update_favorite_template_with_http_info(account_id, **kwargs) 7731 return data 7732 7733 def update_favorite_template_with_http_info(self, account_id, **kwargs): 7734 """ 7735 Favorites a template 7736 7737 This method makes a synchronous HTTP request by default. To make an 7738 asynchronous HTTP request, please define a `callback` function 7739 to be invoked when receiving the response. 7740 >>> def callback_function(response): 7741 >>> pprint(response) 7742 >>> 7743 >>> thread = api.update_favorite_template_with_http_info(account_id, callback=callback_function) 7744 7745 :param callback function: The callback function 7746 for asynchronous request. (optional) 7747 :param str account_id: The external account number (int) or account ID Guid. (required) 7748 :param FavoriteTemplatesInfo favorite_templates_info: 7749 :return: FavoriteTemplatesInfo 7750 If the method is called asynchronously, 7751 returns the request thread. 7752 """ 7753 7754 all_params = ['account_id', 'favorite_templates_info'] 7755 all_params.append('callback') 7756 all_params.append('_return_http_data_only') 7757 all_params.append('_preload_content') 7758 all_params.append('_request_timeout') 7759 7760 params = locals() 7761 for key, val in iteritems(params['kwargs']): 7762 if key not in all_params: 7763 raise TypeError( 7764 "Got an unexpected keyword argument '%s'" 7765 " to method update_favorite_template" % key 7766 ) 7767 params[key] = val 7768 del params['kwargs'] 7769 # verify the required parameter 'account_id' is set 7770 if ('account_id' not in params) or (params['account_id'] is None): 7771 raise ValueError("Missing the required parameter `account_id` when calling `update_favorite_template`") 7772 7773 7774 collection_formats = {} 7775 7776 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 7777 path_params = {} 7778 if 'account_id' in params: 7779 path_params['accountId'] = params['account_id'] 7780 7781 query_params = {} 7782 7783 header_params = {} 7784 7785 form_params = [] 7786 local_var_files = {} 7787 7788 body_params = None 7789 if 'favorite_templates_info' in params: 7790 body_params = params['favorite_templates_info'] 7791 # HTTP header `Accept` 7792 header_params['Accept'] = self.api_client.\ 7793 select_header_accept(['application/json']) 7794 7795 # Authentication setting 7796 auth_settings = [] 7797 7798 return self.api_client.call_api(resource_path, 'PUT', 7799 path_params, 7800 query_params, 7801 header_params, 7802 body=body_params, 7803 post_params=form_params, 7804 files=local_var_files, 7805 response_type='FavoriteTemplatesInfo', 7806 auth_settings=auth_settings, 7807 callback=params.get('callback'), 7808 _return_http_data_only=params.get('_return_http_data_only'), 7809 _preload_content=params.get('_preload_content', True), 7810 _request_timeout=params.get('_request_timeout'), 7811 collection_formats=collection_formats) 7812 7813 def update_notification_defaults(self, account_id, **kwargs): 7814 """ 7815 Updates default user level settings for a specified account 7816 This method changes the default settings for the email notifications that signers and senders receive about envelopes. 7817 This method makes a synchronous HTTP request by default. To make an 7818 asynchronous HTTP request, please define a `callback` function 7819 to be invoked when receiving the response. 7820 >>> def callback_function(response): 7821 >>> pprint(response) 7822 >>> 7823 >>> thread = api.update_notification_defaults(account_id, callback=callback_function) 7824 7825 :param callback function: The callback function 7826 for asynchronous request. (optional) 7827 :param str account_id: The external account number (int) or account ID Guid. (required) 7828 :param NotificationDefaults notification_defaults: 7829 :return: NotificationDefaults 7830 If the method is called asynchronously, 7831 returns the request thread. 7832 """ 7833 kwargs['_return_http_data_only'] = True 7834 if kwargs.get('callback'): 7835 return self.update_notification_defaults_with_http_info(account_id, **kwargs) 7836 else: 7837 (data) = self.update_notification_defaults_with_http_info(account_id, **kwargs) 7838 return data 7839 7840 def update_notification_defaults_with_http_info(self, account_id, **kwargs): 7841 """ 7842 Updates default user level settings for a specified account 7843 This method changes the default settings for the email notifications that signers and senders receive about envelopes. 7844 This method makes a synchronous HTTP request by default. To make an 7845 asynchronous HTTP request, please define a `callback` function 7846 to be invoked when receiving the response. 7847 >>> def callback_function(response): 7848 >>> pprint(response) 7849 >>> 7850 >>> thread = api.update_notification_defaults_with_http_info(account_id, callback=callback_function) 7851 7852 :param callback function: The callback function 7853 for asynchronous request. (optional) 7854 :param str account_id: The external account number (int) or account ID Guid. (required) 7855 :param NotificationDefaults notification_defaults: 7856 :return: NotificationDefaults 7857 If the method is called asynchronously, 7858 returns the request thread. 7859 """ 7860 7861 all_params = ['account_id', 'notification_defaults'] 7862 all_params.append('callback') 7863 all_params.append('_return_http_data_only') 7864 all_params.append('_preload_content') 7865 all_params.append('_request_timeout') 7866 7867 params = locals() 7868 for key, val in iteritems(params['kwargs']): 7869 if key not in all_params: 7870 raise TypeError( 7871 "Got an unexpected keyword argument '%s'" 7872 " to method update_notification_defaults" % key 7873 ) 7874 params[key] = val 7875 del params['kwargs'] 7876 # verify the required parameter 'account_id' is set 7877 if ('account_id' not in params) or (params['account_id'] is None): 7878 raise ValueError("Missing the required parameter `account_id` when calling `update_notification_defaults`") 7879 7880 7881 collection_formats = {} 7882 7883 resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json') 7884 path_params = {} 7885 if 'account_id' in params: 7886 path_params['accountId'] = params['account_id'] 7887 7888 query_params = {} 7889 7890 header_params = {} 7891 7892 form_params = [] 7893 local_var_files = {} 7894 7895 body_params = None 7896 if 'notification_defaults' in params: 7897 body_params = params['notification_defaults'] 7898 # HTTP header `Accept` 7899 header_params['Accept'] = self.api_client.\ 7900 select_header_accept(['application/json']) 7901 7902 # Authentication setting 7903 auth_settings = [] 7904 7905 return self.api_client.call_api(resource_path, 'PUT', 7906 path_params, 7907 query_params, 7908 header_params, 7909 body=body_params, 7910 post_params=form_params, 7911 files=local_var_files, 7912 response_type='NotificationDefaults', 7913 auth_settings=auth_settings, 7914 callback=params.get('callback'), 7915 _return_http_data_only=params.get('_return_http_data_only'), 7916 _preload_content=params.get('_preload_content', True), 7917 _request_timeout=params.get('_request_timeout'), 7918 collection_formats=collection_formats) 7919 7920 def update_password_rules(self, account_id, **kwargs): 7921 """ 7922 Update the password rules 7923 This method updates the password rules for an account. **Note:** To update the password rules for an account, you must be an account administrator. 7924 This method makes a synchronous HTTP request by default. To make an 7925 asynchronous HTTP request, please define a `callback` function 7926 to be invoked when receiving the response. 7927 >>> def callback_function(response): 7928 >>> pprint(response) 7929 >>> 7930 >>> thread = api.update_password_rules(account_id, callback=callback_function) 7931 7932 :param callback function: The callback function 7933 for asynchronous request. (optional) 7934 :param str account_id: The external account number (int) or account ID Guid. (required) 7935 :param AccountPasswordRules account_password_rules: 7936 :return: AccountPasswordRules 7937 If the method is called asynchronously, 7938 returns the request thread. 7939 """ 7940 kwargs['_return_http_data_only'] = True 7941 if kwargs.get('callback'): 7942 return self.update_password_rules_with_http_info(account_id, **kwargs) 7943 else: 7944 (data) = self.update_password_rules_with_http_info(account_id, **kwargs) 7945 return data 7946 7947 def update_password_rules_with_http_info(self, account_id, **kwargs): 7948 """ 7949 Update the password rules 7950 This method updates the password rules for an account. **Note:** To update the password rules for an account, you must be an account administrator. 7951 This method makes a synchronous HTTP request by default. To make an 7952 asynchronous HTTP request, please define a `callback` function 7953 to be invoked when receiving the response. 7954 >>> def callback_function(response): 7955 >>> pprint(response) 7956 >>> 7957 >>> thread = api.update_password_rules_with_http_info(account_id, callback=callback_function) 7958 7959 :param callback function: The callback function 7960 for asynchronous request. (optional) 7961 :param str account_id: The external account number (int) or account ID Guid. (required) 7962 :param AccountPasswordRules account_password_rules: 7963 :return: AccountPasswordRules 7964 If the method is called asynchronously, 7965 returns the request thread. 7966 """ 7967 7968 all_params = ['account_id', 'account_password_rules'] 7969 all_params.append('callback') 7970 all_params.append('_return_http_data_only') 7971 all_params.append('_preload_content') 7972 all_params.append('_request_timeout') 7973 7974 params = locals() 7975 for key, val in iteritems(params['kwargs']): 7976 if key not in all_params: 7977 raise TypeError( 7978 "Got an unexpected keyword argument '%s'" 7979 " to method update_password_rules" % key 7980 ) 7981 params[key] = val 7982 del params['kwargs'] 7983 # verify the required parameter 'account_id' is set 7984 if ('account_id' not in params) or (params['account_id'] is None): 7985 raise ValueError("Missing the required parameter `account_id` when calling `update_password_rules`") 7986 7987 7988 collection_formats = {} 7989 7990 resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json') 7991 path_params = {} 7992 if 'account_id' in params: 7993 path_params['accountId'] = params['account_id'] 7994 7995 query_params = {} 7996 7997 header_params = {} 7998 7999 form_params = [] 8000 local_var_files = {} 8001 8002 body_params = None 8003 if 'account_password_rules' in params: 8004 body_params = params['account_password_rules'] 8005 # HTTP header `Accept` 8006 header_params['Accept'] = self.api_client.\ 8007 select_header_accept(['application/json']) 8008 8009 # Authentication setting 8010 auth_settings = [] 8011 8012 return self.api_client.call_api(resource_path, 'PUT', 8013 path_params, 8014 query_params, 8015 header_params, 8016 body=body_params, 8017 post_params=form_params, 8018 files=local_var_files, 8019 response_type='AccountPasswordRules', 8020 auth_settings=auth_settings, 8021 callback=params.get('callback'), 8022 _return_http_data_only=params.get('_return_http_data_only'), 8023 _preload_content=params.get('_preload_content', True), 8024 _request_timeout=params.get('_request_timeout'), 8025 collection_formats=collection_formats) 8026 8027 def update_permission_profile(self, account_id, permission_profile_id, **kwargs): 8028 """ 8029 Updates a permission profile within the specified account. 8030 This method updates an account permission profile. ### Related topics - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 8031 This method makes a synchronous HTTP request by default. To make an 8032 asynchronous HTTP request, please define a `callback` function 8033 to be invoked when receiving the response. 8034 >>> def callback_function(response): 8035 >>> pprint(response) 8036 >>> 8037 >>> thread = api.update_permission_profile(account_id, permission_profile_id, callback=callback_function) 8038 8039 :param callback function: The callback function 8040 for asynchronous request. (optional) 8041 :param str account_id: The external account number (int) or account ID Guid. (required) 8042 :param str permission_profile_id: (required) 8043 :param str include: 8044 :param PermissionProfile permission_profile: 8045 :return: PermissionProfile 8046 If the method is called asynchronously, 8047 returns the request thread. 8048 """ 8049 kwargs['_return_http_data_only'] = True 8050 if kwargs.get('callback'): 8051 return self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 8052 else: 8053 (data) = self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 8054 return data 8055 8056 def update_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 8057 """ 8058 Updates a permission profile within the specified account. 8059 This method updates an account permission profile. ### Related topics - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 8060 This method makes a synchronous HTTP request by default. To make an 8061 asynchronous HTTP request, please define a `callback` function 8062 to be invoked when receiving the response. 8063 >>> def callback_function(response): 8064 >>> pprint(response) 8065 >>> 8066 >>> thread = api.update_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 8067 8068 :param callback function: The callback function 8069 for asynchronous request. (optional) 8070 :param str account_id: The external account number (int) or account ID Guid. (required) 8071 :param str permission_profile_id: (required) 8072 :param str include: 8073 :param PermissionProfile permission_profile: 8074 :return: PermissionProfile 8075 If the method is called asynchronously, 8076 returns the request thread. 8077 """ 8078 8079 all_params = ['account_id', 'permission_profile_id', 'include', 'permission_profile'] 8080 all_params.append('callback') 8081 all_params.append('_return_http_data_only') 8082 all_params.append('_preload_content') 8083 all_params.append('_request_timeout') 8084 8085 params = locals() 8086 for key, val in iteritems(params['kwargs']): 8087 if key not in all_params: 8088 raise TypeError( 8089 "Got an unexpected keyword argument '%s'" 8090 " to method update_permission_profile" % key 8091 ) 8092 params[key] = val 8093 del params['kwargs'] 8094 # verify the required parameter 'account_id' is set 8095 if ('account_id' not in params) or (params['account_id'] is None): 8096 raise ValueError("Missing the required parameter `account_id` when calling `update_permission_profile`") 8097 # verify the required parameter 'permission_profile_id' is set 8098 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 8099 raise ValueError("Missing the required parameter `permission_profile_id` when calling `update_permission_profile`") 8100 8101 8102 collection_formats = {} 8103 8104 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 8105 path_params = {} 8106 if 'account_id' in params: 8107 path_params['accountId'] = params['account_id'] 8108 if 'permission_profile_id' in params: 8109 path_params['permissionProfileId'] = params['permission_profile_id'] 8110 8111 query_params = {} 8112 if 'include' in params: 8113 query_params['include'] = params['include'] 8114 8115 header_params = {} 8116 8117 form_params = [] 8118 local_var_files = {} 8119 8120 body_params = None 8121 if 'permission_profile' in params: 8122 body_params = params['permission_profile'] 8123 # HTTP header `Accept` 8124 header_params['Accept'] = self.api_client.\ 8125 select_header_accept(['application/json']) 8126 8127 # Authentication setting 8128 auth_settings = [] 8129 8130 return self.api_client.call_api(resource_path, 'PUT', 8131 path_params, 8132 query_params, 8133 header_params, 8134 body=body_params, 8135 post_params=form_params, 8136 files=local_var_files, 8137 response_type='PermissionProfile', 8138 auth_settings=auth_settings, 8139 callback=params.get('callback'), 8140 _return_http_data_only=params.get('_return_http_data_only'), 8141 _preload_content=params.get('_preload_content', True), 8142 _request_timeout=params.get('_request_timeout'), 8143 collection_formats=collection_formats) 8144 8145 def update_settings(self, account_id, **kwargs): 8146 """ 8147 Updates the account settings for an account. 8148 Updates the account settings for the specified account. 8149 This method makes a synchronous HTTP request by default. To make an 8150 asynchronous HTTP request, please define a `callback` function 8151 to be invoked when receiving the response. 8152 >>> def callback_function(response): 8153 >>> pprint(response) 8154 >>> 8155 >>> thread = api.update_settings(account_id, callback=callback_function) 8156 8157 :param callback function: The callback function 8158 for asynchronous request. (optional) 8159 :param str account_id: The external account number (int) or account ID Guid. (required) 8160 :param AccountSettingsInformation account_settings_information: 8161 :return: None 8162 If the method is called asynchronously, 8163 returns the request thread. 8164 """ 8165 kwargs['_return_http_data_only'] = True 8166 if kwargs.get('callback'): 8167 return self.update_settings_with_http_info(account_id, **kwargs) 8168 else: 8169 (data) = self.update_settings_with_http_info(account_id, **kwargs) 8170 return data 8171 8172 def update_settings_with_http_info(self, account_id, **kwargs): 8173 """ 8174 Updates the account settings for an account. 8175 Updates the account settings for the specified account. 8176 This method makes a synchronous HTTP request by default. To make an 8177 asynchronous HTTP request, please define a `callback` function 8178 to be invoked when receiving the response. 8179 >>> def callback_function(response): 8180 >>> pprint(response) 8181 >>> 8182 >>> thread = api.update_settings_with_http_info(account_id, callback=callback_function) 8183 8184 :param callback function: The callback function 8185 for asynchronous request. (optional) 8186 :param str account_id: The external account number (int) or account ID Guid. (required) 8187 :param AccountSettingsInformation account_settings_information: 8188 :return: None 8189 If the method is called asynchronously, 8190 returns the request thread. 8191 """ 8192 8193 all_params = ['account_id', 'account_settings_information'] 8194 all_params.append('callback') 8195 all_params.append('_return_http_data_only') 8196 all_params.append('_preload_content') 8197 all_params.append('_request_timeout') 8198 8199 params = locals() 8200 for key, val in iteritems(params['kwargs']): 8201 if key not in all_params: 8202 raise TypeError( 8203 "Got an unexpected keyword argument '%s'" 8204 " to method update_settings" % key 8205 ) 8206 params[key] = val 8207 del params['kwargs'] 8208 # verify the required parameter 'account_id' is set 8209 if ('account_id' not in params) or (params['account_id'] is None): 8210 raise ValueError("Missing the required parameter `account_id` when calling `update_settings`") 8211 8212 8213 collection_formats = {} 8214 8215 resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json') 8216 path_params = {} 8217 if 'account_id' in params: 8218 path_params['accountId'] = params['account_id'] 8219 8220 query_params = {} 8221 8222 header_params = {} 8223 8224 form_params = [] 8225 local_var_files = {} 8226 8227 body_params = None 8228 if 'account_settings_information' in params: 8229 body_params = params['account_settings_information'] 8230 # HTTP header `Accept` 8231 header_params['Accept'] = self.api_client.\ 8232 select_header_accept(['application/json']) 8233 8234 # Authentication setting 8235 auth_settings = [] 8236 8237 return self.api_client.call_api(resource_path, 'PUT', 8238 path_params, 8239 query_params, 8240 header_params, 8241 body=body_params, 8242 post_params=form_params, 8243 files=local_var_files, 8244 response_type=None, 8245 auth_settings=auth_settings, 8246 callback=params.get('callback'), 8247 _return_http_data_only=params.get('_return_http_data_only'), 8248 _preload_content=params.get('_preload_content', True), 8249 _request_timeout=params.get('_request_timeout'), 8250 collection_formats=collection_formats) 8251 8252 def update_shared_access(self, account_id, **kwargs): 8253 """ 8254 Reserved: Sets the shared access information for users. 8255 Reserved: Sets the shared access information for one or more users. 8256 This method makes a synchronous HTTP request by default. To make an 8257 asynchronous HTTP request, please define a `callback` function 8258 to be invoked when receiving the response. 8259 >>> def callback_function(response): 8260 >>> pprint(response) 8261 >>> 8262 >>> thread = api.update_shared_access(account_id, callback=callback_function) 8263 8264 :param callback function: The callback function 8265 for asynchronous request. (optional) 8266 :param str account_id: The external account number (int) or account ID Guid. (required) 8267 :param str item_type: 8268 :param str preserve_existing_shared_access: 8269 :param str user_ids: 8270 :param AccountSharedAccess account_shared_access: 8271 :return: AccountSharedAccess 8272 If the method is called asynchronously, 8273 returns the request thread. 8274 """ 8275 kwargs['_return_http_data_only'] = True 8276 if kwargs.get('callback'): 8277 return self.update_shared_access_with_http_info(account_id, **kwargs) 8278 else: 8279 (data) = self.update_shared_access_with_http_info(account_id, **kwargs) 8280 return data 8281 8282 def update_shared_access_with_http_info(self, account_id, **kwargs): 8283 """ 8284 Reserved: Sets the shared access information for users. 8285 Reserved: Sets the shared access information for one or more users. 8286 This method makes a synchronous HTTP request by default. To make an 8287 asynchronous HTTP request, please define a `callback` function 8288 to be invoked when receiving the response. 8289 >>> def callback_function(response): 8290 >>> pprint(response) 8291 >>> 8292 >>> thread = api.update_shared_access_with_http_info(account_id, callback=callback_function) 8293 8294 :param callback function: The callback function 8295 for asynchronous request. (optional) 8296 :param str account_id: The external account number (int) or account ID Guid. (required) 8297 :param str item_type: 8298 :param str preserve_existing_shared_access: 8299 :param str user_ids: 8300 :param AccountSharedAccess account_shared_access: 8301 :return: AccountSharedAccess 8302 If the method is called asynchronously, 8303 returns the request thread. 8304 """ 8305 8306 all_params = ['account_id', 'item_type', 'preserve_existing_shared_access', 'user_ids', 'account_shared_access'] 8307 all_params.append('callback') 8308 all_params.append('_return_http_data_only') 8309 all_params.append('_preload_content') 8310 all_params.append('_request_timeout') 8311 8312 params = locals() 8313 for key, val in iteritems(params['kwargs']): 8314 if key not in all_params: 8315 raise TypeError( 8316 "Got an unexpected keyword argument '%s'" 8317 " to method update_shared_access" % key 8318 ) 8319 params[key] = val 8320 del params['kwargs'] 8321 # verify the required parameter 'account_id' is set 8322 if ('account_id' not in params) or (params['account_id'] is None): 8323 raise ValueError("Missing the required parameter `account_id` when calling `update_shared_access`") 8324 8325 8326 collection_formats = {} 8327 8328 resource_path = '/v2.1/accounts/{accountId}/shared_access'.replace('{format}', 'json') 8329 path_params = {} 8330 if 'account_id' in params: 8331 path_params['accountId'] = params['account_id'] 8332 8333 query_params = {} 8334 if 'item_type' in params: 8335 query_params['item_type'] = params['item_type'] 8336 if 'preserve_existing_shared_access' in params: 8337 query_params['preserve_existing_shared_access'] = params['preserve_existing_shared_access'] 8338 if 'user_ids' in params: 8339 query_params['user_ids'] = params['user_ids'] 8340 8341 header_params = {} 8342 8343 form_params = [] 8344 local_var_files = {} 8345 8346 body_params = None 8347 if 'account_shared_access' in params: 8348 body_params = params['account_shared_access'] 8349 # HTTP header `Accept` 8350 header_params['Accept'] = self.api_client.\ 8351 select_header_accept(['application/json']) 8352 8353 # Authentication setting 8354 auth_settings = [] 8355 8356 return self.api_client.call_api(resource_path, 'PUT', 8357 path_params, 8358 query_params, 8359 header_params, 8360 body=body_params, 8361 post_params=form_params, 8362 files=local_var_files, 8363 response_type='AccountSharedAccess', 8364 auth_settings=auth_settings, 8365 callback=params.get('callback'), 8366 _return_http_data_only=params.get('_return_http_data_only'), 8367 _preload_content=params.get('_preload_content', True), 8368 _request_timeout=params.get('_request_timeout'), 8369 collection_formats=collection_formats) 8370 8371 def update_user_authorization(self, account_id, authorization_id, user_id, **kwargs): 8372 """ 8373 Updates the user authorization 8374 This method makes a synchronous HTTP request by default. To make an 8375 asynchronous HTTP request, please define a `callback` function 8376 to be invoked when receiving the response. 8377 >>> def callback_function(response): 8378 >>> pprint(response) 8379 >>> 8380 >>> thread = api.update_user_authorization(account_id, authorization_id, user_id, callback=callback_function) 8381 8382 :param callback function: The callback function 8383 for asynchronous request. (optional) 8384 :param str account_id: The external account number (int) or account ID Guid. (required) 8385 :param str authorization_id: (required) 8386 :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) 8387 :param UserAuthorizationUpdateRequest user_authorization_update_request: 8388 :return: UserAuthorization 8389 If the method is called asynchronously, 8390 returns the request thread. 8391 """ 8392 kwargs['_return_http_data_only'] = True 8393 if kwargs.get('callback'): 8394 return self.update_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 8395 else: 8396 (data) = self.update_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 8397 return data 8398 8399 def update_user_authorization_with_http_info(self, account_id, authorization_id, user_id, **kwargs): 8400 """ 8401 Updates the user authorization 8402 This method makes a synchronous HTTP request by default. To make an 8403 asynchronous HTTP request, please define a `callback` function 8404 to be invoked when receiving the response. 8405 >>> def callback_function(response): 8406 >>> pprint(response) 8407 >>> 8408 >>> thread = api.update_user_authorization_with_http_info(account_id, authorization_id, user_id, callback=callback_function) 8409 8410 :param callback function: The callback function 8411 for asynchronous request. (optional) 8412 :param str account_id: The external account number (int) or account ID Guid. (required) 8413 :param str authorization_id: (required) 8414 :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) 8415 :param UserAuthorizationUpdateRequest user_authorization_update_request: 8416 :return: UserAuthorization 8417 If the method is called asynchronously, 8418 returns the request thread. 8419 """ 8420 8421 all_params = ['account_id', 'authorization_id', 'user_id', 'user_authorization_update_request'] 8422 all_params.append('callback') 8423 all_params.append('_return_http_data_only') 8424 all_params.append('_preload_content') 8425 all_params.append('_request_timeout') 8426 8427 params = locals() 8428 for key, val in iteritems(params['kwargs']): 8429 if key not in all_params: 8430 raise TypeError( 8431 "Got an unexpected keyword argument '%s'" 8432 " to method update_user_authorization" % key 8433 ) 8434 params[key] = val 8435 del params['kwargs'] 8436 # verify the required parameter 'account_id' is set 8437 if ('account_id' not in params) or (params['account_id'] is None): 8438 raise ValueError("Missing the required parameter `account_id` when calling `update_user_authorization`") 8439 # verify the required parameter 'authorization_id' is set 8440 if ('authorization_id' not in params) or (params['authorization_id'] is None): 8441 raise ValueError("Missing the required parameter `authorization_id` when calling `update_user_authorization`") 8442 # verify the required parameter 'user_id' is set 8443 if ('user_id' not in params) or (params['user_id'] is None): 8444 raise ValueError("Missing the required parameter `user_id` when calling `update_user_authorization`") 8445 8446 8447 collection_formats = {} 8448 8449 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorization/{authorizationId}'.replace('{format}', 'json') 8450 path_params = {} 8451 if 'account_id' in params: 8452 path_params['accountId'] = params['account_id'] 8453 if 'authorization_id' in params: 8454 path_params['authorizationId'] = params['authorization_id'] 8455 if 'user_id' in params: 8456 path_params['userId'] = params['user_id'] 8457 8458 query_params = {} 8459 8460 header_params = {} 8461 8462 form_params = [] 8463 local_var_files = {} 8464 8465 body_params = None 8466 if 'user_authorization_update_request' in params: 8467 body_params = params['user_authorization_update_request'] 8468 # HTTP header `Accept` 8469 header_params['Accept'] = self.api_client.\ 8470 select_header_accept(['application/json']) 8471 8472 # Authentication setting 8473 auth_settings = [] 8474 8475 return self.api_client.call_api(resource_path, 'PUT', 8476 path_params, 8477 query_params, 8478 header_params, 8479 body=body_params, 8480 post_params=form_params, 8481 files=local_var_files, 8482 response_type='UserAuthorization', 8483 auth_settings=auth_settings, 8484 callback=params.get('callback'), 8485 _return_http_data_only=params.get('_return_http_data_only'), 8486 _preload_content=params.get('_preload_content', True), 8487 _request_timeout=params.get('_request_timeout'), 8488 collection_formats=collection_formats) 8489 8490 def update_watermark(self, account_id, **kwargs): 8491 """ 8492 Update watermark information. 8493 8494 This method makes a synchronous HTTP request by default. To make an 8495 asynchronous HTTP request, please define a `callback` function 8496 to be invoked when receiving the response. 8497 >>> def callback_function(response): 8498 >>> pprint(response) 8499 >>> 8500 >>> thread = api.update_watermark(account_id, callback=callback_function) 8501 8502 :param callback function: The callback function 8503 for asynchronous request. (optional) 8504 :param str account_id: The external account number (int) or account ID Guid. (required) 8505 :param Watermark watermark: 8506 :return: Watermark 8507 If the method is called asynchronously, 8508 returns the request thread. 8509 """ 8510 kwargs['_return_http_data_only'] = True 8511 if kwargs.get('callback'): 8512 return self.update_watermark_with_http_info(account_id, **kwargs) 8513 else: 8514 (data) = self.update_watermark_with_http_info(account_id, **kwargs) 8515 return data 8516 8517 def update_watermark_with_http_info(self, account_id, **kwargs): 8518 """ 8519 Update watermark information. 8520 8521 This method makes a synchronous HTTP request by default. To make an 8522 asynchronous HTTP request, please define a `callback` function 8523 to be invoked when receiving the response. 8524 >>> def callback_function(response): 8525 >>> pprint(response) 8526 >>> 8527 >>> thread = api.update_watermark_with_http_info(account_id, callback=callback_function) 8528 8529 :param callback function: The callback function 8530 for asynchronous request. (optional) 8531 :param str account_id: The external account number (int) or account ID Guid. (required) 8532 :param Watermark watermark: 8533 :return: Watermark 8534 If the method is called asynchronously, 8535 returns the request thread. 8536 """ 8537 8538 all_params = ['account_id', 'watermark'] 8539 all_params.append('callback') 8540 all_params.append('_return_http_data_only') 8541 all_params.append('_preload_content') 8542 all_params.append('_request_timeout') 8543 8544 params = locals() 8545 for key, val in iteritems(params['kwargs']): 8546 if key not in all_params: 8547 raise TypeError( 8548 "Got an unexpected keyword argument '%s'" 8549 " to method update_watermark" % key 8550 ) 8551 params[key] = val 8552 del params['kwargs'] 8553 # verify the required parameter 'account_id' is set 8554 if ('account_id' not in params) or (params['account_id'] is None): 8555 raise ValueError("Missing the required parameter `account_id` when calling `update_watermark`") 8556 8557 8558 collection_formats = {} 8559 8560 resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json') 8561 path_params = {} 8562 if 'account_id' in params: 8563 path_params['accountId'] = params['account_id'] 8564 8565 query_params = {} 8566 8567 header_params = {} 8568 8569 form_params = [] 8570 local_var_files = {} 8571 8572 body_params = None 8573 if 'watermark' in params: 8574 body_params = params['watermark'] 8575 # HTTP header `Accept` 8576 header_params['Accept'] = self.api_client.\ 8577 select_header_accept(['application/json']) 8578 8579 # Authentication setting 8580 auth_settings = [] 8581 8582 return self.api_client.call_api(resource_path, 'PUT', 8583 path_params, 8584 query_params, 8585 header_params, 8586 body=body_params, 8587 post_params=form_params, 8588 files=local_var_files, 8589 response_type='Watermark', 8590 auth_settings=auth_settings, 8591 callback=params.get('callback'), 8592 _return_http_data_only=params.get('_return_http_data_only'), 8593 _preload_content=params.get('_preload_content', True), 8594 _request_timeout=params.get('_request_timeout'), 8595 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_completion_rate_for_template(self, account_id, template_id, **kwargs): 3746 """ 3747 Gets completion rate for the template 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_completion_rate_for_template(account_id, template_id, 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 template_id: The ID of the template being accessed. (required) 3760 :return: TemplateCompletionRateResponse 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_completion_rate_for_template_with_http_info(account_id, template_id, **kwargs) 3767 else: 3768 (data) = self.get_completion_rate_for_template_with_http_info(account_id, template_id, **kwargs) 3769 return data 3770 3771 def get_completion_rate_for_template_with_http_info(self, account_id, template_id, **kwargs): 3772 """ 3773 Gets completion rate for the template 3774 This method makes a synchronous HTTP request by default. To make an 3775 asynchronous HTTP request, please define a `callback` function 3776 to be invoked when receiving the response. 3777 >>> def callback_function(response): 3778 >>> pprint(response) 3779 >>> 3780 >>> thread = api.get_completion_rate_for_template_with_http_info(account_id, template_id, callback=callback_function) 3781 3782 :param callback function: The callback function 3783 for asynchronous request. (optional) 3784 :param str account_id: The external account number (int) or account ID Guid. (required) 3785 :param str template_id: The ID of the template being accessed. (required) 3786 :return: TemplateCompletionRateResponse 3787 If the method is called asynchronously, 3788 returns the request thread. 3789 """ 3790 3791 all_params = ['account_id', 'template_id'] 3792 all_params.append('callback') 3793 all_params.append('_return_http_data_only') 3794 all_params.append('_preload_content') 3795 all_params.append('_request_timeout') 3796 3797 params = locals() 3798 for key, val in iteritems(params['kwargs']): 3799 if key not in all_params: 3800 raise TypeError( 3801 "Got an unexpected keyword argument '%s'" 3802 " to method get_completion_rate_for_template" % key 3803 ) 3804 params[key] = val 3805 del params['kwargs'] 3806 # verify the required parameter 'account_id' is set 3807 if ('account_id' not in params) or (params['account_id'] is None): 3808 raise ValueError("Missing the required parameter `account_id` when calling `get_completion_rate_for_template`") 3809 # verify the required parameter 'template_id' is set 3810 if ('template_id' not in params) or (params['template_id'] is None): 3811 raise ValueError("Missing the required parameter `template_id` when calling `get_completion_rate_for_template`") 3812 3813 3814 collection_formats = {} 3815 3816 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/insights/completionRate'.replace('{format}', 'json') 3817 path_params = {} 3818 if 'account_id' in params: 3819 path_params['accountId'] = params['account_id'] 3820 if 'template_id' in params: 3821 path_params['templateId'] = params['template_id'] 3822 3823 query_params = {} 3824 3825 header_params = {} 3826 3827 form_params = [] 3828 local_var_files = {} 3829 3830 body_params = None 3831 # HTTP header `Accept` 3832 header_params['Accept'] = self.api_client.\ 3833 select_header_accept(['application/json']) 3834 3835 # Authentication setting 3836 auth_settings = [] 3837 3838 return self.api_client.call_api(resource_path, 'GET', 3839 path_params, 3840 query_params, 3841 header_params, 3842 body=body_params, 3843 post_params=form_params, 3844 files=local_var_files, 3845 response_type='TemplateCompletionRateResponse', 3846 auth_settings=auth_settings, 3847 callback=params.get('callback'), 3848 _return_http_data_only=params.get('_return_http_data_only'), 3849 _preload_content=params.get('_preload_content', True), 3850 _request_timeout=params.get('_request_timeout'), 3851 collection_formats=collection_formats) 3852 3853 def get_completion_rate_for_template_owner(self, account_id, **kwargs): 3854 """ 3855 Gets completion rate for the user 3856 This method makes a synchronous HTTP request by default. To make an 3857 asynchronous HTTP request, please define a `callback` function 3858 to be invoked when receiving the response. 3859 >>> def callback_function(response): 3860 >>> pprint(response) 3861 >>> 3862 >>> thread = api.get_completion_rate_for_template_owner(account_id, callback=callback_function) 3863 3864 :param callback function: The callback function 3865 for asynchronous request. (optional) 3866 :param str account_id: The external account number (int) or account ID Guid. (required) 3867 :return: UserCompletionRateResponse 3868 If the method is called asynchronously, 3869 returns the request thread. 3870 """ 3871 kwargs['_return_http_data_only'] = True 3872 if kwargs.get('callback'): 3873 return self.get_completion_rate_for_template_owner_with_http_info(account_id, **kwargs) 3874 else: 3875 (data) = self.get_completion_rate_for_template_owner_with_http_info(account_id, **kwargs) 3876 return data 3877 3878 def get_completion_rate_for_template_owner_with_http_info(self, account_id, **kwargs): 3879 """ 3880 Gets completion rate for the user 3881 This method makes a synchronous HTTP request by default. To make an 3882 asynchronous HTTP request, please define a `callback` function 3883 to be invoked when receiving the response. 3884 >>> def callback_function(response): 3885 >>> pprint(response) 3886 >>> 3887 >>> thread = api.get_completion_rate_for_template_owner_with_http_info(account_id, callback=callback_function) 3888 3889 :param callback function: The callback function 3890 for asynchronous request. (optional) 3891 :param str account_id: The external account number (int) or account ID Guid. (required) 3892 :return: UserCompletionRateResponse 3893 If the method is called asynchronously, 3894 returns the request thread. 3895 """ 3896 3897 all_params = ['account_id'] 3898 all_params.append('callback') 3899 all_params.append('_return_http_data_only') 3900 all_params.append('_preload_content') 3901 all_params.append('_request_timeout') 3902 3903 params = locals() 3904 for key, val in iteritems(params['kwargs']): 3905 if key not in all_params: 3906 raise TypeError( 3907 "Got an unexpected keyword argument '%s'" 3908 " to method get_completion_rate_for_template_owner" % key 3909 ) 3910 params[key] = val 3911 del params['kwargs'] 3912 # verify the required parameter 'account_id' is set 3913 if ('account_id' not in params) or (params['account_id'] is None): 3914 raise ValueError("Missing the required parameter `account_id` when calling `get_completion_rate_for_template_owner`") 3915 3916 3917 collection_formats = {} 3918 3919 resource_path = '/v2.1/accounts/{accountId}/templates/insights/completionRate'.replace('{format}', 'json') 3920 path_params = {} 3921 if 'account_id' in params: 3922 path_params['accountId'] = params['account_id'] 3923 3924 query_params = {} 3925 3926 header_params = {} 3927 3928 form_params = [] 3929 local_var_files = {} 3930 3931 body_params = None 3932 # HTTP header `Accept` 3933 header_params['Accept'] = self.api_client.\ 3934 select_header_accept(['application/json']) 3935 3936 # Authentication setting 3937 auth_settings = [] 3938 3939 return self.api_client.call_api(resource_path, 'GET', 3940 path_params, 3941 query_params, 3942 header_params, 3943 body=body_params, 3944 post_params=form_params, 3945 files=local_var_files, 3946 response_type='UserCompletionRateResponse', 3947 auth_settings=auth_settings, 3948 callback=params.get('callback'), 3949 _return_http_data_only=params.get('_return_http_data_only'), 3950 _preload_content=params.get('_preload_content', True), 3951 _request_timeout=params.get('_request_timeout'), 3952 collection_formats=collection_formats) 3953 3954 def get_consumer_disclosure(self, account_id, lang_code, **kwargs): 3955 """ 3956 Gets the Electronic Record and Signature Disclosure. 3957 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. 3958 This method makes a synchronous HTTP request by default. To make an 3959 asynchronous HTTP request, please define a `callback` function 3960 to be invoked when receiving the response. 3961 >>> def callback_function(response): 3962 >>> pprint(response) 3963 >>> 3964 >>> thread = api.get_consumer_disclosure(account_id, lang_code, callback=callback_function) 3965 3966 :param callback function: The callback function 3967 for asynchronous request. (optional) 3968 :param str account_id: The external account number (int) or account ID Guid. (required) 3969 :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) 3970 :return: ConsumerDisclosure 3971 If the method is called asynchronously, 3972 returns the request thread. 3973 """ 3974 kwargs['_return_http_data_only'] = True 3975 if kwargs.get('callback'): 3976 return self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 3977 else: 3978 (data) = self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 3979 return data 3980 3981 def get_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs): 3982 """ 3983 Gets the Electronic Record and Signature Disclosure. 3984 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. 3985 This method makes a synchronous HTTP request by default. To make an 3986 asynchronous HTTP request, please define a `callback` function 3987 to be invoked when receiving the response. 3988 >>> def callback_function(response): 3989 >>> pprint(response) 3990 >>> 3991 >>> thread = api.get_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function) 3992 3993 :param callback function: The callback function 3994 for asynchronous request. (optional) 3995 :param str account_id: The external account number (int) or account ID Guid. (required) 3996 :param str 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) 3997 :return: ConsumerDisclosure 3998 If the method is called asynchronously, 3999 returns the request thread. 4000 """ 4001 4002 all_params = ['account_id', 'lang_code'] 4003 all_params.append('callback') 4004 all_params.append('_return_http_data_only') 4005 all_params.append('_preload_content') 4006 all_params.append('_request_timeout') 4007 4008 params = locals() 4009 for key, val in iteritems(params['kwargs']): 4010 if key not in all_params: 4011 raise TypeError( 4012 "Got an unexpected keyword argument '%s'" 4013 " to method get_consumer_disclosure" % key 4014 ) 4015 params[key] = val 4016 del params['kwargs'] 4017 # verify the required parameter 'account_id' is set 4018 if ('account_id' not in params) or (params['account_id'] is None): 4019 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure`") 4020 # verify the required parameter 'lang_code' is set 4021 if ('lang_code' not in params) or (params['lang_code'] is None): 4022 raise ValueError("Missing the required parameter `lang_code` when calling `get_consumer_disclosure`") 4023 4024 4025 collection_formats = {} 4026 4027 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 4028 path_params = {} 4029 if 'account_id' in params: 4030 path_params['accountId'] = params['account_id'] 4031 if 'lang_code' in params: 4032 path_params['langCode'] = params['lang_code'] 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='ConsumerDisclosure', 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_consumer_disclosure_default(self, account_id, **kwargs): 4065 """ 4066 Gets the Electronic Record and Signature Disclosure for the account. 4067 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. 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_consumer_disclosure_default(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 :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. 4080 :return: ConsumerDisclosure 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_consumer_disclosure_default_with_http_info(account_id, **kwargs) 4087 else: 4088 (data) = self.get_consumer_disclosure_default_with_http_info(account_id, **kwargs) 4089 return data 4090 4091 def get_consumer_disclosure_default_with_http_info(self, account_id, **kwargs): 4092 """ 4093 Gets the Electronic Record and Signature Disclosure for the account. 4094 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. 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_consumer_disclosure_default_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 :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. 4107 :return: ConsumerDisclosure 4108 If the method is called asynchronously, 4109 returns the request thread. 4110 """ 4111 4112 all_params = ['account_id', 'lang_code'] 4113 all_params.append('callback') 4114 all_params.append('_return_http_data_only') 4115 all_params.append('_preload_content') 4116 all_params.append('_request_timeout') 4117 4118 params = locals() 4119 for key, val in iteritems(params['kwargs']): 4120 if key not in all_params: 4121 raise TypeError( 4122 "Got an unexpected keyword argument '%s'" 4123 " to method get_consumer_disclosure_default" % key 4124 ) 4125 params[key] = val 4126 del params['kwargs'] 4127 # verify the required parameter 'account_id' is set 4128 if ('account_id' not in params) or (params['account_id'] is None): 4129 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure_default`") 4130 4131 4132 collection_formats = {} 4133 4134 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure'.replace('{format}', 'json') 4135 path_params = {} 4136 if 'account_id' in params: 4137 path_params['accountId'] = params['account_id'] 4138 4139 query_params = {} 4140 if 'lang_code' in params: 4141 query_params['langCode'] = params['lang_code'] 4142 4143 header_params = {} 4144 4145 form_params = [] 4146 local_var_files = {} 4147 4148 body_params = None 4149 # HTTP header `Accept` 4150 header_params['Accept'] = self.api_client.\ 4151 select_header_accept(['application/json']) 4152 4153 # Authentication setting 4154 auth_settings = [] 4155 4156 return self.api_client.call_api(resource_path, 'GET', 4157 path_params, 4158 query_params, 4159 header_params, 4160 body=body_params, 4161 post_params=form_params, 4162 files=local_var_files, 4163 response_type='ConsumerDisclosure', 4164 auth_settings=auth_settings, 4165 callback=params.get('callback'), 4166 _return_http_data_only=params.get('_return_http_data_only'), 4167 _preload_content=params.get('_preload_content', True), 4168 _request_timeout=params.get('_request_timeout'), 4169 collection_formats=collection_formats) 4170 4171 def get_e_note_configuration(self, account_id, **kwargs): 4172 """ 4173 Returns the configuration information for the eNote eOriginal integration. 4174 4175 This method makes a synchronous HTTP request by default. To make an 4176 asynchronous HTTP request, please define a `callback` function 4177 to be invoked when receiving the response. 4178 >>> def callback_function(response): 4179 >>> pprint(response) 4180 >>> 4181 >>> thread = api.get_e_note_configuration(account_id, callback=callback_function) 4182 4183 :param callback function: The callback function 4184 for asynchronous request. (optional) 4185 :param str account_id: The external account number (int) or account ID Guid. (required) 4186 :return: ENoteConfiguration 4187 If the method is called asynchronously, 4188 returns the request thread. 4189 """ 4190 kwargs['_return_http_data_only'] = True 4191 if kwargs.get('callback'): 4192 return self.get_e_note_configuration_with_http_info(account_id, **kwargs) 4193 else: 4194 (data) = self.get_e_note_configuration_with_http_info(account_id, **kwargs) 4195 return data 4196 4197 def get_e_note_configuration_with_http_info(self, account_id, **kwargs): 4198 """ 4199 Returns the configuration information for the eNote eOriginal integration. 4200 4201 This method makes a synchronous HTTP request by default. To make an 4202 asynchronous HTTP request, please define a `callback` function 4203 to be invoked when receiving the response. 4204 >>> def callback_function(response): 4205 >>> pprint(response) 4206 >>> 4207 >>> thread = api.get_e_note_configuration_with_http_info(account_id, callback=callback_function) 4208 4209 :param callback function: The callback function 4210 for asynchronous request. (optional) 4211 :param str account_id: The external account number (int) or account ID Guid. (required) 4212 :return: ENoteConfiguration 4213 If the method is called asynchronously, 4214 returns the request thread. 4215 """ 4216 4217 all_params = ['account_id'] 4218 all_params.append('callback') 4219 all_params.append('_return_http_data_only') 4220 all_params.append('_preload_content') 4221 all_params.append('_request_timeout') 4222 4223 params = locals() 4224 for key, val in iteritems(params['kwargs']): 4225 if key not in all_params: 4226 raise TypeError( 4227 "Got an unexpected keyword argument '%s'" 4228 " to method get_e_note_configuration" % key 4229 ) 4230 params[key] = val 4231 del params['kwargs'] 4232 # verify the required parameter 'account_id' is set 4233 if ('account_id' not in params) or (params['account_id'] is None): 4234 raise ValueError("Missing the required parameter `account_id` when calling `get_e_note_configuration`") 4235 4236 4237 collection_formats = {} 4238 4239 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 4240 path_params = {} 4241 if 'account_id' in params: 4242 path_params['accountId'] = params['account_id'] 4243 4244 query_params = {} 4245 4246 header_params = {} 4247 4248 form_params = [] 4249 local_var_files = {} 4250 4251 body_params = None 4252 # HTTP header `Accept` 4253 header_params['Accept'] = self.api_client.\ 4254 select_header_accept(['application/json']) 4255 4256 # Authentication setting 4257 auth_settings = [] 4258 4259 return self.api_client.call_api(resource_path, 'GET', 4260 path_params, 4261 query_params, 4262 header_params, 4263 body=body_params, 4264 post_params=form_params, 4265 files=local_var_files, 4266 response_type='ENoteConfiguration', 4267 auth_settings=auth_settings, 4268 callback=params.get('callback'), 4269 _return_http_data_only=params.get('_return_http_data_only'), 4270 _preload_content=params.get('_preload_content', True), 4271 _request_timeout=params.get('_request_timeout'), 4272 collection_formats=collection_formats) 4273 4274 def get_envelope_purge_configuration(self, account_id, **kwargs): 4275 """ 4276 Select envelope purge configuration. 4277 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. 4278 This method makes a synchronous HTTP request by default. To make an 4279 asynchronous HTTP request, please define a `callback` function 4280 to be invoked when receiving the response. 4281 >>> def callback_function(response): 4282 >>> pprint(response) 4283 >>> 4284 >>> thread = api.get_envelope_purge_configuration(account_id, callback=callback_function) 4285 4286 :param callback function: The callback function 4287 for asynchronous request. (optional) 4288 :param str account_id: The external account number (int) or account ID Guid. (required) 4289 :return: EnvelopePurgeConfiguration 4290 If the method is called asynchronously, 4291 returns the request thread. 4292 """ 4293 kwargs['_return_http_data_only'] = True 4294 if kwargs.get('callback'): 4295 return self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs) 4296 else: 4297 (data) = self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs) 4298 return data 4299 4300 def get_envelope_purge_configuration_with_http_info(self, account_id, **kwargs): 4301 """ 4302 Select envelope purge configuration. 4303 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. 4304 This method makes a synchronous HTTP request by default. To make an 4305 asynchronous HTTP request, please define a `callback` function 4306 to be invoked when receiving the response. 4307 >>> def callback_function(response): 4308 >>> pprint(response) 4309 >>> 4310 >>> thread = api.get_envelope_purge_configuration_with_http_info(account_id, callback=callback_function) 4311 4312 :param callback function: The callback function 4313 for asynchronous request. (optional) 4314 :param str account_id: The external account number (int) or account ID Guid. (required) 4315 :return: EnvelopePurgeConfiguration 4316 If the method is called asynchronously, 4317 returns the request thread. 4318 """ 4319 4320 all_params = ['account_id'] 4321 all_params.append('callback') 4322 all_params.append('_return_http_data_only') 4323 all_params.append('_preload_content') 4324 all_params.append('_request_timeout') 4325 4326 params = locals() 4327 for key, val in iteritems(params['kwargs']): 4328 if key not in all_params: 4329 raise TypeError( 4330 "Got an unexpected keyword argument '%s'" 4331 " to method get_envelope_purge_configuration" % key 4332 ) 4333 params[key] = val 4334 del params['kwargs'] 4335 # verify the required parameter 'account_id' is set 4336 if ('account_id' not in params) or (params['account_id'] is None): 4337 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_purge_configuration`") 4338 4339 4340 collection_formats = {} 4341 4342 resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json') 4343 path_params = {} 4344 if 'account_id' in params: 4345 path_params['accountId'] = params['account_id'] 4346 4347 query_params = {} 4348 4349 header_params = {} 4350 4351 form_params = [] 4352 local_var_files = {} 4353 4354 body_params = None 4355 # HTTP header `Accept` 4356 header_params['Accept'] = self.api_client.\ 4357 select_header_accept(['application/json']) 4358 4359 # Authentication setting 4360 auth_settings = [] 4361 4362 return self.api_client.call_api(resource_path, 'GET', 4363 path_params, 4364 query_params, 4365 header_params, 4366 body=body_params, 4367 post_params=form_params, 4368 files=local_var_files, 4369 response_type='EnvelopePurgeConfiguration', 4370 auth_settings=auth_settings, 4371 callback=params.get('callback'), 4372 _return_http_data_only=params.get('_return_http_data_only'), 4373 _preload_content=params.get('_preload_content', True), 4374 _request_timeout=params.get('_request_timeout'), 4375 collection_formats=collection_formats) 4376 4377 def get_favorite_templates(self, account_id, **kwargs): 4378 """ 4379 Retrieves the list of favorited templates for this caller 4380 4381 This method makes a synchronous HTTP request by default. To make an 4382 asynchronous HTTP request, please define a `callback` function 4383 to be invoked when receiving the response. 4384 >>> def callback_function(response): 4385 >>> pprint(response) 4386 >>> 4387 >>> thread = api.get_favorite_templates(account_id, callback=callback_function) 4388 4389 :param callback function: The callback function 4390 for asynchronous request. (optional) 4391 :param str account_id: The external account number (int) or account ID Guid. (required) 4392 :return: FavoriteTemplatesInfo 4393 If the method is called asynchronously, 4394 returns the request thread. 4395 """ 4396 kwargs['_return_http_data_only'] = True 4397 if kwargs.get('callback'): 4398 return self.get_favorite_templates_with_http_info(account_id, **kwargs) 4399 else: 4400 (data) = self.get_favorite_templates_with_http_info(account_id, **kwargs) 4401 return data 4402 4403 def get_favorite_templates_with_http_info(self, account_id, **kwargs): 4404 """ 4405 Retrieves the list of favorited templates for this caller 4406 4407 This method makes a synchronous HTTP request by default. To make an 4408 asynchronous HTTP request, please define a `callback` function 4409 to be invoked when receiving the response. 4410 >>> def callback_function(response): 4411 >>> pprint(response) 4412 >>> 4413 >>> thread = api.get_favorite_templates_with_http_info(account_id, callback=callback_function) 4414 4415 :param callback function: The callback function 4416 for asynchronous request. (optional) 4417 :param str account_id: The external account number (int) or account ID Guid. (required) 4418 :return: FavoriteTemplatesInfo 4419 If the method is called asynchronously, 4420 returns the request thread. 4421 """ 4422 4423 all_params = ['account_id'] 4424 all_params.append('callback') 4425 all_params.append('_return_http_data_only') 4426 all_params.append('_preload_content') 4427 all_params.append('_request_timeout') 4428 4429 params = locals() 4430 for key, val in iteritems(params['kwargs']): 4431 if key not in all_params: 4432 raise TypeError( 4433 "Got an unexpected keyword argument '%s'" 4434 " to method get_favorite_templates" % key 4435 ) 4436 params[key] = val 4437 del params['kwargs'] 4438 # verify the required parameter 'account_id' is set 4439 if ('account_id' not in params) or (params['account_id'] is None): 4440 raise ValueError("Missing the required parameter `account_id` when calling `get_favorite_templates`") 4441 4442 4443 collection_formats = {} 4444 4445 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 4446 path_params = {} 4447 if 'account_id' in params: 4448 path_params['accountId'] = params['account_id'] 4449 4450 query_params = {} 4451 4452 header_params = {} 4453 4454 form_params = [] 4455 local_var_files = {} 4456 4457 body_params = None 4458 # HTTP header `Accept` 4459 header_params['Accept'] = self.api_client.\ 4460 select_header_accept(['application/json']) 4461 4462 # Authentication setting 4463 auth_settings = [] 4464 4465 return self.api_client.call_api(resource_path, 'GET', 4466 path_params, 4467 query_params, 4468 header_params, 4469 body=body_params, 4470 post_params=form_params, 4471 files=local_var_files, 4472 response_type='FavoriteTemplatesInfo', 4473 auth_settings=auth_settings, 4474 callback=params.get('callback'), 4475 _return_http_data_only=params.get('_return_http_data_only'), 4476 _preload_content=params.get('_preload_content', True), 4477 _request_timeout=params.get('_request_timeout'), 4478 collection_formats=collection_formats) 4479 4480 def get_notification_defaults(self, account_id, **kwargs): 4481 """ 4482 Returns default user level settings for a specified account 4483 This method returns the default settings for the email notifications that signers and senders receive about envelopes. 4484 This method makes a synchronous HTTP request by default. To make an 4485 asynchronous HTTP request, please define a `callback` function 4486 to be invoked when receiving the response. 4487 >>> def callback_function(response): 4488 >>> pprint(response) 4489 >>> 4490 >>> thread = api.get_notification_defaults(account_id, callback=callback_function) 4491 4492 :param callback function: The callback function 4493 for asynchronous request. (optional) 4494 :param str account_id: The external account number (int) or account ID Guid. (required) 4495 :return: NotificationDefaults 4496 If the method is called asynchronously, 4497 returns the request thread. 4498 """ 4499 kwargs['_return_http_data_only'] = True 4500 if kwargs.get('callback'): 4501 return self.get_notification_defaults_with_http_info(account_id, **kwargs) 4502 else: 4503 (data) = self.get_notification_defaults_with_http_info(account_id, **kwargs) 4504 return data 4505 4506 def get_notification_defaults_with_http_info(self, account_id, **kwargs): 4507 """ 4508 Returns default user level settings for a specified account 4509 This method returns the default settings for the email notifications that signers and senders receive about envelopes. 4510 This method makes a synchronous HTTP request by default. To make an 4511 asynchronous HTTP request, please define a `callback` function 4512 to be invoked when receiving the response. 4513 >>> def callback_function(response): 4514 >>> pprint(response) 4515 >>> 4516 >>> thread = api.get_notification_defaults_with_http_info(account_id, callback=callback_function) 4517 4518 :param callback function: The callback function 4519 for asynchronous request. (optional) 4520 :param str account_id: The external account number (int) or account ID Guid. (required) 4521 :return: NotificationDefaults 4522 If the method is called asynchronously, 4523 returns the request thread. 4524 """ 4525 4526 all_params = ['account_id'] 4527 all_params.append('callback') 4528 all_params.append('_return_http_data_only') 4529 all_params.append('_preload_content') 4530 all_params.append('_request_timeout') 4531 4532 params = locals() 4533 for key, val in iteritems(params['kwargs']): 4534 if key not in all_params: 4535 raise TypeError( 4536 "Got an unexpected keyword argument '%s'" 4537 " to method get_notification_defaults" % key 4538 ) 4539 params[key] = val 4540 del params['kwargs'] 4541 # verify the required parameter 'account_id' is set 4542 if ('account_id' not in params) or (params['account_id'] is None): 4543 raise ValueError("Missing the required parameter `account_id` when calling `get_notification_defaults`") 4544 4545 4546 collection_formats = {} 4547 4548 resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json') 4549 path_params = {} 4550 if 'account_id' in params: 4551 path_params['accountId'] = params['account_id'] 4552 4553 query_params = {} 4554 4555 header_params = {} 4556 4557 form_params = [] 4558 local_var_files = {} 4559 4560 body_params = None 4561 # HTTP header `Accept` 4562 header_params['Accept'] = self.api_client.\ 4563 select_header_accept(['application/json']) 4564 4565 # Authentication setting 4566 auth_settings = [] 4567 4568 return self.api_client.call_api(resource_path, 'GET', 4569 path_params, 4570 query_params, 4571 header_params, 4572 body=body_params, 4573 post_params=form_params, 4574 files=local_var_files, 4575 response_type='NotificationDefaults', 4576 auth_settings=auth_settings, 4577 callback=params.get('callback'), 4578 _return_http_data_only=params.get('_return_http_data_only'), 4579 _preload_content=params.get('_preload_content', True), 4580 _request_timeout=params.get('_request_timeout'), 4581 collection_formats=collection_formats) 4582 4583 def get_password_rules(self, account_id, **kwargs): 4584 """ 4585 Get the password rules 4586 This method retrieves the password rules for an account. 4587 This method makes a synchronous HTTP request by default. To make an 4588 asynchronous HTTP request, please define a `callback` function 4589 to be invoked when receiving the response. 4590 >>> def callback_function(response): 4591 >>> pprint(response) 4592 >>> 4593 >>> thread = api.get_password_rules(account_id, callback=callback_function) 4594 4595 :param callback function: The callback function 4596 for asynchronous request. (optional) 4597 :param str account_id: The external account number (int) or account ID Guid. (required) 4598 :return: AccountPasswordRules 4599 If the method is called asynchronously, 4600 returns the request thread. 4601 """ 4602 kwargs['_return_http_data_only'] = True 4603 if kwargs.get('callback'): 4604 return self.get_password_rules_with_http_info(account_id, **kwargs) 4605 else: 4606 (data) = self.get_password_rules_with_http_info(account_id, **kwargs) 4607 return data 4608 4609 def get_password_rules_with_http_info(self, account_id, **kwargs): 4610 """ 4611 Get the password rules 4612 This method retrieves the password rules for an account. 4613 This method makes a synchronous HTTP request by default. To make an 4614 asynchronous HTTP request, please define a `callback` function 4615 to be invoked when receiving the response. 4616 >>> def callback_function(response): 4617 >>> pprint(response) 4618 >>> 4619 >>> thread = api.get_password_rules_with_http_info(account_id, callback=callback_function) 4620 4621 :param callback function: The callback function 4622 for asynchronous request. (optional) 4623 :param str account_id: The external account number (int) or account ID Guid. (required) 4624 :return: AccountPasswordRules 4625 If the method is called asynchronously, 4626 returns the request thread. 4627 """ 4628 4629 all_params = ['account_id'] 4630 all_params.append('callback') 4631 all_params.append('_return_http_data_only') 4632 all_params.append('_preload_content') 4633 all_params.append('_request_timeout') 4634 4635 params = locals() 4636 for key, val in iteritems(params['kwargs']): 4637 if key not in all_params: 4638 raise TypeError( 4639 "Got an unexpected keyword argument '%s'" 4640 " to method get_password_rules" % key 4641 ) 4642 params[key] = val 4643 del params['kwargs'] 4644 # verify the required parameter 'account_id' is set 4645 if ('account_id' not in params) or (params['account_id'] is None): 4646 raise ValueError("Missing the required parameter `account_id` when calling `get_password_rules`") 4647 4648 4649 collection_formats = {} 4650 4651 resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json') 4652 path_params = {} 4653 if 'account_id' in params: 4654 path_params['accountId'] = params['account_id'] 4655 4656 query_params = {} 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='AccountPasswordRules', 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_password_rules_0(self, **kwargs): 4687 """ 4688 Get membership account password rules 4689 4690 This method makes a synchronous HTTP request by default. To make an 4691 asynchronous HTTP request, please define a `callback` function 4692 to be invoked when receiving the response. 4693 >>> def callback_function(response): 4694 >>> pprint(response) 4695 >>> 4696 >>> thread = api.get_password_rules_0(callback=callback_function) 4697 4698 :param callback function: The callback function 4699 for asynchronous request. (optional) 4700 :return: UserPasswordRules 4701 If the method is called asynchronously, 4702 returns the request thread. 4703 """ 4704 kwargs['_return_http_data_only'] = True 4705 if kwargs.get('callback'): 4706 return self.get_password_rules_0_with_http_info(**kwargs) 4707 else: 4708 (data) = self.get_password_rules_0_with_http_info(**kwargs) 4709 return data 4710 4711 def get_password_rules_0_with_http_info(self, **kwargs): 4712 """ 4713 Get membership account password rules 4714 4715 This method makes a synchronous HTTP request by default. To make an 4716 asynchronous HTTP request, please define a `callback` function 4717 to be invoked when receiving the response. 4718 >>> def callback_function(response): 4719 >>> pprint(response) 4720 >>> 4721 >>> thread = api.get_password_rules_0_with_http_info(callback=callback_function) 4722 4723 :param callback function: The callback function 4724 for asynchronous request. (optional) 4725 :return: UserPasswordRules 4726 If the method is called asynchronously, 4727 returns the request thread. 4728 """ 4729 4730 all_params = [] 4731 all_params.append('callback') 4732 all_params.append('_return_http_data_only') 4733 all_params.append('_preload_content') 4734 all_params.append('_request_timeout') 4735 4736 params = locals() 4737 for key, val in iteritems(params['kwargs']): 4738 if key not in all_params: 4739 raise TypeError( 4740 "Got an unexpected keyword argument '%s'" 4741 " to method get_password_rules_0" % key 4742 ) 4743 params[key] = val 4744 del params['kwargs'] 4745 4746 collection_formats = {} 4747 4748 resource_path = '/v2.1/current_user/password_rules'.replace('{format}', 'json') 4749 path_params = {} 4750 4751 query_params = {} 4752 4753 header_params = {} 4754 4755 form_params = [] 4756 local_var_files = {} 4757 4758 body_params = None 4759 # HTTP header `Accept` 4760 header_params['Accept'] = self.api_client.\ 4761 select_header_accept(['application/json']) 4762 4763 # Authentication setting 4764 auth_settings = [] 4765 4766 return self.api_client.call_api(resource_path, 'GET', 4767 path_params, 4768 query_params, 4769 header_params, 4770 body=body_params, 4771 post_params=form_params, 4772 files=local_var_files, 4773 response_type='UserPasswordRules', 4774 auth_settings=auth_settings, 4775 callback=params.get('callback'), 4776 _return_http_data_only=params.get('_return_http_data_only'), 4777 _preload_content=params.get('_preload_content', True), 4778 _request_timeout=params.get('_request_timeout'), 4779 collection_formats=collection_formats) 4780 4781 def get_permission_profile(self, account_id, permission_profile_id, **kwargs): 4782 """ 4783 Returns a permissions profile in the specified account. 4784 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/) 4785 This method makes a synchronous HTTP request by default. To make an 4786 asynchronous HTTP request, please define a `callback` function 4787 to be invoked when receiving the response. 4788 >>> def callback_function(response): 4789 >>> pprint(response) 4790 >>> 4791 >>> thread = api.get_permission_profile(account_id, permission_profile_id, callback=callback_function) 4792 4793 :param callback function: The callback function 4794 for asynchronous request. (optional) 4795 :param str account_id: The external account number (int) or account ID Guid. (required) 4796 :param str permission_profile_id: (required) 4797 :param str include: 4798 :return: PermissionProfile 4799 If the method is called asynchronously, 4800 returns the request thread. 4801 """ 4802 kwargs['_return_http_data_only'] = True 4803 if kwargs.get('callback'): 4804 return self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 4805 else: 4806 (data) = self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 4807 return data 4808 4809 def get_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 4810 """ 4811 Returns a permissions profile in the specified account. 4812 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/) 4813 This method makes a synchronous HTTP request by default. To make an 4814 asynchronous HTTP request, please define a `callback` function 4815 to be invoked when receiving the response. 4816 >>> def callback_function(response): 4817 >>> pprint(response) 4818 >>> 4819 >>> thread = api.get_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 4820 4821 :param callback function: The callback function 4822 for asynchronous request. (optional) 4823 :param str account_id: The external account number (int) or account ID Guid. (required) 4824 :param str permission_profile_id: (required) 4825 :param str include: 4826 :return: PermissionProfile 4827 If the method is called asynchronously, 4828 returns the request thread. 4829 """ 4830 4831 all_params = ['account_id', 'permission_profile_id', 'include'] 4832 all_params.append('callback') 4833 all_params.append('_return_http_data_only') 4834 all_params.append('_preload_content') 4835 all_params.append('_request_timeout') 4836 4837 params = locals() 4838 for key, val in iteritems(params['kwargs']): 4839 if key not in all_params: 4840 raise TypeError( 4841 "Got an unexpected keyword argument '%s'" 4842 " to method get_permission_profile" % key 4843 ) 4844 params[key] = val 4845 del params['kwargs'] 4846 # verify the required parameter 'account_id' is set 4847 if ('account_id' not in params) or (params['account_id'] is None): 4848 raise ValueError("Missing the required parameter `account_id` when calling `get_permission_profile`") 4849 # verify the required parameter 'permission_profile_id' is set 4850 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 4851 raise ValueError("Missing the required parameter `permission_profile_id` when calling `get_permission_profile`") 4852 4853 4854 collection_formats = {} 4855 4856 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 4857 path_params = {} 4858 if 'account_id' in params: 4859 path_params['accountId'] = params['account_id'] 4860 if 'permission_profile_id' in params: 4861 path_params['permissionProfileId'] = params['permission_profile_id'] 4862 4863 query_params = {} 4864 if 'include' in params: 4865 query_params['include'] = params['include'] 4866 4867 header_params = {} 4868 4869 form_params = [] 4870 local_var_files = {} 4871 4872 body_params = None 4873 # HTTP header `Accept` 4874 header_params['Accept'] = self.api_client.\ 4875 select_header_accept(['application/json']) 4876 4877 # Authentication setting 4878 auth_settings = [] 4879 4880 return self.api_client.call_api(resource_path, 'GET', 4881 path_params, 4882 query_params, 4883 header_params, 4884 body=body_params, 4885 post_params=form_params, 4886 files=local_var_files, 4887 response_type='PermissionProfile', 4888 auth_settings=auth_settings, 4889 callback=params.get('callback'), 4890 _return_http_data_only=params.get('_return_http_data_only'), 4891 _preload_content=params.get('_preload_content', True), 4892 _request_timeout=params.get('_request_timeout'), 4893 collection_formats=collection_formats) 4894 4895 def get_principal_user_authorizations(self, account_id, user_id, **kwargs): 4896 """ 4897 Returns the principal user authorizations 4898 This method makes a synchronous HTTP request by default. To make an 4899 asynchronous HTTP request, please define a `callback` function 4900 to be invoked when receiving the response. 4901 >>> def callback_function(response): 4902 >>> pprint(response) 4903 >>> 4904 >>> thread = api.get_principal_user_authorizations(account_id, user_id, callback=callback_function) 4905 4906 :param callback function: The callback function 4907 for asynchronous request. (optional) 4908 :param str account_id: The external account number (int) or account ID Guid. (required) 4909 :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) 4910 :param str active_only: 4911 :param str count: 4912 :param str email_substring: Part (substring) of email we are searching for. 4913 :param str include_closed_users: 4914 :param str permissions: 4915 :param str start_position: 4916 :param str user_name_substring: 4917 :return: UserAuthorizations 4918 If the method is called asynchronously, 4919 returns the request thread. 4920 """ 4921 kwargs['_return_http_data_only'] = True 4922 if kwargs.get('callback'): 4923 return self.get_principal_user_authorizations_with_http_info(account_id, user_id, **kwargs) 4924 else: 4925 (data) = self.get_principal_user_authorizations_with_http_info(account_id, user_id, **kwargs) 4926 return data 4927 4928 def get_principal_user_authorizations_with_http_info(self, account_id, user_id, **kwargs): 4929 """ 4930 Returns the principal user authorizations 4931 This method makes a synchronous HTTP request by default. To make an 4932 asynchronous HTTP request, please define a `callback` function 4933 to be invoked when receiving the response. 4934 >>> def callback_function(response): 4935 >>> pprint(response) 4936 >>> 4937 >>> thread = api.get_principal_user_authorizations_with_http_info(account_id, user_id, callback=callback_function) 4938 4939 :param callback function: The callback function 4940 for asynchronous request. (optional) 4941 :param str account_id: The external account number (int) or account ID Guid. (required) 4942 :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) 4943 :param str active_only: 4944 :param str count: 4945 :param str email_substring: Part (substring) of email we are searching for. 4946 :param str include_closed_users: 4947 :param str permissions: 4948 :param str start_position: 4949 :param str user_name_substring: 4950 :return: UserAuthorizations 4951 If the method is called asynchronously, 4952 returns the request thread. 4953 """ 4954 4955 all_params = ['account_id', 'user_id', 'active_only', 'count', 'email_substring', 'include_closed_users', 'permissions', 'start_position', 'user_name_substring'] 4956 all_params.append('callback') 4957 all_params.append('_return_http_data_only') 4958 all_params.append('_preload_content') 4959 all_params.append('_request_timeout') 4960 4961 params = locals() 4962 for key, val in iteritems(params['kwargs']): 4963 if key not in all_params: 4964 raise TypeError( 4965 "Got an unexpected keyword argument '%s'" 4966 " to method get_principal_user_authorizations" % key 4967 ) 4968 params[key] = val 4969 del params['kwargs'] 4970 # verify the required parameter 'account_id' is set 4971 if ('account_id' not in params) or (params['account_id'] is None): 4972 raise ValueError("Missing the required parameter `account_id` when calling `get_principal_user_authorizations`") 4973 # verify the required parameter 'user_id' is set 4974 if ('user_id' not in params) or (params['user_id'] is None): 4975 raise ValueError("Missing the required parameter `user_id` when calling `get_principal_user_authorizations`") 4976 4977 4978 collection_formats = {} 4979 4980 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorizations'.replace('{format}', 'json') 4981 path_params = {} 4982 if 'account_id' in params: 4983 path_params['accountId'] = params['account_id'] 4984 if 'user_id' in params: 4985 path_params['userId'] = params['user_id'] 4986 4987 query_params = {} 4988 if 'active_only' in params: 4989 query_params['active_only'] = params['active_only'] 4990 if 'count' in params: 4991 query_params['count'] = params['count'] 4992 if 'email_substring' in params: 4993 query_params['email_substring'] = params['email_substring'] 4994 if 'include_closed_users' in params: 4995 query_params['include_closed_users'] = params['include_closed_users'] 4996 if 'permissions' in params: 4997 query_params['permissions'] = params['permissions'] 4998 if 'start_position' in params: 4999 query_params['start_position'] = params['start_position'] 5000 if 'user_name_substring' in params: 5001 query_params['user_name_substring'] = params['user_name_substring'] 5002 5003 header_params = {} 5004 5005 form_params = [] 5006 local_var_files = {} 5007 5008 body_params = None 5009 # HTTP header `Accept` 5010 header_params['Accept'] = self.api_client.\ 5011 select_header_accept(['application/json']) 5012 5013 # Authentication setting 5014 auth_settings = [] 5015 5016 return self.api_client.call_api(resource_path, 'GET', 5017 path_params, 5018 query_params, 5019 header_params, 5020 body=body_params, 5021 post_params=form_params, 5022 files=local_var_files, 5023 response_type='UserAuthorizations', 5024 auth_settings=auth_settings, 5025 callback=params.get('callback'), 5026 _return_http_data_only=params.get('_return_http_data_only'), 5027 _preload_content=params.get('_preload_content', True), 5028 _request_timeout=params.get('_request_timeout'), 5029 collection_formats=collection_formats) 5030 5031 def get_provisioning(self, **kwargs): 5032 """ 5033 Retrieves the account provisioning information for the account. 5034 Retrieves the account provisioning information for the account. 5035 This method makes a synchronous HTTP request by default. To make an 5036 asynchronous HTTP request, please define a `callback` function 5037 to be invoked when receiving the response. 5038 >>> def callback_function(response): 5039 >>> pprint(response) 5040 >>> 5041 >>> thread = api.get_provisioning(callback=callback_function) 5042 5043 :param callback function: The callback function 5044 for asynchronous request. (optional) 5045 :return: ProvisioningInformation 5046 If the method is called asynchronously, 5047 returns the request thread. 5048 """ 5049 kwargs['_return_http_data_only'] = True 5050 if kwargs.get('callback'): 5051 return self.get_provisioning_with_http_info(**kwargs) 5052 else: 5053 (data) = self.get_provisioning_with_http_info(**kwargs) 5054 return data 5055 5056 def get_provisioning_with_http_info(self, **kwargs): 5057 """ 5058 Retrieves the account provisioning information for the account. 5059 Retrieves the account provisioning information for the account. 5060 This method makes a synchronous HTTP request by default. To make an 5061 asynchronous HTTP request, please define a `callback` function 5062 to be invoked when receiving the response. 5063 >>> def callback_function(response): 5064 >>> pprint(response) 5065 >>> 5066 >>> thread = api.get_provisioning_with_http_info(callback=callback_function) 5067 5068 :param callback function: The callback function 5069 for asynchronous request. (optional) 5070 :return: ProvisioningInformation 5071 If the method is called asynchronously, 5072 returns the request thread. 5073 """ 5074 5075 all_params = [] 5076 all_params.append('callback') 5077 all_params.append('_return_http_data_only') 5078 all_params.append('_preload_content') 5079 all_params.append('_request_timeout') 5080 5081 params = locals() 5082 for key, val in iteritems(params['kwargs']): 5083 if key not in all_params: 5084 raise TypeError( 5085 "Got an unexpected keyword argument '%s'" 5086 " to method get_provisioning" % key 5087 ) 5088 params[key] = val 5089 del params['kwargs'] 5090 5091 collection_formats = {} 5092 5093 resource_path = '/v2.1/accounts/provisioning'.replace('{format}', 'json') 5094 path_params = {} 5095 5096 query_params = {} 5097 5098 header_params = {} 5099 5100 form_params = [] 5101 local_var_files = {} 5102 5103 body_params = None 5104 # HTTP header `Accept` 5105 header_params['Accept'] = self.api_client.\ 5106 select_header_accept(['application/json']) 5107 5108 # Authentication setting 5109 auth_settings = [] 5110 5111 return self.api_client.call_api(resource_path, 'GET', 5112 path_params, 5113 query_params, 5114 header_params, 5115 body=body_params, 5116 post_params=form_params, 5117 files=local_var_files, 5118 response_type='ProvisioningInformation', 5119 auth_settings=auth_settings, 5120 callback=params.get('callback'), 5121 _return_http_data_only=params.get('_return_http_data_only'), 5122 _preload_content=params.get('_preload_content', True), 5123 _request_timeout=params.get('_request_timeout'), 5124 collection_formats=collection_formats) 5125 5126 def get_supported_languages(self, account_id, **kwargs): 5127 """ 5128 Gets list of supported languages for recipient language setting. 5129 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). 5130 This method makes a synchronous HTTP request by default. To make an 5131 asynchronous HTTP request, please define a `callback` function 5132 to be invoked when receiving the response. 5133 >>> def callback_function(response): 5134 >>> pprint(response) 5135 >>> 5136 >>> thread = api.get_supported_languages(account_id, callback=callback_function) 5137 5138 :param callback function: The callback function 5139 for asynchronous request. (optional) 5140 :param str account_id: The external account number (int) or account ID Guid. (required) 5141 :return: SupportedLanguages 5142 If the method is called asynchronously, 5143 returns the request thread. 5144 """ 5145 kwargs['_return_http_data_only'] = True 5146 if kwargs.get('callback'): 5147 return self.get_supported_languages_with_http_info(account_id, **kwargs) 5148 else: 5149 (data) = self.get_supported_languages_with_http_info(account_id, **kwargs) 5150 return data 5151 5152 def get_supported_languages_with_http_info(self, account_id, **kwargs): 5153 """ 5154 Gets list of supported languages for recipient language setting. 5155 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). 5156 This method makes a synchronous HTTP request by default. To make an 5157 asynchronous HTTP request, please define a `callback` function 5158 to be invoked when receiving the response. 5159 >>> def callback_function(response): 5160 >>> pprint(response) 5161 >>> 5162 >>> thread = api.get_supported_languages_with_http_info(account_id, callback=callback_function) 5163 5164 :param callback function: The callback function 5165 for asynchronous request. (optional) 5166 :param str account_id: The external account number (int) or account ID Guid. (required) 5167 :return: SupportedLanguages 5168 If the method is called asynchronously, 5169 returns the request thread. 5170 """ 5171 5172 all_params = ['account_id'] 5173 all_params.append('callback') 5174 all_params.append('_return_http_data_only') 5175 all_params.append('_preload_content') 5176 all_params.append('_request_timeout') 5177 5178 params = locals() 5179 for key, val in iteritems(params['kwargs']): 5180 if key not in all_params: 5181 raise TypeError( 5182 "Got an unexpected keyword argument '%s'" 5183 " to method get_supported_languages" % key 5184 ) 5185 params[key] = val 5186 del params['kwargs'] 5187 # verify the required parameter 'account_id' is set 5188 if ('account_id' not in params) or (params['account_id'] is None): 5189 raise ValueError("Missing the required parameter `account_id` when calling `get_supported_languages`") 5190 5191 5192 collection_formats = {} 5193 5194 resource_path = '/v2.1/accounts/{accountId}/supported_languages'.replace('{format}', 'json') 5195 path_params = {} 5196 if 'account_id' in params: 5197 path_params['accountId'] = params['account_id'] 5198 5199 query_params = {} 5200 5201 header_params = {} 5202 5203 form_params = [] 5204 local_var_files = {} 5205 5206 body_params = None 5207 # HTTP header `Accept` 5208 header_params['Accept'] = self.api_client.\ 5209 select_header_accept(['application/json']) 5210 5211 # Authentication setting 5212 auth_settings = [] 5213 5214 return self.api_client.call_api(resource_path, 'GET', 5215 path_params, 5216 query_params, 5217 header_params, 5218 body=body_params, 5219 post_params=form_params, 5220 files=local_var_files, 5221 response_type='SupportedLanguages', 5222 auth_settings=auth_settings, 5223 callback=params.get('callback'), 5224 _return_http_data_only=params.get('_return_http_data_only'), 5225 _preload_content=params.get('_preload_content', True), 5226 _request_timeout=params.get('_request_timeout'), 5227 collection_formats=collection_formats) 5228 5229 def get_user_authorization(self, account_id, authorization_id, user_id, **kwargs): 5230 """ 5231 Returns the user authorization for a given authorization id 5232 This method makes a synchronous HTTP request by default. To make an 5233 asynchronous HTTP request, please define a `callback` function 5234 to be invoked when receiving the response. 5235 >>> def callback_function(response): 5236 >>> pprint(response) 5237 >>> 5238 >>> thread = api.get_user_authorization(account_id, authorization_id, user_id, callback=callback_function) 5239 5240 :param callback function: The callback function 5241 for asynchronous request. (optional) 5242 :param str account_id: The external account number (int) or account ID Guid. (required) 5243 :param str authorization_id: (required) 5244 :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) 5245 :return: UserAuthorization 5246 If the method is called asynchronously, 5247 returns the request thread. 5248 """ 5249 kwargs['_return_http_data_only'] = True 5250 if kwargs.get('callback'): 5251 return self.get_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 5252 else: 5253 (data) = self.get_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 5254 return data 5255 5256 def get_user_authorization_with_http_info(self, account_id, authorization_id, user_id, **kwargs): 5257 """ 5258 Returns the user authorization for a given authorization id 5259 This method makes a synchronous HTTP request by default. To make an 5260 asynchronous HTTP request, please define a `callback` function 5261 to be invoked when receiving the response. 5262 >>> def callback_function(response): 5263 >>> pprint(response) 5264 >>> 5265 >>> thread = api.get_user_authorization_with_http_info(account_id, authorization_id, user_id, callback=callback_function) 5266 5267 :param callback function: The callback function 5268 for asynchronous request. (optional) 5269 :param str account_id: The external account number (int) or account ID Guid. (required) 5270 :param str authorization_id: (required) 5271 :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) 5272 :return: UserAuthorization 5273 If the method is called asynchronously, 5274 returns the request thread. 5275 """ 5276 5277 all_params = ['account_id', 'authorization_id', 'user_id'] 5278 all_params.append('callback') 5279 all_params.append('_return_http_data_only') 5280 all_params.append('_preload_content') 5281 all_params.append('_request_timeout') 5282 5283 params = locals() 5284 for key, val in iteritems(params['kwargs']): 5285 if key not in all_params: 5286 raise TypeError( 5287 "Got an unexpected keyword argument '%s'" 5288 " to method get_user_authorization" % key 5289 ) 5290 params[key] = val 5291 del params['kwargs'] 5292 # verify the required parameter 'account_id' is set 5293 if ('account_id' not in params) or (params['account_id'] is None): 5294 raise ValueError("Missing the required parameter `account_id` when calling `get_user_authorization`") 5295 # verify the required parameter 'authorization_id' is set 5296 if ('authorization_id' not in params) or (params['authorization_id'] is None): 5297 raise ValueError("Missing the required parameter `authorization_id` when calling `get_user_authorization`") 5298 # verify the required parameter 'user_id' is set 5299 if ('user_id' not in params) or (params['user_id'] is None): 5300 raise ValueError("Missing the required parameter `user_id` when calling `get_user_authorization`") 5301 5302 5303 collection_formats = {} 5304 5305 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorization/{authorizationId}'.replace('{format}', 'json') 5306 path_params = {} 5307 if 'account_id' in params: 5308 path_params['accountId'] = params['account_id'] 5309 if 'authorization_id' in params: 5310 path_params['authorizationId'] = params['authorization_id'] 5311 if 'user_id' in params: 5312 path_params['userId'] = params['user_id'] 5313 5314 query_params = {} 5315 5316 header_params = {} 5317 5318 form_params = [] 5319 local_var_files = {} 5320 5321 body_params = None 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, 'GET', 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='UserAuthorization', 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 get_watermark(self, account_id, **kwargs): 5345 """ 5346 Get watermark information. 5347 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.get_watermark(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 :return: Watermark 5360 If the method is called asynchronously, 5361 returns the request thread. 5362 """ 5363 kwargs['_return_http_data_only'] = True 5364 if kwargs.get('callback'): 5365 return self.get_watermark_with_http_info(account_id, **kwargs) 5366 else: 5367 (data) = self.get_watermark_with_http_info(account_id, **kwargs) 5368 return data 5369 5370 def get_watermark_with_http_info(self, account_id, **kwargs): 5371 """ 5372 Get watermark information. 5373 5374 This method makes a synchronous HTTP request by default. To make an 5375 asynchronous HTTP request, please define a `callback` function 5376 to be invoked when receiving the response. 5377 >>> def callback_function(response): 5378 >>> pprint(response) 5379 >>> 5380 >>> thread = api.get_watermark_with_http_info(account_id, callback=callback_function) 5381 5382 :param callback function: The callback function 5383 for asynchronous request. (optional) 5384 :param str account_id: The external account number (int) or account ID Guid. (required) 5385 :return: Watermark 5386 If the method is called asynchronously, 5387 returns the request thread. 5388 """ 5389 5390 all_params = ['account_id'] 5391 all_params.append('callback') 5392 all_params.append('_return_http_data_only') 5393 all_params.append('_preload_content') 5394 all_params.append('_request_timeout') 5395 5396 params = locals() 5397 for key, val in iteritems(params['kwargs']): 5398 if key not in all_params: 5399 raise TypeError( 5400 "Got an unexpected keyword argument '%s'" 5401 " to method get_watermark" % key 5402 ) 5403 params[key] = val 5404 del params['kwargs'] 5405 # verify the required parameter 'account_id' is set 5406 if ('account_id' not in params) or (params['account_id'] is None): 5407 raise ValueError("Missing the required parameter `account_id` when calling `get_watermark`") 5408 5409 5410 collection_formats = {} 5411 5412 resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json') 5413 path_params = {} 5414 if 'account_id' in params: 5415 path_params['accountId'] = params['account_id'] 5416 5417 query_params = {} 5418 5419 header_params = {} 5420 5421 form_params = [] 5422 local_var_files = {} 5423 5424 body_params = None 5425 # HTTP header `Accept` 5426 header_params['Accept'] = self.api_client.\ 5427 select_header_accept(['application/json']) 5428 5429 # Authentication setting 5430 auth_settings = [] 5431 5432 return self.api_client.call_api(resource_path, 'GET', 5433 path_params, 5434 query_params, 5435 header_params, 5436 body=body_params, 5437 post_params=form_params, 5438 files=local_var_files, 5439 response_type='Watermark', 5440 auth_settings=auth_settings, 5441 callback=params.get('callback'), 5442 _return_http_data_only=params.get('_return_http_data_only'), 5443 _preload_content=params.get('_preload_content', True), 5444 _request_timeout=params.get('_request_timeout'), 5445 collection_formats=collection_formats) 5446 5447 def get_watermark_preview(self, account_id, **kwargs): 5448 """ 5449 Get watermark preview. 5450 5451 This method makes a synchronous HTTP request by default. To make an 5452 asynchronous HTTP request, please define a `callback` function 5453 to be invoked when receiving the response. 5454 >>> def callback_function(response): 5455 >>> pprint(response) 5456 >>> 5457 >>> thread = api.get_watermark_preview(account_id, callback=callback_function) 5458 5459 :param callback function: The callback function 5460 for asynchronous request. (optional) 5461 :param str account_id: The external account number (int) or account ID Guid. (required) 5462 :param Watermark watermark: 5463 :return: Watermark 5464 If the method is called asynchronously, 5465 returns the request thread. 5466 """ 5467 kwargs['_return_http_data_only'] = True 5468 if kwargs.get('callback'): 5469 return self.get_watermark_preview_with_http_info(account_id, **kwargs) 5470 else: 5471 (data) = self.get_watermark_preview_with_http_info(account_id, **kwargs) 5472 return data 5473 5474 def get_watermark_preview_with_http_info(self, account_id, **kwargs): 5475 """ 5476 Get watermark preview. 5477 5478 This method makes a synchronous HTTP request by default. To make an 5479 asynchronous HTTP request, please define a `callback` function 5480 to be invoked when receiving the response. 5481 >>> def callback_function(response): 5482 >>> pprint(response) 5483 >>> 5484 >>> thread = api.get_watermark_preview_with_http_info(account_id, callback=callback_function) 5485 5486 :param callback function: The callback function 5487 for asynchronous request. (optional) 5488 :param str account_id: The external account number (int) or account ID Guid. (required) 5489 :param Watermark watermark: 5490 :return: Watermark 5491 If the method is called asynchronously, 5492 returns the request thread. 5493 """ 5494 5495 all_params = ['account_id', 'watermark'] 5496 all_params.append('callback') 5497 all_params.append('_return_http_data_only') 5498 all_params.append('_preload_content') 5499 all_params.append('_request_timeout') 5500 5501 params = locals() 5502 for key, val in iteritems(params['kwargs']): 5503 if key not in all_params: 5504 raise TypeError( 5505 "Got an unexpected keyword argument '%s'" 5506 " to method get_watermark_preview" % key 5507 ) 5508 params[key] = val 5509 del params['kwargs'] 5510 # verify the required parameter 'account_id' is set 5511 if ('account_id' not in params) or (params['account_id'] is None): 5512 raise ValueError("Missing the required parameter `account_id` when calling `get_watermark_preview`") 5513 5514 5515 collection_formats = {} 5516 5517 resource_path = '/v2.1/accounts/{accountId}/watermark/preview'.replace('{format}', 'json') 5518 path_params = {} 5519 if 'account_id' in params: 5520 path_params['accountId'] = params['account_id'] 5521 5522 query_params = {} 5523 5524 header_params = {} 5525 5526 form_params = [] 5527 local_var_files = {} 5528 5529 body_params = None 5530 if 'watermark' in params: 5531 body_params = params['watermark'] 5532 # HTTP header `Accept` 5533 header_params['Accept'] = self.api_client.\ 5534 select_header_accept(['application/json']) 5535 5536 # Authentication setting 5537 auth_settings = [] 5538 5539 return self.api_client.call_api(resource_path, 'PUT', 5540 path_params, 5541 query_params, 5542 header_params, 5543 body=body_params, 5544 post_params=form_params, 5545 files=local_var_files, 5546 response_type='Watermark', 5547 auth_settings=auth_settings, 5548 callback=params.get('callback'), 5549 _return_http_data_only=params.get('_return_http_data_only'), 5550 _preload_content=params.get('_preload_content', True), 5551 _request_timeout=params.get('_request_timeout'), 5552 collection_formats=collection_formats) 5553 5554 def list_brands(self, account_id, **kwargs): 5555 """ 5556 Gets a list of brand profiles. 5557 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. 5558 This method makes a synchronous HTTP request by default. To make an 5559 asynchronous HTTP request, please define a `callback` function 5560 to be invoked when receiving the response. 5561 >>> def callback_function(response): 5562 >>> pprint(response) 5563 >>> 5564 >>> thread = api.list_brands(account_id, callback=callback_function) 5565 5566 :param callback function: The callback function 5567 for asynchronous request. (optional) 5568 :param str account_id: The external account number (int) or account ID Guid. (required) 5569 :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set. 5570 :param str include_logos: When set to **true**, returns the logos associated with the brand. 5571 :return: BrandsResponse 5572 If the method is called asynchronously, 5573 returns the request thread. 5574 """ 5575 kwargs['_return_http_data_only'] = True 5576 if kwargs.get('callback'): 5577 return self.list_brands_with_http_info(account_id, **kwargs) 5578 else: 5579 (data) = self.list_brands_with_http_info(account_id, **kwargs) 5580 return data 5581 5582 def list_brands_with_http_info(self, account_id, **kwargs): 5583 """ 5584 Gets a list of brand profiles. 5585 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. 5586 This method makes a synchronous HTTP request by default. To make an 5587 asynchronous HTTP request, please define a `callback` function 5588 to be invoked when receiving the response. 5589 >>> def callback_function(response): 5590 >>> pprint(response) 5591 >>> 5592 >>> thread = api.list_brands_with_http_info(account_id, callback=callback_function) 5593 5594 :param callback function: The callback function 5595 for asynchronous request. (optional) 5596 :param str account_id: The external account number (int) or account ID Guid. (required) 5597 :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set. 5598 :param str include_logos: When set to **true**, returns the logos associated with the brand. 5599 :return: BrandsResponse 5600 If the method is called asynchronously, 5601 returns the request thread. 5602 """ 5603 5604 all_params = ['account_id', 'exclude_distributor_brand', 'include_logos'] 5605 all_params.append('callback') 5606 all_params.append('_return_http_data_only') 5607 all_params.append('_preload_content') 5608 all_params.append('_request_timeout') 5609 5610 params = locals() 5611 for key, val in iteritems(params['kwargs']): 5612 if key not in all_params: 5613 raise TypeError( 5614 "Got an unexpected keyword argument '%s'" 5615 " to method list_brands" % key 5616 ) 5617 params[key] = val 5618 del params['kwargs'] 5619 # verify the required parameter 'account_id' is set 5620 if ('account_id' not in params) or (params['account_id'] is None): 5621 raise ValueError("Missing the required parameter `account_id` when calling `list_brands`") 5622 5623 5624 collection_formats = {} 5625 5626 resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json') 5627 path_params = {} 5628 if 'account_id' in params: 5629 path_params['accountId'] = params['account_id'] 5630 5631 query_params = {} 5632 if 'exclude_distributor_brand' in params: 5633 query_params['exclude_distributor_brand'] = params['exclude_distributor_brand'] 5634 if 'include_logos' in params: 5635 query_params['include_logos'] = params['include_logos'] 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='BrandsResponse', 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_custom_fields(self, account_id, **kwargs): 5666 """ 5667 Gets a list of custom fields associated with the account. 5668 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. 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_custom_fields(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 :return: CustomFields 5681 If the method is called asynchronously, 5682 returns the request thread. 5683 """ 5684 kwargs['_return_http_data_only'] = True 5685 if kwargs.get('callback'): 5686 return self.list_custom_fields_with_http_info(account_id, **kwargs) 5687 else: 5688 (data) = self.list_custom_fields_with_http_info(account_id, **kwargs) 5689 return data 5690 5691 def list_custom_fields_with_http_info(self, account_id, **kwargs): 5692 """ 5693 Gets a list of custom fields associated with the account. 5694 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. 5695 This method makes a synchronous HTTP request by default. To make an 5696 asynchronous HTTP request, please define a `callback` function 5697 to be invoked when receiving the response. 5698 >>> def callback_function(response): 5699 >>> pprint(response) 5700 >>> 5701 >>> thread = api.list_custom_fields_with_http_info(account_id, callback=callback_function) 5702 5703 :param callback function: The callback function 5704 for asynchronous request. (optional) 5705 :param str account_id: The external account number (int) or account ID Guid. (required) 5706 :return: CustomFields 5707 If the method is called asynchronously, 5708 returns the request thread. 5709 """ 5710 5711 all_params = ['account_id'] 5712 all_params.append('callback') 5713 all_params.append('_return_http_data_only') 5714 all_params.append('_preload_content') 5715 all_params.append('_request_timeout') 5716 5717 params = locals() 5718 for key, val in iteritems(params['kwargs']): 5719 if key not in all_params: 5720 raise TypeError( 5721 "Got an unexpected keyword argument '%s'" 5722 " to method list_custom_fields" % key 5723 ) 5724 params[key] = val 5725 del params['kwargs'] 5726 # verify the required parameter 'account_id' is set 5727 if ('account_id' not in params) or (params['account_id'] is None): 5728 raise ValueError("Missing the required parameter `account_id` when calling `list_custom_fields`") 5729 5730 5731 collection_formats = {} 5732 5733 resource_path = '/v2.1/accounts/{accountId}/custom_fields'.replace('{format}', 'json') 5734 path_params = {} 5735 if 'account_id' in params: 5736 path_params['accountId'] = params['account_id'] 5737 5738 query_params = {} 5739 5740 header_params = {} 5741 5742 form_params = [] 5743 local_var_files = {} 5744 5745 body_params = None 5746 # HTTP header `Accept` 5747 header_params['Accept'] = self.api_client.\ 5748 select_header_accept(['application/json']) 5749 5750 # Authentication setting 5751 auth_settings = [] 5752 5753 return self.api_client.call_api(resource_path, 'GET', 5754 path_params, 5755 query_params, 5756 header_params, 5757 body=body_params, 5758 post_params=form_params, 5759 files=local_var_files, 5760 response_type='CustomFields', 5761 auth_settings=auth_settings, 5762 callback=params.get('callback'), 5763 _return_http_data_only=params.get('_return_http_data_only'), 5764 _preload_content=params.get('_preload_content', True), 5765 _request_timeout=params.get('_request_timeout'), 5766 collection_formats=collection_formats) 5767 5768 def list_permissions(self, account_id, **kwargs): 5769 """ 5770 Gets a list of permission profiles. 5771 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. 5772 This method makes a synchronous HTTP request by default. To make an 5773 asynchronous HTTP request, please define a `callback` function 5774 to be invoked when receiving the response. 5775 >>> def callback_function(response): 5776 >>> pprint(response) 5777 >>> 5778 >>> thread = api.list_permissions(account_id, callback=callback_function) 5779 5780 :param callback function: The callback function 5781 for asynchronous request. (optional) 5782 :param str account_id: The external account number (int) or account ID Guid. (required) 5783 :param str include: 5784 :return: PermissionProfileInformation 5785 If the method is called asynchronously, 5786 returns the request thread. 5787 """ 5788 kwargs['_return_http_data_only'] = True 5789 if kwargs.get('callback'): 5790 return self.list_permissions_with_http_info(account_id, **kwargs) 5791 else: 5792 (data) = self.list_permissions_with_http_info(account_id, **kwargs) 5793 return data 5794 5795 def list_permissions_with_http_info(self, account_id, **kwargs): 5796 """ 5797 Gets a list of permission profiles. 5798 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. 5799 This method makes a synchronous HTTP request by default. To make an 5800 asynchronous HTTP request, please define a `callback` function 5801 to be invoked when receiving the response. 5802 >>> def callback_function(response): 5803 >>> pprint(response) 5804 >>> 5805 >>> thread = api.list_permissions_with_http_info(account_id, callback=callback_function) 5806 5807 :param callback function: The callback function 5808 for asynchronous request. (optional) 5809 :param str account_id: The external account number (int) or account ID Guid. (required) 5810 :param str include: 5811 :return: PermissionProfileInformation 5812 If the method is called asynchronously, 5813 returns the request thread. 5814 """ 5815 5816 all_params = ['account_id', 'include'] 5817 all_params.append('callback') 5818 all_params.append('_return_http_data_only') 5819 all_params.append('_preload_content') 5820 all_params.append('_request_timeout') 5821 5822 params = locals() 5823 for key, val in iteritems(params['kwargs']): 5824 if key not in all_params: 5825 raise TypeError( 5826 "Got an unexpected keyword argument '%s'" 5827 " to method list_permissions" % key 5828 ) 5829 params[key] = val 5830 del params['kwargs'] 5831 # verify the required parameter 'account_id' is set 5832 if ('account_id' not in params) or (params['account_id'] is None): 5833 raise ValueError("Missing the required parameter `account_id` when calling `list_permissions`") 5834 5835 5836 collection_formats = {} 5837 5838 resource_path = '/v2.1/accounts/{accountId}/permission_profiles'.replace('{format}', 'json') 5839 path_params = {} 5840 if 'account_id' in params: 5841 path_params['accountId'] = params['account_id'] 5842 5843 query_params = {} 5844 if 'include' in params: 5845 query_params['include'] = params['include'] 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='PermissionProfileInformation', 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_settings(self, account_id, **kwargs): 5876 """ 5877 Gets account settings information. 5878 Retrieves the account settings information for the specified account. 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_settings(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 :return: AccountSettingsInformation 5891 If the method is called asynchronously, 5892 returns the request thread. 5893 """ 5894 kwargs['_return_http_data_only'] = True 5895 if kwargs.get('callback'): 5896 return self.list_settings_with_http_info(account_id, **kwargs) 5897 else: 5898 (data) = self.list_settings_with_http_info(account_id, **kwargs) 5899 return data 5900 5901 def list_settings_with_http_info(self, account_id, **kwargs): 5902 """ 5903 Gets account settings information. 5904 Retrieves the account settings information for the specified account. 5905 This method makes a synchronous HTTP request by default. To make an 5906 asynchronous HTTP request, please define a `callback` function 5907 to be invoked when receiving the response. 5908 >>> def callback_function(response): 5909 >>> pprint(response) 5910 >>> 5911 >>> thread = api.list_settings_with_http_info(account_id, callback=callback_function) 5912 5913 :param callback function: The callback function 5914 for asynchronous request. (optional) 5915 :param str account_id: The external account number (int) or account ID Guid. (required) 5916 :return: AccountSettingsInformation 5917 If the method is called asynchronously, 5918 returns the request thread. 5919 """ 5920 5921 all_params = ['account_id'] 5922 all_params.append('callback') 5923 all_params.append('_return_http_data_only') 5924 all_params.append('_preload_content') 5925 all_params.append('_request_timeout') 5926 5927 params = locals() 5928 for key, val in iteritems(params['kwargs']): 5929 if key not in all_params: 5930 raise TypeError( 5931 "Got an unexpected keyword argument '%s'" 5932 " to method list_settings" % key 5933 ) 5934 params[key] = val 5935 del params['kwargs'] 5936 # verify the required parameter 'account_id' is set 5937 if ('account_id' not in params) or (params['account_id'] is None): 5938 raise ValueError("Missing the required parameter `account_id` when calling `list_settings`") 5939 5940 5941 collection_formats = {} 5942 5943 resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json') 5944 path_params = {} 5945 if 'account_id' in params: 5946 path_params['accountId'] = params['account_id'] 5947 5948 query_params = {} 5949 5950 header_params = {} 5951 5952 form_params = [] 5953 local_var_files = {} 5954 5955 body_params = None 5956 # HTTP header `Accept` 5957 header_params['Accept'] = self.api_client.\ 5958 select_header_accept(['application/json']) 5959 5960 # Authentication setting 5961 auth_settings = [] 5962 5963 return self.api_client.call_api(resource_path, 'GET', 5964 path_params, 5965 query_params, 5966 header_params, 5967 body=body_params, 5968 post_params=form_params, 5969 files=local_var_files, 5970 response_type='AccountSettingsInformation', 5971 auth_settings=auth_settings, 5972 callback=params.get('callback'), 5973 _return_http_data_only=params.get('_return_http_data_only'), 5974 _preload_content=params.get('_preload_content', True), 5975 _request_timeout=params.get('_request_timeout'), 5976 collection_formats=collection_formats) 5977 5978 def list_shared_access(self, account_id, **kwargs): 5979 """ 5980 Reserved: Gets the shared item status for one or more users. 5981 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. 5982 This method makes a synchronous HTTP request by default. To make an 5983 asynchronous HTTP request, please define a `callback` function 5984 to be invoked when receiving the response. 5985 >>> def callback_function(response): 5986 >>> pprint(response) 5987 >>> 5988 >>> thread = api.list_shared_access(account_id, callback=callback_function) 5989 5990 :param callback function: The callback function 5991 for asynchronous request. (optional) 5992 :param str account_id: The external account number (int) or account ID Guid. (required) 5993 :param str count: Specifies maximum number of results included in the response. If no value is specified, this defaults to 1000. 5994 :param str envelopes_not_shared_user_status: 5995 :param str folder_ids: 5996 :param str item_type: Specifies the type of shared item being requested. The accepted values are: -envelopes: returns information about envelope sharing between users. 5997 :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. 5998 :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 5999 :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. 6000 :param str user_ids: A comma separated list of userIds for whom the shared item information is being requested. 6001 :return: AccountSharedAccess 6002 If the method is called asynchronously, 6003 returns the request thread. 6004 """ 6005 kwargs['_return_http_data_only'] = True 6006 if kwargs.get('callback'): 6007 return self.list_shared_access_with_http_info(account_id, **kwargs) 6008 else: 6009 (data) = self.list_shared_access_with_http_info(account_id, **kwargs) 6010 return data 6011 6012 def list_shared_access_with_http_info(self, account_id, **kwargs): 6013 """ 6014 Reserved: Gets the shared item status for one or more users. 6015 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. 6016 This method makes a synchronous HTTP request by default. To make an 6017 asynchronous HTTP request, please define a `callback` function 6018 to be invoked when receiving the response. 6019 >>> def callback_function(response): 6020 >>> pprint(response) 6021 >>> 6022 >>> thread = api.list_shared_access_with_http_info(account_id, callback=callback_function) 6023 6024 :param callback function: The callback function 6025 for asynchronous request. (optional) 6026 :param str account_id: The external account number (int) or account ID Guid. (required) 6027 :param str count: Specifies maximum number of results included in the response. If no value is specified, this defaults to 1000. 6028 :param str envelopes_not_shared_user_status: 6029 :param str folder_ids: 6030 :param str item_type: Specifies the type of shared item being requested. The accepted values are: -envelopes: returns information about envelope sharing between users. 6031 :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. 6032 :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 6033 :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. 6034 :param str user_ids: A comma separated list of userIds for whom the shared item information is being requested. 6035 :return: AccountSharedAccess 6036 If the method is called asynchronously, 6037 returns the request thread. 6038 """ 6039 6040 all_params = ['account_id', 'count', 'envelopes_not_shared_user_status', 'folder_ids', 'item_type', 'search_text', 'shared', 'start_position', 'user_ids'] 6041 all_params.append('callback') 6042 all_params.append('_return_http_data_only') 6043 all_params.append('_preload_content') 6044 all_params.append('_request_timeout') 6045 6046 params = locals() 6047 for key, val in iteritems(params['kwargs']): 6048 if key not in all_params: 6049 raise TypeError( 6050 "Got an unexpected keyword argument '%s'" 6051 " to method list_shared_access" % key 6052 ) 6053 params[key] = val 6054 del params['kwargs'] 6055 # verify the required parameter 'account_id' is set 6056 if ('account_id' not in params) or (params['account_id'] is None): 6057 raise ValueError("Missing the required parameter `account_id` when calling `list_shared_access`") 6058 6059 6060 collection_formats = {} 6061 6062 resource_path = '/v2.1/accounts/{accountId}/shared_access'.replace('{format}', 'json') 6063 path_params = {} 6064 if 'account_id' in params: 6065 path_params['accountId'] = params['account_id'] 6066 6067 query_params = {} 6068 if 'count' in params: 6069 query_params['count'] = params['count'] 6070 if 'envelopes_not_shared_user_status' in params: 6071 query_params['envelopes_not_shared_user_status'] = params['envelopes_not_shared_user_status'] 6072 if 'folder_ids' in params: 6073 query_params['folder_ids'] = params['folder_ids'] 6074 if 'item_type' in params: 6075 query_params['item_type'] = params['item_type'] 6076 if 'search_text' in params: 6077 query_params['search_text'] = params['search_text'] 6078 if 'shared' in params: 6079 query_params['shared'] = params['shared'] 6080 if 'start_position' in params: 6081 query_params['start_position'] = params['start_position'] 6082 if 'user_ids' in params: 6083 query_params['user_ids'] = params['user_ids'] 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='AccountSharedAccess', 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_signature_providers(self, account_id, **kwargs): 6114 """ 6115 Returns Account available signature providers for specified account. 6116 Returns a list of signature providers that the specified account can use. 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_signature_providers(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: AccountSignatureProviders 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_signature_providers_with_http_info(account_id, **kwargs) 6135 else: 6136 (data) = self.list_signature_providers_with_http_info(account_id, **kwargs) 6137 return data 6138 6139 def list_signature_providers_with_http_info(self, account_id, **kwargs): 6140 """ 6141 Returns Account available signature providers for specified account. 6142 Returns a list of signature providers that the specified account can use. 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_signature_providers_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: AccountSignatureProviders 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_signature_providers" % 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_signature_providers`") 6177 6178 6179 collection_formats = {} 6180 6181 resource_path = '/v2.1/accounts/{accountId}/signatureProviders'.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='AccountSignatureProviders', 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 list_unsupported_file_types(self, account_id, **kwargs): 6217 """ 6218 Gets a list of unsupported file types. 6219 Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system. 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.list_unsupported_file_types(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 :return: FileTypeList 6232 If the method is called asynchronously, 6233 returns the request thread. 6234 """ 6235 kwargs['_return_http_data_only'] = True 6236 if kwargs.get('callback'): 6237 return self.list_unsupported_file_types_with_http_info(account_id, **kwargs) 6238 else: 6239 (data) = self.list_unsupported_file_types_with_http_info(account_id, **kwargs) 6240 return data 6241 6242 def list_unsupported_file_types_with_http_info(self, account_id, **kwargs): 6243 """ 6244 Gets a list of unsupported file types. 6245 Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system. 6246 This method makes a synchronous HTTP request by default. To make an 6247 asynchronous HTTP request, please define a `callback` function 6248 to be invoked when receiving the response. 6249 >>> def callback_function(response): 6250 >>> pprint(response) 6251 >>> 6252 >>> thread = api.list_unsupported_file_types_with_http_info(account_id, callback=callback_function) 6253 6254 :param callback function: The callback function 6255 for asynchronous request. (optional) 6256 :param str account_id: The external account number (int) or account ID Guid. (required) 6257 :return: FileTypeList 6258 If the method is called asynchronously, 6259 returns the request thread. 6260 """ 6261 6262 all_params = ['account_id'] 6263 all_params.append('callback') 6264 all_params.append('_return_http_data_only') 6265 all_params.append('_preload_content') 6266 all_params.append('_request_timeout') 6267 6268 params = locals() 6269 for key, val in iteritems(params['kwargs']): 6270 if key not in all_params: 6271 raise TypeError( 6272 "Got an unexpected keyword argument '%s'" 6273 " to method list_unsupported_file_types" % key 6274 ) 6275 params[key] = val 6276 del params['kwargs'] 6277 # verify the required parameter 'account_id' is set 6278 if ('account_id' not in params) or (params['account_id'] is None): 6279 raise ValueError("Missing the required parameter `account_id` when calling `list_unsupported_file_types`") 6280 6281 6282 collection_formats = {} 6283 6284 resource_path = '/v2.1/accounts/{accountId}/unsupported_file_types'.replace('{format}', 'json') 6285 path_params = {} 6286 if 'account_id' in params: 6287 path_params['accountId'] = params['account_id'] 6288 6289 query_params = {} 6290 6291 header_params = {} 6292 6293 form_params = [] 6294 local_var_files = {} 6295 6296 body_params = None 6297 # HTTP header `Accept` 6298 header_params['Accept'] = self.api_client.\ 6299 select_header_accept(['application/json']) 6300 6301 # Authentication setting 6302 auth_settings = [] 6303 6304 return self.api_client.call_api(resource_path, 'GET', 6305 path_params, 6306 query_params, 6307 header_params, 6308 body=body_params, 6309 post_params=form_params, 6310 files=local_var_files, 6311 response_type='FileTypeList', 6312 auth_settings=auth_settings, 6313 callback=params.get('callback'), 6314 _return_http_data_only=params.get('_return_http_data_only'), 6315 _preload_content=params.get('_preload_content', True), 6316 _request_timeout=params.get('_request_timeout'), 6317 collection_formats=collection_formats) 6318 6319 def un_favorite_template(self, account_id, **kwargs): 6320 """ 6321 Unfavorite a template 6322 6323 This method makes a synchronous HTTP request by default. To make an 6324 asynchronous HTTP request, please define a `callback` function 6325 to be invoked when receiving the response. 6326 >>> def callback_function(response): 6327 >>> pprint(response) 6328 >>> 6329 >>> thread = api.un_favorite_template(account_id, callback=callback_function) 6330 6331 :param callback function: The callback function 6332 for asynchronous request. (optional) 6333 :param str account_id: The external account number (int) or account ID Guid. (required) 6334 :param FavoriteTemplatesInfo favorite_templates_info: 6335 :return: FavoriteTemplatesInfo 6336 If the method is called asynchronously, 6337 returns the request thread. 6338 """ 6339 kwargs['_return_http_data_only'] = True 6340 if kwargs.get('callback'): 6341 return self.un_favorite_template_with_http_info(account_id, **kwargs) 6342 else: 6343 (data) = self.un_favorite_template_with_http_info(account_id, **kwargs) 6344 return data 6345 6346 def un_favorite_template_with_http_info(self, account_id, **kwargs): 6347 """ 6348 Unfavorite a template 6349 6350 This method makes a synchronous HTTP request by default. To make an 6351 asynchronous HTTP request, please define a `callback` function 6352 to be invoked when receiving the response. 6353 >>> def callback_function(response): 6354 >>> pprint(response) 6355 >>> 6356 >>> thread = api.un_favorite_template_with_http_info(account_id, callback=callback_function) 6357 6358 :param callback function: The callback function 6359 for asynchronous request. (optional) 6360 :param str account_id: The external account number (int) or account ID Guid. (required) 6361 :param FavoriteTemplatesInfo favorite_templates_info: 6362 :return: FavoriteTemplatesInfo 6363 If the method is called asynchronously, 6364 returns the request thread. 6365 """ 6366 6367 all_params = ['account_id', 'favorite_templates_info'] 6368 all_params.append('callback') 6369 all_params.append('_return_http_data_only') 6370 all_params.append('_preload_content') 6371 all_params.append('_request_timeout') 6372 6373 params = locals() 6374 for key, val in iteritems(params['kwargs']): 6375 if key not in all_params: 6376 raise TypeError( 6377 "Got an unexpected keyword argument '%s'" 6378 " to method un_favorite_template" % key 6379 ) 6380 params[key] = val 6381 del params['kwargs'] 6382 # verify the required parameter 'account_id' is set 6383 if ('account_id' not in params) or (params['account_id'] is None): 6384 raise ValueError("Missing the required parameter `account_id` when calling `un_favorite_template`") 6385 6386 6387 collection_formats = {} 6388 6389 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 6390 path_params = {} 6391 if 'account_id' in params: 6392 path_params['accountId'] = params['account_id'] 6393 6394 query_params = {} 6395 6396 header_params = {} 6397 6398 form_params = [] 6399 local_var_files = {} 6400 6401 body_params = None 6402 if 'favorite_templates_info' in params: 6403 body_params = params['favorite_templates_info'] 6404 # HTTP header `Accept` 6405 header_params['Accept'] = self.api_client.\ 6406 select_header_accept(['application/json']) 6407 6408 # Authentication setting 6409 auth_settings = [] 6410 6411 return self.api_client.call_api(resource_path, 'DELETE', 6412 path_params, 6413 query_params, 6414 header_params, 6415 body=body_params, 6416 post_params=form_params, 6417 files=local_var_files, 6418 response_type='FavoriteTemplatesInfo', 6419 auth_settings=auth_settings, 6420 callback=params.get('callback'), 6421 _return_http_data_only=params.get('_return_http_data_only'), 6422 _preload_content=params.get('_preload_content', True), 6423 _request_timeout=params.get('_request_timeout'), 6424 collection_formats=collection_formats) 6425 6426 def update_account_signature(self, account_id, **kwargs): 6427 """ 6428 Updates a account signature. 6429 6430 This method makes a synchronous HTTP request by default. To make an 6431 asynchronous HTTP request, please define a `callback` function 6432 to be invoked when receiving the response. 6433 >>> def callback_function(response): 6434 >>> pprint(response) 6435 >>> 6436 >>> thread = api.update_account_signature(account_id, callback=callback_function) 6437 6438 :param callback function: The callback function 6439 for asynchronous request. (optional) 6440 :param str account_id: The external account number (int) or account ID Guid. (required) 6441 :param AccountSignaturesInformation account_signatures_information: 6442 :return: AccountSignaturesInformation 6443 If the method is called asynchronously, 6444 returns the request thread. 6445 """ 6446 kwargs['_return_http_data_only'] = True 6447 if kwargs.get('callback'): 6448 return self.update_account_signature_with_http_info(account_id, **kwargs) 6449 else: 6450 (data) = self.update_account_signature_with_http_info(account_id, **kwargs) 6451 return data 6452 6453 def update_account_signature_with_http_info(self, account_id, **kwargs): 6454 """ 6455 Updates a account signature. 6456 6457 This method makes a synchronous HTTP request by default. To make an 6458 asynchronous HTTP request, please define a `callback` function 6459 to be invoked when receiving the response. 6460 >>> def callback_function(response): 6461 >>> pprint(response) 6462 >>> 6463 >>> thread = api.update_account_signature_with_http_info(account_id, callback=callback_function) 6464 6465 :param callback function: The callback function 6466 for asynchronous request. (optional) 6467 :param str account_id: The external account number (int) or account ID Guid. (required) 6468 :param AccountSignaturesInformation account_signatures_information: 6469 :return: AccountSignaturesInformation 6470 If the method is called asynchronously, 6471 returns the request thread. 6472 """ 6473 6474 all_params = ['account_id', 'account_signatures_information'] 6475 all_params.append('callback') 6476 all_params.append('_return_http_data_only') 6477 all_params.append('_preload_content') 6478 all_params.append('_request_timeout') 6479 6480 params = locals() 6481 for key, val in iteritems(params['kwargs']): 6482 if key not in all_params: 6483 raise TypeError( 6484 "Got an unexpected keyword argument '%s'" 6485 " to method update_account_signature" % key 6486 ) 6487 params[key] = val 6488 del params['kwargs'] 6489 # verify the required parameter 'account_id' is set 6490 if ('account_id' not in params) or (params['account_id'] is None): 6491 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature`") 6492 6493 6494 collection_formats = {} 6495 6496 resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json') 6497 path_params = {} 6498 if 'account_id' in params: 6499 path_params['accountId'] = params['account_id'] 6500 6501 query_params = {} 6502 6503 header_params = {} 6504 6505 form_params = [] 6506 local_var_files = {} 6507 6508 body_params = None 6509 if 'account_signatures_information' in params: 6510 body_params = params['account_signatures_information'] 6511 # HTTP header `Accept` 6512 header_params['Accept'] = self.api_client.\ 6513 select_header_accept(['application/json']) 6514 6515 # Authentication setting 6516 auth_settings = [] 6517 6518 return self.api_client.call_api(resource_path, 'PUT', 6519 path_params, 6520 query_params, 6521 header_params, 6522 body=body_params, 6523 post_params=form_params, 6524 files=local_var_files, 6525 response_type='AccountSignaturesInformation', 6526 auth_settings=auth_settings, 6527 callback=params.get('callback'), 6528 _return_http_data_only=params.get('_return_http_data_only'), 6529 _preload_content=params.get('_preload_content', True), 6530 _request_timeout=params.get('_request_timeout'), 6531 collection_formats=collection_formats) 6532 6533 def update_account_signature_by_id(self, account_id, signature_id, **kwargs): 6534 """ 6535 Updates a account signature. 6536 6537 This method makes a synchronous HTTP request by default. To make an 6538 asynchronous HTTP request, please define a `callback` function 6539 to be invoked when receiving the response. 6540 >>> def callback_function(response): 6541 >>> pprint(response) 6542 >>> 6543 >>> thread = api.update_account_signature_by_id(account_id, signature_id, callback=callback_function) 6544 6545 :param callback function: The callback function 6546 for asynchronous request. (optional) 6547 :param str account_id: The external account number (int) or account ID Guid. (required) 6548 :param str signature_id: The ID of the signature being accessed. (required) 6549 :param str close_existing_signature: 6550 :param AccountSignatureDefinition account_signature_definition: 6551 :return: AccountSignature 6552 If the method is called asynchronously, 6553 returns the request thread. 6554 """ 6555 kwargs['_return_http_data_only'] = True 6556 if kwargs.get('callback'): 6557 return self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs) 6558 else: 6559 (data) = self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs) 6560 return data 6561 6562 def update_account_signature_by_id_with_http_info(self, account_id, signature_id, **kwargs): 6563 """ 6564 Updates a account signature. 6565 6566 This method makes a synchronous HTTP request by default. To make an 6567 asynchronous HTTP request, please define a `callback` function 6568 to be invoked when receiving the response. 6569 >>> def callback_function(response): 6570 >>> pprint(response) 6571 >>> 6572 >>> thread = api.update_account_signature_by_id_with_http_info(account_id, signature_id, callback=callback_function) 6573 6574 :param callback function: The callback function 6575 for asynchronous request. (optional) 6576 :param str account_id: The external account number (int) or account ID Guid. (required) 6577 :param str signature_id: The ID of the signature being accessed. (required) 6578 :param str close_existing_signature: 6579 :param AccountSignatureDefinition account_signature_definition: 6580 :return: AccountSignature 6581 If the method is called asynchronously, 6582 returns the request thread. 6583 """ 6584 6585 all_params = ['account_id', 'signature_id', 'close_existing_signature', 'account_signature_definition'] 6586 all_params.append('callback') 6587 all_params.append('_return_http_data_only') 6588 all_params.append('_preload_content') 6589 all_params.append('_request_timeout') 6590 6591 params = locals() 6592 for key, val in iteritems(params['kwargs']): 6593 if key not in all_params: 6594 raise TypeError( 6595 "Got an unexpected keyword argument '%s'" 6596 " to method update_account_signature_by_id" % key 6597 ) 6598 params[key] = val 6599 del params['kwargs'] 6600 # verify the required parameter 'account_id' is set 6601 if ('account_id' not in params) or (params['account_id'] is None): 6602 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_by_id`") 6603 # verify the required parameter 'signature_id' is set 6604 if ('signature_id' not in params) or (params['signature_id'] is None): 6605 raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_by_id`") 6606 6607 6608 collection_formats = {} 6609 6610 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 6611 path_params = {} 6612 if 'account_id' in params: 6613 path_params['accountId'] = params['account_id'] 6614 if 'signature_id' in params: 6615 path_params['signatureId'] = params['signature_id'] 6616 6617 query_params = {} 6618 if 'close_existing_signature' in params: 6619 query_params['close_existing_signature'] = params['close_existing_signature'] 6620 6621 header_params = {} 6622 6623 form_params = [] 6624 local_var_files = {} 6625 6626 body_params = None 6627 if 'account_signature_definition' in params: 6628 body_params = params['account_signature_definition'] 6629 # HTTP header `Accept` 6630 header_params['Accept'] = self.api_client.\ 6631 select_header_accept(['application/json']) 6632 6633 # Authentication setting 6634 auth_settings = [] 6635 6636 return self.api_client.call_api(resource_path, 'PUT', 6637 path_params, 6638 query_params, 6639 header_params, 6640 body=body_params, 6641 post_params=form_params, 6642 files=local_var_files, 6643 response_type='AccountSignature', 6644 auth_settings=auth_settings, 6645 callback=params.get('callback'), 6646 _return_http_data_only=params.get('_return_http_data_only'), 6647 _preload_content=params.get('_preload_content', True), 6648 _request_timeout=params.get('_request_timeout'), 6649 collection_formats=collection_formats) 6650 6651 def update_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 6652 """ 6653 Sets a signature, initials, or stamps image. 6654 6655 This method makes a synchronous HTTP request by default. To make an 6656 asynchronous HTTP request, please define a `callback` function 6657 to be invoked when receiving the response. 6658 >>> def callback_function(response): 6659 >>> pprint(response) 6660 >>> 6661 >>> thread = api.update_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 6662 6663 :param callback function: The callback function 6664 for asynchronous request. (optional) 6665 :param str account_id: The external account number (int) or account ID Guid. (required) 6666 :param str image_type: One of **signature_image** or **initials_image**. (required) 6667 :param str signature_id: The ID of the signature being accessed. (required) 6668 :param str transparent_png: 6669 :return: AccountSignature 6670 If the method is called asynchronously, 6671 returns the request thread. 6672 """ 6673 kwargs['_return_http_data_only'] = True 6674 if kwargs.get('callback'): 6675 return self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 6676 else: 6677 (data) = self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 6678 return data 6679 6680 def update_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 6681 """ 6682 Sets a signature, initials, or stamps image. 6683 6684 This method makes a synchronous HTTP request by default. To make an 6685 asynchronous HTTP request, please define a `callback` function 6686 to be invoked when receiving the response. 6687 >>> def callback_function(response): 6688 >>> pprint(response) 6689 >>> 6690 >>> thread = api.update_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 6691 6692 :param callback function: The callback function 6693 for asynchronous request. (optional) 6694 :param str account_id: The external account number (int) or account ID Guid. (required) 6695 :param str image_type: One of **signature_image** or **initials_image**. (required) 6696 :param str signature_id: The ID of the signature being accessed. (required) 6697 :param str transparent_png: 6698 :return: AccountSignature 6699 If the method is called asynchronously, 6700 returns the request thread. 6701 """ 6702 6703 all_params = ['account_id', 'image_type', 'signature_id', 'transparent_png'] 6704 all_params.append('callback') 6705 all_params.append('_return_http_data_only') 6706 all_params.append('_preload_content') 6707 all_params.append('_request_timeout') 6708 6709 params = locals() 6710 for key, val in iteritems(params['kwargs']): 6711 if key not in all_params: 6712 raise TypeError( 6713 "Got an unexpected keyword argument '%s'" 6714 " to method update_account_signature_image" % key 6715 ) 6716 params[key] = val 6717 del params['kwargs'] 6718 # verify the required parameter 'account_id' is set 6719 if ('account_id' not in params) or (params['account_id'] is None): 6720 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_image`") 6721 # verify the required parameter 'image_type' is set 6722 if ('image_type' not in params) or (params['image_type'] is None): 6723 raise ValueError("Missing the required parameter `image_type` when calling `update_account_signature_image`") 6724 # verify the required parameter 'signature_id' is set 6725 if ('signature_id' not in params) or (params['signature_id'] is None): 6726 raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_image`") 6727 6728 6729 collection_formats = {} 6730 6731 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 6732 path_params = {} 6733 if 'account_id' in params: 6734 path_params['accountId'] = params['account_id'] 6735 if 'image_type' in params: 6736 path_params['imageType'] = params['image_type'] 6737 if 'signature_id' in params: 6738 path_params['signatureId'] = params['signature_id'] 6739 6740 query_params = {} 6741 if 'transparent_png' in params: 6742 query_params['transparent_png'] = params['transparent_png'] 6743 6744 header_params = {} 6745 6746 form_params = [] 6747 local_var_files = {} 6748 6749 body_params = None 6750 # HTTP header `Accept` 6751 header_params['Accept'] = self.api_client.\ 6752 select_header_accept(['application/json']) 6753 6754 # HTTP header `Content-Type` 6755 header_params['Content-Type'] = self.api_client.\ 6756 select_header_content_type(['image/gif']) 6757 6758 # Authentication setting 6759 auth_settings = [] 6760 6761 return self.api_client.call_api(resource_path, 'PUT', 6762 path_params, 6763 query_params, 6764 header_params, 6765 body=body_params, 6766 post_params=form_params, 6767 files=local_var_files, 6768 response_type='AccountSignature', 6769 auth_settings=auth_settings, 6770 callback=params.get('callback'), 6771 _return_http_data_only=params.get('_return_http_data_only'), 6772 _preload_content=params.get('_preload_content', True), 6773 _request_timeout=params.get('_request_timeout'), 6774 collection_formats=collection_formats) 6775 6776 def update_account_tab_settings(self, account_id, **kwargs): 6777 """ 6778 Modifies tab settings for specified account 6779 This method modifies the tab types and tab functionality that is enabled for an account. 6780 This method makes a synchronous HTTP request by default. To make an 6781 asynchronous HTTP request, please define a `callback` function 6782 to be invoked when receiving the response. 6783 >>> def callback_function(response): 6784 >>> pprint(response) 6785 >>> 6786 >>> thread = api.update_account_tab_settings(account_id, callback=callback_function) 6787 6788 :param callback function: The callback function 6789 for asynchronous request. (optional) 6790 :param str account_id: The external account number (int) or account ID Guid. (required) 6791 :param TabAccountSettings tab_account_settings: 6792 :return: TabAccountSettings 6793 If the method is called asynchronously, 6794 returns the request thread. 6795 """ 6796 kwargs['_return_http_data_only'] = True 6797 if kwargs.get('callback'): 6798 return self.update_account_tab_settings_with_http_info(account_id, **kwargs) 6799 else: 6800 (data) = self.update_account_tab_settings_with_http_info(account_id, **kwargs) 6801 return data 6802 6803 def update_account_tab_settings_with_http_info(self, account_id, **kwargs): 6804 """ 6805 Modifies tab settings for specified account 6806 This method modifies the tab types and tab functionality that is enabled for an account. 6807 This method makes a synchronous HTTP request by default. To make an 6808 asynchronous HTTP request, please define a `callback` function 6809 to be invoked when receiving the response. 6810 >>> def callback_function(response): 6811 >>> pprint(response) 6812 >>> 6813 >>> thread = api.update_account_tab_settings_with_http_info(account_id, callback=callback_function) 6814 6815 :param callback function: The callback function 6816 for asynchronous request. (optional) 6817 :param str account_id: The external account number (int) or account ID Guid. (required) 6818 :param TabAccountSettings tab_account_settings: 6819 :return: TabAccountSettings 6820 If the method is called asynchronously, 6821 returns the request thread. 6822 """ 6823 6824 all_params = ['account_id', 'tab_account_settings'] 6825 all_params.append('callback') 6826 all_params.append('_return_http_data_only') 6827 all_params.append('_preload_content') 6828 all_params.append('_request_timeout') 6829 6830 params = locals() 6831 for key, val in iteritems(params['kwargs']): 6832 if key not in all_params: 6833 raise TypeError( 6834 "Got an unexpected keyword argument '%s'" 6835 " to method update_account_tab_settings" % key 6836 ) 6837 params[key] = val 6838 del params['kwargs'] 6839 # verify the required parameter 'account_id' is set 6840 if ('account_id' not in params) or (params['account_id'] is None): 6841 raise ValueError("Missing the required parameter `account_id` when calling `update_account_tab_settings`") 6842 6843 6844 collection_formats = {} 6845 6846 resource_path = '/v2.1/accounts/{accountId}/settings/tabs'.replace('{format}', 'json') 6847 path_params = {} 6848 if 'account_id' in params: 6849 path_params['accountId'] = params['account_id'] 6850 6851 query_params = {} 6852 6853 header_params = {} 6854 6855 form_params = [] 6856 local_var_files = {} 6857 6858 body_params = None 6859 if 'tab_account_settings' in params: 6860 body_params = params['tab_account_settings'] 6861 # HTTP header `Accept` 6862 header_params['Accept'] = self.api_client.\ 6863 select_header_accept(['application/json']) 6864 6865 # Authentication setting 6866 auth_settings = [] 6867 6868 return self.api_client.call_api(resource_path, 'PUT', 6869 path_params, 6870 query_params, 6871 header_params, 6872 body=body_params, 6873 post_params=form_params, 6874 files=local_var_files, 6875 response_type='TabAccountSettings', 6876 auth_settings=auth_settings, 6877 callback=params.get('callback'), 6878 _return_http_data_only=params.get('_return_http_data_only'), 6879 _preload_content=params.get('_preload_content', True), 6880 _request_timeout=params.get('_request_timeout'), 6881 collection_formats=collection_formats) 6882 6883 def update_brand(self, account_id, brand_id, **kwargs): 6884 """ 6885 Updates an existing brand. 6886 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**). 6887 This method makes a synchronous HTTP request by default. To make an 6888 asynchronous HTTP request, please define a `callback` function 6889 to be invoked when receiving the response. 6890 >>> def callback_function(response): 6891 >>> pprint(response) 6892 >>> 6893 >>> thread = api.update_brand(account_id, brand_id, callback=callback_function) 6894 6895 :param callback function: The callback function 6896 for asynchronous request. (optional) 6897 :param str account_id: The external account number (int) or account ID Guid. (required) 6898 :param str brand_id: The unique identifier of a brand. (required) 6899 :param str replace_brand: 6900 :param Brand brand: 6901 :return: Brand 6902 If the method is called asynchronously, 6903 returns the request thread. 6904 """ 6905 kwargs['_return_http_data_only'] = True 6906 if kwargs.get('callback'): 6907 return self.update_brand_with_http_info(account_id, brand_id, **kwargs) 6908 else: 6909 (data) = self.update_brand_with_http_info(account_id, brand_id, **kwargs) 6910 return data 6911 6912 def update_brand_with_http_info(self, account_id, brand_id, **kwargs): 6913 """ 6914 Updates an existing brand. 6915 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**). 6916 This method makes a synchronous HTTP request by default. To make an 6917 asynchronous HTTP request, please define a `callback` function 6918 to be invoked when receiving the response. 6919 >>> def callback_function(response): 6920 >>> pprint(response) 6921 >>> 6922 >>> thread = api.update_brand_with_http_info(account_id, brand_id, callback=callback_function) 6923 6924 :param callback function: The callback function 6925 for asynchronous request. (optional) 6926 :param str account_id: The external account number (int) or account ID Guid. (required) 6927 :param str brand_id: The unique identifier of a brand. (required) 6928 :param str replace_brand: 6929 :param Brand brand: 6930 :return: Brand 6931 If the method is called asynchronously, 6932 returns the request thread. 6933 """ 6934 6935 all_params = ['account_id', 'brand_id', 'replace_brand', 'brand'] 6936 all_params.append('callback') 6937 all_params.append('_return_http_data_only') 6938 all_params.append('_preload_content') 6939 all_params.append('_request_timeout') 6940 6941 params = locals() 6942 for key, val in iteritems(params['kwargs']): 6943 if key not in all_params: 6944 raise TypeError( 6945 "Got an unexpected keyword argument '%s'" 6946 " to method update_brand" % key 6947 ) 6948 params[key] = val 6949 del params['kwargs'] 6950 # verify the required parameter 'account_id' is set 6951 if ('account_id' not in params) or (params['account_id'] is None): 6952 raise ValueError("Missing the required parameter `account_id` when calling `update_brand`") 6953 # verify the required parameter 'brand_id' is set 6954 if ('brand_id' not in params) or (params['brand_id'] is None): 6955 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand`") 6956 6957 6958 collection_formats = {} 6959 6960 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 6961 path_params = {} 6962 if 'account_id' in params: 6963 path_params['accountId'] = params['account_id'] 6964 if 'brand_id' in params: 6965 path_params['brandId'] = params['brand_id'] 6966 6967 query_params = {} 6968 if 'replace_brand' in params: 6969 query_params['replace_brand'] = params['replace_brand'] 6970 6971 header_params = {} 6972 6973 form_params = [] 6974 local_var_files = {} 6975 6976 body_params = None 6977 if 'brand' in params: 6978 body_params = params['brand'] 6979 # HTTP header `Accept` 6980 header_params['Accept'] = self.api_client.\ 6981 select_header_accept(['application/json']) 6982 6983 # Authentication setting 6984 auth_settings = [] 6985 6986 return self.api_client.call_api(resource_path, 'PUT', 6987 path_params, 6988 query_params, 6989 header_params, 6990 body=body_params, 6991 post_params=form_params, 6992 files=local_var_files, 6993 response_type='Brand', 6994 auth_settings=auth_settings, 6995 callback=params.get('callback'), 6996 _return_http_data_only=params.get('_return_http_data_only'), 6997 _preload_content=params.get('_preload_content', True), 6998 _request_timeout=params.get('_request_timeout'), 6999 collection_formats=collection_formats) 7000 7001 def update_brand_logo_by_type(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs): 7002 """ 7003 Put one branding logo. 7004 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**). 7005 This method makes a synchronous HTTP request by default. To make an 7006 asynchronous HTTP request, please define a `callback` function 7007 to be invoked when receiving the response. 7008 >>> def callback_function(response): 7009 >>> pprint(response) 7010 >>> 7011 >>> thread = api.update_brand_logo_by_type(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function) 7012 7013 :param callback function: The callback function 7014 for asynchronous request. (optional) 7015 :param str account_id: The external account number (int) or account ID GUID. (required) 7016 :param str brand_id: The ID of the brand. (required) 7017 :param str logo_type: The type of logo. Valid values are: - `primary` - `secondary` - `email` (required) 7018 :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) 7019 :return: None 7020 If the method is called asynchronously, 7021 returns the request thread. 7022 """ 7023 kwargs['_return_http_data_only'] = True 7024 if kwargs.get('callback'): 7025 return self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs) 7026 else: 7027 (data) = self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs) 7028 return data 7029 7030 def update_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs): 7031 """ 7032 Put one branding logo. 7033 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**). 7034 This method makes a synchronous HTTP request by default. To make an 7035 asynchronous HTTP request, please define a `callback` function 7036 to be invoked when receiving the response. 7037 >>> def callback_function(response): 7038 >>> pprint(response) 7039 >>> 7040 >>> thread = api.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function) 7041 7042 :param callback function: The callback function 7043 for asynchronous request. (optional) 7044 :param str account_id: The external account number (int) or account ID GUID. (required) 7045 :param str brand_id: The ID of the brand. (required) 7046 :param str logo_type: The type of logo. Valid values are: - `primary` - `secondary` - `email` (required) 7047 :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) 7048 :return: None 7049 If the method is called asynchronously, 7050 returns the request thread. 7051 """ 7052 7053 all_params = ['account_id', 'brand_id', 'logo_type', 'logo_file_bytes'] 7054 all_params.append('callback') 7055 all_params.append('_return_http_data_only') 7056 all_params.append('_preload_content') 7057 all_params.append('_request_timeout') 7058 7059 params = locals() 7060 for key, val in iteritems(params['kwargs']): 7061 if key not in all_params: 7062 raise TypeError( 7063 "Got an unexpected keyword argument '%s'" 7064 " to method update_brand_logo_by_type" % key 7065 ) 7066 params[key] = val 7067 del params['kwargs'] 7068 # verify the required parameter 'account_id' is set 7069 if ('account_id' not in params) or (params['account_id'] is None): 7070 raise ValueError("Missing the required parameter `account_id` when calling `update_brand_logo_by_type`") 7071 # verify the required parameter 'brand_id' is set 7072 if ('brand_id' not in params) or (params['brand_id'] is None): 7073 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_logo_by_type`") 7074 # verify the required parameter 'logo_type' is set 7075 if ('logo_type' not in params) or (params['logo_type'] is None): 7076 raise ValueError("Missing the required parameter `logo_type` when calling `update_brand_logo_by_type`") 7077 # verify the required parameter 'logo_file_bytes' is set 7078 if ('logo_file_bytes' not in params) or (params['logo_file_bytes'] is None): 7079 raise ValueError("Missing the required parameter `logo_file_bytes` when calling `update_brand_logo_by_type`") 7080 7081 7082 collection_formats = {} 7083 7084 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 7085 path_params = {} 7086 if 'account_id' in params: 7087 path_params['accountId'] = params['account_id'] 7088 if 'brand_id' in params: 7089 path_params['brandId'] = params['brand_id'] 7090 if 'logo_type' in params: 7091 path_params['logoType'] = params['logo_type'] 7092 7093 query_params = {} 7094 7095 header_params = {} 7096 7097 form_params = [] 7098 local_var_files = {} 7099 7100 body_params = None 7101 if 'logo_file_bytes' in params: 7102 body_params = params['logo_file_bytes'] 7103 # HTTP header `Accept` 7104 header_params['Accept'] = self.api_client.\ 7105 select_header_accept(['application/json']) 7106 7107 # HTTP header `Content-Type` 7108 header_params['Content-Type'] = self.api_client.\ 7109 select_header_content_type(['image/png']) 7110 7111 # Authentication setting 7112 auth_settings = [] 7113 7114 return self.api_client.call_api(resource_path, 'PUT', 7115 path_params, 7116 query_params, 7117 header_params, 7118 body=body_params, 7119 post_params=form_params, 7120 files=local_var_files, 7121 response_type=None, 7122 auth_settings=auth_settings, 7123 callback=params.get('callback'), 7124 _return_http_data_only=params.get('_return_http_data_only'), 7125 _preload_content=params.get('_preload_content', True), 7126 _request_timeout=params.get('_request_timeout'), 7127 collection_formats=collection_formats) 7128 7129 def update_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, file_xml, **kwargs): 7130 """ 7131 Uploads a branding resource file. 7132 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. 7133 This method makes a synchronous HTTP request by default. To make an 7134 asynchronous HTTP request, please define a `callback` function 7135 to be invoked when receiving the response. 7136 >>> def callback_function(response): 7137 >>> pprint(response) 7138 >>> 7139 >>> thread = api.update_brand_resources_by_content_type(account_id, brand_id, resource_content_type, file_xml, callback=callback_function) 7140 7141 :param callback function: The callback function 7142 for asynchronous request. (optional) 7143 :param str account_id: The external account number (int) or account ID GUID. (required) 7144 :param str brand_id: The ID of the brand. (required) 7145 :param str resource_content_type: The type of brand resource file that you are updating. Valid values are: - `sending` - `signing` - `email` - `signing_captive` (required) 7146 :param file file_xml: Brand resource XML file. (required) 7147 :return: BrandResources 7148 If the method is called asynchronously, 7149 returns the request thread. 7150 """ 7151 kwargs['_return_http_data_only'] = True 7152 if kwargs.get('callback'): 7153 return self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs) 7154 else: 7155 (data) = self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs) 7156 return data 7157 7158 def update_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, file_xml, **kwargs): 7159 """ 7160 Uploads a branding resource file. 7161 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. 7162 This method makes a synchronous HTTP request by default. To make an 7163 asynchronous HTTP request, please define a `callback` function 7164 to be invoked when receiving the response. 7165 >>> def callback_function(response): 7166 >>> pprint(response) 7167 >>> 7168 >>> thread = api.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, callback=callback_function) 7169 7170 :param callback function: The callback function 7171 for asynchronous request. (optional) 7172 :param str account_id: The external account number (int) or account ID GUID. (required) 7173 :param str brand_id: The ID of the brand. (required) 7174 :param str resource_content_type: The type of brand resource file that you are updating. Valid values are: - `sending` - `signing` - `email` - `signing_captive` (required) 7175 :param file file_xml: Brand resource XML file. (required) 7176 :return: BrandResources 7177 If the method is called asynchronously, 7178 returns the request thread. 7179 """ 7180 7181 all_params = ['account_id', 'brand_id', 'resource_content_type', 'file_xml'] 7182 all_params.append('callback') 7183 all_params.append('_return_http_data_only') 7184 all_params.append('_preload_content') 7185 all_params.append('_request_timeout') 7186 7187 params = locals() 7188 for key, val in iteritems(params['kwargs']): 7189 if key not in all_params: 7190 raise TypeError( 7191 "Got an unexpected keyword argument '%s'" 7192 " to method update_brand_resources_by_content_type" % key 7193 ) 7194 params[key] = val 7195 del params['kwargs'] 7196 # verify the required parameter 'account_id' is set 7197 if ('account_id' not in params) or (params['account_id'] is None): 7198 raise ValueError("Missing the required parameter `account_id` when calling `update_brand_resources_by_content_type`") 7199 # verify the required parameter 'brand_id' is set 7200 if ('brand_id' not in params) or (params['brand_id'] is None): 7201 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_resources_by_content_type`") 7202 # verify the required parameter 'resource_content_type' is set 7203 if ('resource_content_type' not in params) or (params['resource_content_type'] is None): 7204 raise ValueError("Missing the required parameter `resource_content_type` when calling `update_brand_resources_by_content_type`") 7205 # verify the required parameter 'file_xml' is set 7206 if ('file_xml' not in params) or (params['file_xml'] is None): 7207 raise ValueError("Missing the required parameter `file_xml` when calling `update_brand_resources_by_content_type`") 7208 7209 7210 collection_formats = {} 7211 7212 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources/{resourceContentType}'.replace('{format}', 'json') 7213 path_params = {} 7214 if 'account_id' in params: 7215 path_params['accountId'] = params['account_id'] 7216 if 'brand_id' in params: 7217 path_params['brandId'] = params['brand_id'] 7218 if 'resource_content_type' in params: 7219 path_params['resourceContentType'] = params['resource_content_type'] 7220 7221 query_params = {} 7222 7223 header_params = {} 7224 7225 form_params = [] 7226 local_var_files = {} 7227 if 'file_xml' in params: 7228 local_var_files['file.xml'] = params['file_xml'] 7229 7230 body_params = None 7231 # HTTP header `Accept` 7232 header_params['Accept'] = self.api_client.\ 7233 select_header_accept(['application/json']) 7234 7235 # HTTP header `Content-Type` 7236 header_params['Content-Type'] = self.api_client.\ 7237 select_header_content_type(['multipart/form-data']) 7238 7239 # Authentication setting 7240 auth_settings = [] 7241 7242 return self.api_client.call_api(resource_path, 'PUT', 7243 path_params, 7244 query_params, 7245 header_params, 7246 body=body_params, 7247 post_params=form_params, 7248 files=local_var_files, 7249 response_type='BrandResources', 7250 auth_settings=auth_settings, 7251 callback=params.get('callback'), 7252 _return_http_data_only=params.get('_return_http_data_only'), 7253 _preload_content=params.get('_preload_content', True), 7254 _request_timeout=params.get('_request_timeout'), 7255 collection_formats=collection_formats) 7256 7257 def update_consumer_disclosure(self, account_id, lang_code, **kwargs): 7258 """ 7259 Update Consumer Disclosure. 7260 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. 7261 This method makes a synchronous HTTP request by default. To make an 7262 asynchronous HTTP request, please define a `callback` function 7263 to be invoked when receiving the response. 7264 >>> def callback_function(response): 7265 >>> pprint(response) 7266 >>> 7267 >>> thread = api.update_consumer_disclosure(account_id, lang_code, callback=callback_function) 7268 7269 :param callback function: The callback function 7270 for asynchronous request. (optional) 7271 :param str account_id: The external account number (int) or account ID Guid. (required) 7272 :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) 7273 :param str include_metadata: 7274 :param ConsumerDisclosure consumer_disclosure: 7275 :return: ConsumerDisclosure 7276 If the method is called asynchronously, 7277 returns the request thread. 7278 """ 7279 kwargs['_return_http_data_only'] = True 7280 if kwargs.get('callback'): 7281 return self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 7282 else: 7283 (data) = self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 7284 return data 7285 7286 def update_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs): 7287 """ 7288 Update Consumer Disclosure. 7289 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. 7290 This method makes a synchronous HTTP request by default. To make an 7291 asynchronous HTTP request, please define a `callback` function 7292 to be invoked when receiving the response. 7293 >>> def callback_function(response): 7294 >>> pprint(response) 7295 >>> 7296 >>> thread = api.update_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function) 7297 7298 :param callback function: The callback function 7299 for asynchronous request. (optional) 7300 :param str account_id: The external account number (int) or account ID Guid. (required) 7301 :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) 7302 :param str include_metadata: 7303 :param ConsumerDisclosure consumer_disclosure: 7304 :return: ConsumerDisclosure 7305 If the method is called asynchronously, 7306 returns the request thread. 7307 """ 7308 7309 all_params = ['account_id', 'lang_code', 'include_metadata', 'consumer_disclosure'] 7310 all_params.append('callback') 7311 all_params.append('_return_http_data_only') 7312 all_params.append('_preload_content') 7313 all_params.append('_request_timeout') 7314 7315 params = locals() 7316 for key, val in iteritems(params['kwargs']): 7317 if key not in all_params: 7318 raise TypeError( 7319 "Got an unexpected keyword argument '%s'" 7320 " to method update_consumer_disclosure" % key 7321 ) 7322 params[key] = val 7323 del params['kwargs'] 7324 # verify the required parameter 'account_id' is set 7325 if ('account_id' not in params) or (params['account_id'] is None): 7326 raise ValueError("Missing the required parameter `account_id` when calling `update_consumer_disclosure`") 7327 # verify the required parameter 'lang_code' is set 7328 if ('lang_code' not in params) or (params['lang_code'] is None): 7329 raise ValueError("Missing the required parameter `lang_code` when calling `update_consumer_disclosure`") 7330 7331 7332 collection_formats = {} 7333 7334 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 7335 path_params = {} 7336 if 'account_id' in params: 7337 path_params['accountId'] = params['account_id'] 7338 if 'lang_code' in params: 7339 path_params['langCode'] = params['lang_code'] 7340 7341 query_params = {} 7342 if 'include_metadata' in params: 7343 query_params['include_metadata'] = params['include_metadata'] 7344 7345 header_params = {} 7346 7347 form_params = [] 7348 local_var_files = {} 7349 7350 body_params = None 7351 if 'consumer_disclosure' in params: 7352 body_params = params['consumer_disclosure'] 7353 # HTTP header `Accept` 7354 header_params['Accept'] = self.api_client.\ 7355 select_header_accept(['application/json']) 7356 7357 # Authentication setting 7358 auth_settings = [] 7359 7360 return self.api_client.call_api(resource_path, 'PUT', 7361 path_params, 7362 query_params, 7363 header_params, 7364 body=body_params, 7365 post_params=form_params, 7366 files=local_var_files, 7367 response_type='ConsumerDisclosure', 7368 auth_settings=auth_settings, 7369 callback=params.get('callback'), 7370 _return_http_data_only=params.get('_return_http_data_only'), 7371 _preload_content=params.get('_preload_content', True), 7372 _request_timeout=params.get('_request_timeout'), 7373 collection_formats=collection_formats) 7374 7375 def update_custom_field(self, account_id, custom_field_id, **kwargs): 7376 """ 7377 Updates an existing account custom field. 7378 This method updates an existing account custom field. 7379 This method makes a synchronous HTTP request by default. To make an 7380 asynchronous HTTP request, please define a `callback` function 7381 to be invoked when receiving the response. 7382 >>> def callback_function(response): 7383 >>> pprint(response) 7384 >>> 7385 >>> thread = api.update_custom_field(account_id, custom_field_id, callback=callback_function) 7386 7387 :param callback function: The callback function 7388 for asynchronous request. (optional) 7389 :param str account_id: The external account number (int) or account ID Guid. (required) 7390 :param str custom_field_id: (required) 7391 :param str apply_to_templates: 7392 :param CustomField custom_field: 7393 :return: CustomFields 7394 If the method is called asynchronously, 7395 returns the request thread. 7396 """ 7397 kwargs['_return_http_data_only'] = True 7398 if kwargs.get('callback'): 7399 return self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 7400 else: 7401 (data) = self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 7402 return data 7403 7404 def update_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs): 7405 """ 7406 Updates an existing account custom field. 7407 This method updates an existing account custom field. 7408 This method makes a synchronous HTTP request by default. To make an 7409 asynchronous HTTP request, please define a `callback` function 7410 to be invoked when receiving the response. 7411 >>> def callback_function(response): 7412 >>> pprint(response) 7413 >>> 7414 >>> thread = api.update_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function) 7415 7416 :param callback function: The callback function 7417 for asynchronous request. (optional) 7418 :param str account_id: The external account number (int) or account ID Guid. (required) 7419 :param str custom_field_id: (required) 7420 :param str apply_to_templates: 7421 :param CustomField custom_field: 7422 :return: CustomFields 7423 If the method is called asynchronously, 7424 returns the request thread. 7425 """ 7426 7427 all_params = ['account_id', 'custom_field_id', 'apply_to_templates', 'custom_field'] 7428 all_params.append('callback') 7429 all_params.append('_return_http_data_only') 7430 all_params.append('_preload_content') 7431 all_params.append('_request_timeout') 7432 7433 params = locals() 7434 for key, val in iteritems(params['kwargs']): 7435 if key not in all_params: 7436 raise TypeError( 7437 "Got an unexpected keyword argument '%s'" 7438 " to method update_custom_field" % key 7439 ) 7440 params[key] = val 7441 del params['kwargs'] 7442 # verify the required parameter 'account_id' is set 7443 if ('account_id' not in params) or (params['account_id'] is None): 7444 raise ValueError("Missing the required parameter `account_id` when calling `update_custom_field`") 7445 # verify the required parameter 'custom_field_id' is set 7446 if ('custom_field_id' not in params) or (params['custom_field_id'] is None): 7447 raise ValueError("Missing the required parameter `custom_field_id` when calling `update_custom_field`") 7448 7449 7450 collection_formats = {} 7451 7452 resource_path = '/v2.1/accounts/{accountId}/custom_fields/{customFieldId}'.replace('{format}', 'json') 7453 path_params = {} 7454 if 'account_id' in params: 7455 path_params['accountId'] = params['account_id'] 7456 if 'custom_field_id' in params: 7457 path_params['customFieldId'] = params['custom_field_id'] 7458 7459 query_params = {} 7460 if 'apply_to_templates' in params: 7461 query_params['apply_to_templates'] = params['apply_to_templates'] 7462 7463 header_params = {} 7464 7465 form_params = [] 7466 local_var_files = {} 7467 7468 body_params = None 7469 if 'custom_field' in params: 7470 body_params = params['custom_field'] 7471 # HTTP header `Accept` 7472 header_params['Accept'] = self.api_client.\ 7473 select_header_accept(['application/json']) 7474 7475 # Authentication setting 7476 auth_settings = [] 7477 7478 return self.api_client.call_api(resource_path, 'PUT', 7479 path_params, 7480 query_params, 7481 header_params, 7482 body=body_params, 7483 post_params=form_params, 7484 files=local_var_files, 7485 response_type='CustomFields', 7486 auth_settings=auth_settings, 7487 callback=params.get('callback'), 7488 _return_http_data_only=params.get('_return_http_data_only'), 7489 _preload_content=params.get('_preload_content', True), 7490 _request_timeout=params.get('_request_timeout'), 7491 collection_formats=collection_formats) 7492 7493 def update_e_note_configuration(self, account_id, **kwargs): 7494 """ 7495 Updates configuration information for the eNote eOriginal integration. 7496 7497 This method makes a synchronous HTTP request by default. To make an 7498 asynchronous HTTP request, please define a `callback` function 7499 to be invoked when receiving the response. 7500 >>> def callback_function(response): 7501 >>> pprint(response) 7502 >>> 7503 >>> thread = api.update_e_note_configuration(account_id, callback=callback_function) 7504 7505 :param callback function: The callback function 7506 for asynchronous request. (optional) 7507 :param str account_id: The external account number (int) or account ID Guid. (required) 7508 :param ENoteConfiguration e_note_configuration: 7509 :return: ENoteConfiguration 7510 If the method is called asynchronously, 7511 returns the request thread. 7512 """ 7513 kwargs['_return_http_data_only'] = True 7514 if kwargs.get('callback'): 7515 return self.update_e_note_configuration_with_http_info(account_id, **kwargs) 7516 else: 7517 (data) = self.update_e_note_configuration_with_http_info(account_id, **kwargs) 7518 return data 7519 7520 def update_e_note_configuration_with_http_info(self, account_id, **kwargs): 7521 """ 7522 Updates configuration information for the eNote eOriginal integration. 7523 7524 This method makes a synchronous HTTP request by default. To make an 7525 asynchronous HTTP request, please define a `callback` function 7526 to be invoked when receiving the response. 7527 >>> def callback_function(response): 7528 >>> pprint(response) 7529 >>> 7530 >>> thread = api.update_e_note_configuration_with_http_info(account_id, callback=callback_function) 7531 7532 :param callback function: The callback function 7533 for asynchronous request. (optional) 7534 :param str account_id: The external account number (int) or account ID Guid. (required) 7535 :param ENoteConfiguration e_note_configuration: 7536 :return: ENoteConfiguration 7537 If the method is called asynchronously, 7538 returns the request thread. 7539 """ 7540 7541 all_params = ['account_id', 'e_note_configuration'] 7542 all_params.append('callback') 7543 all_params.append('_return_http_data_only') 7544 all_params.append('_preload_content') 7545 all_params.append('_request_timeout') 7546 7547 params = locals() 7548 for key, val in iteritems(params['kwargs']): 7549 if key not in all_params: 7550 raise TypeError( 7551 "Got an unexpected keyword argument '%s'" 7552 " to method update_e_note_configuration" % key 7553 ) 7554 params[key] = val 7555 del params['kwargs'] 7556 # verify the required parameter 'account_id' is set 7557 if ('account_id' not in params) or (params['account_id'] is None): 7558 raise ValueError("Missing the required parameter `account_id` when calling `update_e_note_configuration`") 7559 7560 7561 collection_formats = {} 7562 7563 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 7564 path_params = {} 7565 if 'account_id' in params: 7566 path_params['accountId'] = params['account_id'] 7567 7568 query_params = {} 7569 7570 header_params = {} 7571 7572 form_params = [] 7573 local_var_files = {} 7574 7575 body_params = None 7576 if 'e_note_configuration' in params: 7577 body_params = params['e_note_configuration'] 7578 # HTTP header `Accept` 7579 header_params['Accept'] = self.api_client.\ 7580 select_header_accept(['application/json']) 7581 7582 # Authentication setting 7583 auth_settings = [] 7584 7585 return self.api_client.call_api(resource_path, 'PUT', 7586 path_params, 7587 query_params, 7588 header_params, 7589 body=body_params, 7590 post_params=form_params, 7591 files=local_var_files, 7592 response_type='ENoteConfiguration', 7593 auth_settings=auth_settings, 7594 callback=params.get('callback'), 7595 _return_http_data_only=params.get('_return_http_data_only'), 7596 _preload_content=params.get('_preload_content', True), 7597 _request_timeout=params.get('_request_timeout'), 7598 collection_formats=collection_formats) 7599 7600 def update_envelope_purge_configuration(self, account_id, **kwargs): 7601 """ 7602 Updates envelope purge configuration. 7603 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). 7604 This method makes a synchronous HTTP request by default. To make an 7605 asynchronous HTTP request, please define a `callback` function 7606 to be invoked when receiving the response. 7607 >>> def callback_function(response): 7608 >>> pprint(response) 7609 >>> 7610 >>> thread = api.update_envelope_purge_configuration(account_id, callback=callback_function) 7611 7612 :param callback function: The callback function 7613 for asynchronous request. (optional) 7614 :param str account_id: The external account number (int) or account ID Guid. (required) 7615 :param EnvelopePurgeConfiguration envelope_purge_configuration: 7616 :return: EnvelopePurgeConfiguration 7617 If the method is called asynchronously, 7618 returns the request thread. 7619 """ 7620 kwargs['_return_http_data_only'] = True 7621 if kwargs.get('callback'): 7622 return self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs) 7623 else: 7624 (data) = self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs) 7625 return data 7626 7627 def update_envelope_purge_configuration_with_http_info(self, account_id, **kwargs): 7628 """ 7629 Updates envelope purge configuration. 7630 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). 7631 This method makes a synchronous HTTP request by default. To make an 7632 asynchronous HTTP request, please define a `callback` function 7633 to be invoked when receiving the response. 7634 >>> def callback_function(response): 7635 >>> pprint(response) 7636 >>> 7637 >>> thread = api.update_envelope_purge_configuration_with_http_info(account_id, callback=callback_function) 7638 7639 :param callback function: The callback function 7640 for asynchronous request. (optional) 7641 :param str account_id: The external account number (int) or account ID Guid. (required) 7642 :param EnvelopePurgeConfiguration envelope_purge_configuration: 7643 :return: EnvelopePurgeConfiguration 7644 If the method is called asynchronously, 7645 returns the request thread. 7646 """ 7647 7648 all_params = ['account_id', 'envelope_purge_configuration'] 7649 all_params.append('callback') 7650 all_params.append('_return_http_data_only') 7651 all_params.append('_preload_content') 7652 all_params.append('_request_timeout') 7653 7654 params = locals() 7655 for key, val in iteritems(params['kwargs']): 7656 if key not in all_params: 7657 raise TypeError( 7658 "Got an unexpected keyword argument '%s'" 7659 " to method update_envelope_purge_configuration" % key 7660 ) 7661 params[key] = val 7662 del params['kwargs'] 7663 # verify the required parameter 'account_id' is set 7664 if ('account_id' not in params) or (params['account_id'] is None): 7665 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_purge_configuration`") 7666 7667 7668 collection_formats = {} 7669 7670 resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json') 7671 path_params = {} 7672 if 'account_id' in params: 7673 path_params['accountId'] = params['account_id'] 7674 7675 query_params = {} 7676 7677 header_params = {} 7678 7679 form_params = [] 7680 local_var_files = {} 7681 7682 body_params = None 7683 if 'envelope_purge_configuration' in params: 7684 body_params = params['envelope_purge_configuration'] 7685 # HTTP header `Accept` 7686 header_params['Accept'] = self.api_client.\ 7687 select_header_accept(['application/json']) 7688 7689 # Authentication setting 7690 auth_settings = [] 7691 7692 return self.api_client.call_api(resource_path, 'PUT', 7693 path_params, 7694 query_params, 7695 header_params, 7696 body=body_params, 7697 post_params=form_params, 7698 files=local_var_files, 7699 response_type='EnvelopePurgeConfiguration', 7700 auth_settings=auth_settings, 7701 callback=params.get('callback'), 7702 _return_http_data_only=params.get('_return_http_data_only'), 7703 _preload_content=params.get('_preload_content', True), 7704 _request_timeout=params.get('_request_timeout'), 7705 collection_formats=collection_formats) 7706 7707 def update_favorite_template(self, account_id, **kwargs): 7708 """ 7709 Favorites a template 7710 7711 This method makes a synchronous HTTP request by default. To make an 7712 asynchronous HTTP request, please define a `callback` function 7713 to be invoked when receiving the response. 7714 >>> def callback_function(response): 7715 >>> pprint(response) 7716 >>> 7717 >>> thread = api.update_favorite_template(account_id, callback=callback_function) 7718 7719 :param callback function: The callback function 7720 for asynchronous request. (optional) 7721 :param str account_id: The external account number (int) or account ID Guid. (required) 7722 :param FavoriteTemplatesInfo favorite_templates_info: 7723 :return: FavoriteTemplatesInfo 7724 If the method is called asynchronously, 7725 returns the request thread. 7726 """ 7727 kwargs['_return_http_data_only'] = True 7728 if kwargs.get('callback'): 7729 return self.update_favorite_template_with_http_info(account_id, **kwargs) 7730 else: 7731 (data) = self.update_favorite_template_with_http_info(account_id, **kwargs) 7732 return data 7733 7734 def update_favorite_template_with_http_info(self, account_id, **kwargs): 7735 """ 7736 Favorites a template 7737 7738 This method makes a synchronous HTTP request by default. To make an 7739 asynchronous HTTP request, please define a `callback` function 7740 to be invoked when receiving the response. 7741 >>> def callback_function(response): 7742 >>> pprint(response) 7743 >>> 7744 >>> thread = api.update_favorite_template_with_http_info(account_id, callback=callback_function) 7745 7746 :param callback function: The callback function 7747 for asynchronous request. (optional) 7748 :param str account_id: The external account number (int) or account ID Guid. (required) 7749 :param FavoriteTemplatesInfo favorite_templates_info: 7750 :return: FavoriteTemplatesInfo 7751 If the method is called asynchronously, 7752 returns the request thread. 7753 """ 7754 7755 all_params = ['account_id', 'favorite_templates_info'] 7756 all_params.append('callback') 7757 all_params.append('_return_http_data_only') 7758 all_params.append('_preload_content') 7759 all_params.append('_request_timeout') 7760 7761 params = locals() 7762 for key, val in iteritems(params['kwargs']): 7763 if key not in all_params: 7764 raise TypeError( 7765 "Got an unexpected keyword argument '%s'" 7766 " to method update_favorite_template" % key 7767 ) 7768 params[key] = val 7769 del params['kwargs'] 7770 # verify the required parameter 'account_id' is set 7771 if ('account_id' not in params) or (params['account_id'] is None): 7772 raise ValueError("Missing the required parameter `account_id` when calling `update_favorite_template`") 7773 7774 7775 collection_formats = {} 7776 7777 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 7778 path_params = {} 7779 if 'account_id' in params: 7780 path_params['accountId'] = params['account_id'] 7781 7782 query_params = {} 7783 7784 header_params = {} 7785 7786 form_params = [] 7787 local_var_files = {} 7788 7789 body_params = None 7790 if 'favorite_templates_info' in params: 7791 body_params = params['favorite_templates_info'] 7792 # HTTP header `Accept` 7793 header_params['Accept'] = self.api_client.\ 7794 select_header_accept(['application/json']) 7795 7796 # Authentication setting 7797 auth_settings = [] 7798 7799 return self.api_client.call_api(resource_path, 'PUT', 7800 path_params, 7801 query_params, 7802 header_params, 7803 body=body_params, 7804 post_params=form_params, 7805 files=local_var_files, 7806 response_type='FavoriteTemplatesInfo', 7807 auth_settings=auth_settings, 7808 callback=params.get('callback'), 7809 _return_http_data_only=params.get('_return_http_data_only'), 7810 _preload_content=params.get('_preload_content', True), 7811 _request_timeout=params.get('_request_timeout'), 7812 collection_formats=collection_formats) 7813 7814 def update_notification_defaults(self, account_id, **kwargs): 7815 """ 7816 Updates default user level settings for a specified account 7817 This method changes the default settings for the email notifications that signers and senders receive about envelopes. 7818 This method makes a synchronous HTTP request by default. To make an 7819 asynchronous HTTP request, please define a `callback` function 7820 to be invoked when receiving the response. 7821 >>> def callback_function(response): 7822 >>> pprint(response) 7823 >>> 7824 >>> thread = api.update_notification_defaults(account_id, callback=callback_function) 7825 7826 :param callback function: The callback function 7827 for asynchronous request. (optional) 7828 :param str account_id: The external account number (int) or account ID Guid. (required) 7829 :param NotificationDefaults notification_defaults: 7830 :return: NotificationDefaults 7831 If the method is called asynchronously, 7832 returns the request thread. 7833 """ 7834 kwargs['_return_http_data_only'] = True 7835 if kwargs.get('callback'): 7836 return self.update_notification_defaults_with_http_info(account_id, **kwargs) 7837 else: 7838 (data) = self.update_notification_defaults_with_http_info(account_id, **kwargs) 7839 return data 7840 7841 def update_notification_defaults_with_http_info(self, account_id, **kwargs): 7842 """ 7843 Updates default user level settings for a specified account 7844 This method changes the default settings for the email notifications that signers and senders receive about envelopes. 7845 This method makes a synchronous HTTP request by default. To make an 7846 asynchronous HTTP request, please define a `callback` function 7847 to be invoked when receiving the response. 7848 >>> def callback_function(response): 7849 >>> pprint(response) 7850 >>> 7851 >>> thread = api.update_notification_defaults_with_http_info(account_id, callback=callback_function) 7852 7853 :param callback function: The callback function 7854 for asynchronous request. (optional) 7855 :param str account_id: The external account number (int) or account ID Guid. (required) 7856 :param NotificationDefaults notification_defaults: 7857 :return: NotificationDefaults 7858 If the method is called asynchronously, 7859 returns the request thread. 7860 """ 7861 7862 all_params = ['account_id', 'notification_defaults'] 7863 all_params.append('callback') 7864 all_params.append('_return_http_data_only') 7865 all_params.append('_preload_content') 7866 all_params.append('_request_timeout') 7867 7868 params = locals() 7869 for key, val in iteritems(params['kwargs']): 7870 if key not in all_params: 7871 raise TypeError( 7872 "Got an unexpected keyword argument '%s'" 7873 " to method update_notification_defaults" % key 7874 ) 7875 params[key] = val 7876 del params['kwargs'] 7877 # verify the required parameter 'account_id' is set 7878 if ('account_id' not in params) or (params['account_id'] is None): 7879 raise ValueError("Missing the required parameter `account_id` when calling `update_notification_defaults`") 7880 7881 7882 collection_formats = {} 7883 7884 resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json') 7885 path_params = {} 7886 if 'account_id' in params: 7887 path_params['accountId'] = params['account_id'] 7888 7889 query_params = {} 7890 7891 header_params = {} 7892 7893 form_params = [] 7894 local_var_files = {} 7895 7896 body_params = None 7897 if 'notification_defaults' in params: 7898 body_params = params['notification_defaults'] 7899 # HTTP header `Accept` 7900 header_params['Accept'] = self.api_client.\ 7901 select_header_accept(['application/json']) 7902 7903 # Authentication setting 7904 auth_settings = [] 7905 7906 return self.api_client.call_api(resource_path, 'PUT', 7907 path_params, 7908 query_params, 7909 header_params, 7910 body=body_params, 7911 post_params=form_params, 7912 files=local_var_files, 7913 response_type='NotificationDefaults', 7914 auth_settings=auth_settings, 7915 callback=params.get('callback'), 7916 _return_http_data_only=params.get('_return_http_data_only'), 7917 _preload_content=params.get('_preload_content', True), 7918 _request_timeout=params.get('_request_timeout'), 7919 collection_formats=collection_formats) 7920 7921 def update_password_rules(self, account_id, **kwargs): 7922 """ 7923 Update the password rules 7924 This method updates the password rules for an account. **Note:** To update the password rules for an account, you must be an account administrator. 7925 This method makes a synchronous HTTP request by default. To make an 7926 asynchronous HTTP request, please define a `callback` function 7927 to be invoked when receiving the response. 7928 >>> def callback_function(response): 7929 >>> pprint(response) 7930 >>> 7931 >>> thread = api.update_password_rules(account_id, callback=callback_function) 7932 7933 :param callback function: The callback function 7934 for asynchronous request. (optional) 7935 :param str account_id: The external account number (int) or account ID Guid. (required) 7936 :param AccountPasswordRules account_password_rules: 7937 :return: AccountPasswordRules 7938 If the method is called asynchronously, 7939 returns the request thread. 7940 """ 7941 kwargs['_return_http_data_only'] = True 7942 if kwargs.get('callback'): 7943 return self.update_password_rules_with_http_info(account_id, **kwargs) 7944 else: 7945 (data) = self.update_password_rules_with_http_info(account_id, **kwargs) 7946 return data 7947 7948 def update_password_rules_with_http_info(self, account_id, **kwargs): 7949 """ 7950 Update the password rules 7951 This method updates the password rules for an account. **Note:** To update the password rules for an account, you must be an account administrator. 7952 This method makes a synchronous HTTP request by default. To make an 7953 asynchronous HTTP request, please define a `callback` function 7954 to be invoked when receiving the response. 7955 >>> def callback_function(response): 7956 >>> pprint(response) 7957 >>> 7958 >>> thread = api.update_password_rules_with_http_info(account_id, callback=callback_function) 7959 7960 :param callback function: The callback function 7961 for asynchronous request. (optional) 7962 :param str account_id: The external account number (int) or account ID Guid. (required) 7963 :param AccountPasswordRules account_password_rules: 7964 :return: AccountPasswordRules 7965 If the method is called asynchronously, 7966 returns the request thread. 7967 """ 7968 7969 all_params = ['account_id', 'account_password_rules'] 7970 all_params.append('callback') 7971 all_params.append('_return_http_data_only') 7972 all_params.append('_preload_content') 7973 all_params.append('_request_timeout') 7974 7975 params = locals() 7976 for key, val in iteritems(params['kwargs']): 7977 if key not in all_params: 7978 raise TypeError( 7979 "Got an unexpected keyword argument '%s'" 7980 " to method update_password_rules" % key 7981 ) 7982 params[key] = val 7983 del params['kwargs'] 7984 # verify the required parameter 'account_id' is set 7985 if ('account_id' not in params) or (params['account_id'] is None): 7986 raise ValueError("Missing the required parameter `account_id` when calling `update_password_rules`") 7987 7988 7989 collection_formats = {} 7990 7991 resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json') 7992 path_params = {} 7993 if 'account_id' in params: 7994 path_params['accountId'] = params['account_id'] 7995 7996 query_params = {} 7997 7998 header_params = {} 7999 8000 form_params = [] 8001 local_var_files = {} 8002 8003 body_params = None 8004 if 'account_password_rules' in params: 8005 body_params = params['account_password_rules'] 8006 # HTTP header `Accept` 8007 header_params['Accept'] = self.api_client.\ 8008 select_header_accept(['application/json']) 8009 8010 # Authentication setting 8011 auth_settings = [] 8012 8013 return self.api_client.call_api(resource_path, 'PUT', 8014 path_params, 8015 query_params, 8016 header_params, 8017 body=body_params, 8018 post_params=form_params, 8019 files=local_var_files, 8020 response_type='AccountPasswordRules', 8021 auth_settings=auth_settings, 8022 callback=params.get('callback'), 8023 _return_http_data_only=params.get('_return_http_data_only'), 8024 _preload_content=params.get('_preload_content', True), 8025 _request_timeout=params.get('_request_timeout'), 8026 collection_formats=collection_formats) 8027 8028 def update_permission_profile(self, account_id, permission_profile_id, **kwargs): 8029 """ 8030 Updates a permission profile within the specified account. 8031 This method updates an account permission profile. ### Related topics - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 8032 This method makes a synchronous HTTP request by default. To make an 8033 asynchronous HTTP request, please define a `callback` function 8034 to be invoked when receiving the response. 8035 >>> def callback_function(response): 8036 >>> pprint(response) 8037 >>> 8038 >>> thread = api.update_permission_profile(account_id, permission_profile_id, callback=callback_function) 8039 8040 :param callback function: The callback function 8041 for asynchronous request. (optional) 8042 :param str account_id: The external account number (int) or account ID Guid. (required) 8043 :param str permission_profile_id: (required) 8044 :param str include: 8045 :param PermissionProfile permission_profile: 8046 :return: PermissionProfile 8047 If the method is called asynchronously, 8048 returns the request thread. 8049 """ 8050 kwargs['_return_http_data_only'] = True 8051 if kwargs.get('callback'): 8052 return self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 8053 else: 8054 (data) = self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 8055 return data 8056 8057 def update_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 8058 """ 8059 Updates a permission profile within the specified account. 8060 This method updates an account permission profile. ### Related topics - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 8061 This method makes a synchronous HTTP request by default. To make an 8062 asynchronous HTTP request, please define a `callback` function 8063 to be invoked when receiving the response. 8064 >>> def callback_function(response): 8065 >>> pprint(response) 8066 >>> 8067 >>> thread = api.update_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 8068 8069 :param callback function: The callback function 8070 for asynchronous request. (optional) 8071 :param str account_id: The external account number (int) or account ID Guid. (required) 8072 :param str permission_profile_id: (required) 8073 :param str include: 8074 :param PermissionProfile permission_profile: 8075 :return: PermissionProfile 8076 If the method is called asynchronously, 8077 returns the request thread. 8078 """ 8079 8080 all_params = ['account_id', 'permission_profile_id', 'include', 'permission_profile'] 8081 all_params.append('callback') 8082 all_params.append('_return_http_data_only') 8083 all_params.append('_preload_content') 8084 all_params.append('_request_timeout') 8085 8086 params = locals() 8087 for key, val in iteritems(params['kwargs']): 8088 if key not in all_params: 8089 raise TypeError( 8090 "Got an unexpected keyword argument '%s'" 8091 " to method update_permission_profile" % key 8092 ) 8093 params[key] = val 8094 del params['kwargs'] 8095 # verify the required parameter 'account_id' is set 8096 if ('account_id' not in params) or (params['account_id'] is None): 8097 raise ValueError("Missing the required parameter `account_id` when calling `update_permission_profile`") 8098 # verify the required parameter 'permission_profile_id' is set 8099 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 8100 raise ValueError("Missing the required parameter `permission_profile_id` when calling `update_permission_profile`") 8101 8102 8103 collection_formats = {} 8104 8105 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 8106 path_params = {} 8107 if 'account_id' in params: 8108 path_params['accountId'] = params['account_id'] 8109 if 'permission_profile_id' in params: 8110 path_params['permissionProfileId'] = params['permission_profile_id'] 8111 8112 query_params = {} 8113 if 'include' in params: 8114 query_params['include'] = params['include'] 8115 8116 header_params = {} 8117 8118 form_params = [] 8119 local_var_files = {} 8120 8121 body_params = None 8122 if 'permission_profile' in params: 8123 body_params = params['permission_profile'] 8124 # HTTP header `Accept` 8125 header_params['Accept'] = self.api_client.\ 8126 select_header_accept(['application/json']) 8127 8128 # Authentication setting 8129 auth_settings = [] 8130 8131 return self.api_client.call_api(resource_path, 'PUT', 8132 path_params, 8133 query_params, 8134 header_params, 8135 body=body_params, 8136 post_params=form_params, 8137 files=local_var_files, 8138 response_type='PermissionProfile', 8139 auth_settings=auth_settings, 8140 callback=params.get('callback'), 8141 _return_http_data_only=params.get('_return_http_data_only'), 8142 _preload_content=params.get('_preload_content', True), 8143 _request_timeout=params.get('_request_timeout'), 8144 collection_formats=collection_formats) 8145 8146 def update_settings(self, account_id, **kwargs): 8147 """ 8148 Updates the account settings for an account. 8149 Updates the account settings for the specified account. 8150 This method makes a synchronous HTTP request by default. To make an 8151 asynchronous HTTP request, please define a `callback` function 8152 to be invoked when receiving the response. 8153 >>> def callback_function(response): 8154 >>> pprint(response) 8155 >>> 8156 >>> thread = api.update_settings(account_id, callback=callback_function) 8157 8158 :param callback function: The callback function 8159 for asynchronous request. (optional) 8160 :param str account_id: The external account number (int) or account ID Guid. (required) 8161 :param AccountSettingsInformation account_settings_information: 8162 :return: None 8163 If the method is called asynchronously, 8164 returns the request thread. 8165 """ 8166 kwargs['_return_http_data_only'] = True 8167 if kwargs.get('callback'): 8168 return self.update_settings_with_http_info(account_id, **kwargs) 8169 else: 8170 (data) = self.update_settings_with_http_info(account_id, **kwargs) 8171 return data 8172 8173 def update_settings_with_http_info(self, account_id, **kwargs): 8174 """ 8175 Updates the account settings for an account. 8176 Updates the account settings for the specified account. 8177 This method makes a synchronous HTTP request by default. To make an 8178 asynchronous HTTP request, please define a `callback` function 8179 to be invoked when receiving the response. 8180 >>> def callback_function(response): 8181 >>> pprint(response) 8182 >>> 8183 >>> thread = api.update_settings_with_http_info(account_id, callback=callback_function) 8184 8185 :param callback function: The callback function 8186 for asynchronous request. (optional) 8187 :param str account_id: The external account number (int) or account ID Guid. (required) 8188 :param AccountSettingsInformation account_settings_information: 8189 :return: None 8190 If the method is called asynchronously, 8191 returns the request thread. 8192 """ 8193 8194 all_params = ['account_id', 'account_settings_information'] 8195 all_params.append('callback') 8196 all_params.append('_return_http_data_only') 8197 all_params.append('_preload_content') 8198 all_params.append('_request_timeout') 8199 8200 params = locals() 8201 for key, val in iteritems(params['kwargs']): 8202 if key not in all_params: 8203 raise TypeError( 8204 "Got an unexpected keyword argument '%s'" 8205 " to method update_settings" % key 8206 ) 8207 params[key] = val 8208 del params['kwargs'] 8209 # verify the required parameter 'account_id' is set 8210 if ('account_id' not in params) or (params['account_id'] is None): 8211 raise ValueError("Missing the required parameter `account_id` when calling `update_settings`") 8212 8213 8214 collection_formats = {} 8215 8216 resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json') 8217 path_params = {} 8218 if 'account_id' in params: 8219 path_params['accountId'] = params['account_id'] 8220 8221 query_params = {} 8222 8223 header_params = {} 8224 8225 form_params = [] 8226 local_var_files = {} 8227 8228 body_params = None 8229 if 'account_settings_information' in params: 8230 body_params = params['account_settings_information'] 8231 # HTTP header `Accept` 8232 header_params['Accept'] = self.api_client.\ 8233 select_header_accept(['application/json']) 8234 8235 # Authentication setting 8236 auth_settings = [] 8237 8238 return self.api_client.call_api(resource_path, 'PUT', 8239 path_params, 8240 query_params, 8241 header_params, 8242 body=body_params, 8243 post_params=form_params, 8244 files=local_var_files, 8245 response_type=None, 8246 auth_settings=auth_settings, 8247 callback=params.get('callback'), 8248 _return_http_data_only=params.get('_return_http_data_only'), 8249 _preload_content=params.get('_preload_content', True), 8250 _request_timeout=params.get('_request_timeout'), 8251 collection_formats=collection_formats) 8252 8253 def update_shared_access(self, account_id, **kwargs): 8254 """ 8255 Reserved: Sets the shared access information for users. 8256 Reserved: Sets the shared access information for one or more users. 8257 This method makes a synchronous HTTP request by default. To make an 8258 asynchronous HTTP request, please define a `callback` function 8259 to be invoked when receiving the response. 8260 >>> def callback_function(response): 8261 >>> pprint(response) 8262 >>> 8263 >>> thread = api.update_shared_access(account_id, callback=callback_function) 8264 8265 :param callback function: The callback function 8266 for asynchronous request. (optional) 8267 :param str account_id: The external account number (int) or account ID Guid. (required) 8268 :param str item_type: 8269 :param str preserve_existing_shared_access: 8270 :param str user_ids: 8271 :param AccountSharedAccess account_shared_access: 8272 :return: AccountSharedAccess 8273 If the method is called asynchronously, 8274 returns the request thread. 8275 """ 8276 kwargs['_return_http_data_only'] = True 8277 if kwargs.get('callback'): 8278 return self.update_shared_access_with_http_info(account_id, **kwargs) 8279 else: 8280 (data) = self.update_shared_access_with_http_info(account_id, **kwargs) 8281 return data 8282 8283 def update_shared_access_with_http_info(self, account_id, **kwargs): 8284 """ 8285 Reserved: Sets the shared access information for users. 8286 Reserved: Sets the shared access information for one or more users. 8287 This method makes a synchronous HTTP request by default. To make an 8288 asynchronous HTTP request, please define a `callback` function 8289 to be invoked when receiving the response. 8290 >>> def callback_function(response): 8291 >>> pprint(response) 8292 >>> 8293 >>> thread = api.update_shared_access_with_http_info(account_id, callback=callback_function) 8294 8295 :param callback function: The callback function 8296 for asynchronous request. (optional) 8297 :param str account_id: The external account number (int) or account ID Guid. (required) 8298 :param str item_type: 8299 :param str preserve_existing_shared_access: 8300 :param str user_ids: 8301 :param AccountSharedAccess account_shared_access: 8302 :return: AccountSharedAccess 8303 If the method is called asynchronously, 8304 returns the request thread. 8305 """ 8306 8307 all_params = ['account_id', 'item_type', 'preserve_existing_shared_access', 'user_ids', 'account_shared_access'] 8308 all_params.append('callback') 8309 all_params.append('_return_http_data_only') 8310 all_params.append('_preload_content') 8311 all_params.append('_request_timeout') 8312 8313 params = locals() 8314 for key, val in iteritems(params['kwargs']): 8315 if key not in all_params: 8316 raise TypeError( 8317 "Got an unexpected keyword argument '%s'" 8318 " to method update_shared_access" % key 8319 ) 8320 params[key] = val 8321 del params['kwargs'] 8322 # verify the required parameter 'account_id' is set 8323 if ('account_id' not in params) or (params['account_id'] is None): 8324 raise ValueError("Missing the required parameter `account_id` when calling `update_shared_access`") 8325 8326 8327 collection_formats = {} 8328 8329 resource_path = '/v2.1/accounts/{accountId}/shared_access'.replace('{format}', 'json') 8330 path_params = {} 8331 if 'account_id' in params: 8332 path_params['accountId'] = params['account_id'] 8333 8334 query_params = {} 8335 if 'item_type' in params: 8336 query_params['item_type'] = params['item_type'] 8337 if 'preserve_existing_shared_access' in params: 8338 query_params['preserve_existing_shared_access'] = params['preserve_existing_shared_access'] 8339 if 'user_ids' in params: 8340 query_params['user_ids'] = params['user_ids'] 8341 8342 header_params = {} 8343 8344 form_params = [] 8345 local_var_files = {} 8346 8347 body_params = None 8348 if 'account_shared_access' in params: 8349 body_params = params['account_shared_access'] 8350 # HTTP header `Accept` 8351 header_params['Accept'] = self.api_client.\ 8352 select_header_accept(['application/json']) 8353 8354 # Authentication setting 8355 auth_settings = [] 8356 8357 return self.api_client.call_api(resource_path, 'PUT', 8358 path_params, 8359 query_params, 8360 header_params, 8361 body=body_params, 8362 post_params=form_params, 8363 files=local_var_files, 8364 response_type='AccountSharedAccess', 8365 auth_settings=auth_settings, 8366 callback=params.get('callback'), 8367 _return_http_data_only=params.get('_return_http_data_only'), 8368 _preload_content=params.get('_preload_content', True), 8369 _request_timeout=params.get('_request_timeout'), 8370 collection_formats=collection_formats) 8371 8372 def update_user_authorization(self, account_id, authorization_id, user_id, **kwargs): 8373 """ 8374 Updates the user authorization 8375 This method makes a synchronous HTTP request by default. To make an 8376 asynchronous HTTP request, please define a `callback` function 8377 to be invoked when receiving the response. 8378 >>> def callback_function(response): 8379 >>> pprint(response) 8380 >>> 8381 >>> thread = api.update_user_authorization(account_id, authorization_id, user_id, callback=callback_function) 8382 8383 :param callback function: The callback function 8384 for asynchronous request. (optional) 8385 :param str account_id: The external account number (int) or account ID Guid. (required) 8386 :param str authorization_id: (required) 8387 :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) 8388 :param UserAuthorizationUpdateRequest user_authorization_update_request: 8389 :return: UserAuthorization 8390 If the method is called asynchronously, 8391 returns the request thread. 8392 """ 8393 kwargs['_return_http_data_only'] = True 8394 if kwargs.get('callback'): 8395 return self.update_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 8396 else: 8397 (data) = self.update_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 8398 return data 8399 8400 def update_user_authorization_with_http_info(self, account_id, authorization_id, user_id, **kwargs): 8401 """ 8402 Updates the user authorization 8403 This method makes a synchronous HTTP request by default. To make an 8404 asynchronous HTTP request, please define a `callback` function 8405 to be invoked when receiving the response. 8406 >>> def callback_function(response): 8407 >>> pprint(response) 8408 >>> 8409 >>> thread = api.update_user_authorization_with_http_info(account_id, authorization_id, user_id, callback=callback_function) 8410 8411 :param callback function: The callback function 8412 for asynchronous request. (optional) 8413 :param str account_id: The external account number (int) or account ID Guid. (required) 8414 :param str authorization_id: (required) 8415 :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) 8416 :param UserAuthorizationUpdateRequest user_authorization_update_request: 8417 :return: UserAuthorization 8418 If the method is called asynchronously, 8419 returns the request thread. 8420 """ 8421 8422 all_params = ['account_id', 'authorization_id', 'user_id', 'user_authorization_update_request'] 8423 all_params.append('callback') 8424 all_params.append('_return_http_data_only') 8425 all_params.append('_preload_content') 8426 all_params.append('_request_timeout') 8427 8428 params = locals() 8429 for key, val in iteritems(params['kwargs']): 8430 if key not in all_params: 8431 raise TypeError( 8432 "Got an unexpected keyword argument '%s'" 8433 " to method update_user_authorization" % key 8434 ) 8435 params[key] = val 8436 del params['kwargs'] 8437 # verify the required parameter 'account_id' is set 8438 if ('account_id' not in params) or (params['account_id'] is None): 8439 raise ValueError("Missing the required parameter `account_id` when calling `update_user_authorization`") 8440 # verify the required parameter 'authorization_id' is set 8441 if ('authorization_id' not in params) or (params['authorization_id'] is None): 8442 raise ValueError("Missing the required parameter `authorization_id` when calling `update_user_authorization`") 8443 # verify the required parameter 'user_id' is set 8444 if ('user_id' not in params) or (params['user_id'] is None): 8445 raise ValueError("Missing the required parameter `user_id` when calling `update_user_authorization`") 8446 8447 8448 collection_formats = {} 8449 8450 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorization/{authorizationId}'.replace('{format}', 'json') 8451 path_params = {} 8452 if 'account_id' in params: 8453 path_params['accountId'] = params['account_id'] 8454 if 'authorization_id' in params: 8455 path_params['authorizationId'] = params['authorization_id'] 8456 if 'user_id' in params: 8457 path_params['userId'] = params['user_id'] 8458 8459 query_params = {} 8460 8461 header_params = {} 8462 8463 form_params = [] 8464 local_var_files = {} 8465 8466 body_params = None 8467 if 'user_authorization_update_request' in params: 8468 body_params = params['user_authorization_update_request'] 8469 # HTTP header `Accept` 8470 header_params['Accept'] = self.api_client.\ 8471 select_header_accept(['application/json']) 8472 8473 # Authentication setting 8474 auth_settings = [] 8475 8476 return self.api_client.call_api(resource_path, 'PUT', 8477 path_params, 8478 query_params, 8479 header_params, 8480 body=body_params, 8481 post_params=form_params, 8482 files=local_var_files, 8483 response_type='UserAuthorization', 8484 auth_settings=auth_settings, 8485 callback=params.get('callback'), 8486 _return_http_data_only=params.get('_return_http_data_only'), 8487 _preload_content=params.get('_preload_content', True), 8488 _request_timeout=params.get('_request_timeout'), 8489 collection_formats=collection_formats) 8490 8491 def update_watermark(self, account_id, **kwargs): 8492 """ 8493 Update watermark information. 8494 8495 This method makes a synchronous HTTP request by default. To make an 8496 asynchronous HTTP request, please define a `callback` function 8497 to be invoked when receiving the response. 8498 >>> def callback_function(response): 8499 >>> pprint(response) 8500 >>> 8501 >>> thread = api.update_watermark(account_id, callback=callback_function) 8502 8503 :param callback function: The callback function 8504 for asynchronous request. (optional) 8505 :param str account_id: The external account number (int) or account ID Guid. (required) 8506 :param Watermark watermark: 8507 :return: Watermark 8508 If the method is called asynchronously, 8509 returns the request thread. 8510 """ 8511 kwargs['_return_http_data_only'] = True 8512 if kwargs.get('callback'): 8513 return self.update_watermark_with_http_info(account_id, **kwargs) 8514 else: 8515 (data) = self.update_watermark_with_http_info(account_id, **kwargs) 8516 return data 8517 8518 def update_watermark_with_http_info(self, account_id, **kwargs): 8519 """ 8520 Update watermark information. 8521 8522 This method makes a synchronous HTTP request by default. To make an 8523 asynchronous HTTP request, please define a `callback` function 8524 to be invoked when receiving the response. 8525 >>> def callback_function(response): 8526 >>> pprint(response) 8527 >>> 8528 >>> thread = api.update_watermark_with_http_info(account_id, callback=callback_function) 8529 8530 :param callback function: The callback function 8531 for asynchronous request. (optional) 8532 :param str account_id: The external account number (int) or account ID Guid. (required) 8533 :param Watermark watermark: 8534 :return: Watermark 8535 If the method is called asynchronously, 8536 returns the request thread. 8537 """ 8538 8539 all_params = ['account_id', 'watermark'] 8540 all_params.append('callback') 8541 all_params.append('_return_http_data_only') 8542 all_params.append('_preload_content') 8543 all_params.append('_request_timeout') 8544 8545 params = locals() 8546 for key, val in iteritems(params['kwargs']): 8547 if key not in all_params: 8548 raise TypeError( 8549 "Got an unexpected keyword argument '%s'" 8550 " to method update_watermark" % key 8551 ) 8552 params[key] = val 8553 del params['kwargs'] 8554 # verify the required parameter 'account_id' is set 8555 if ('account_id' not in params) or (params['account_id'] is None): 8556 raise ValueError("Missing the required parameter `account_id` when calling `update_watermark`") 8557 8558 8559 collection_formats = {} 8560 8561 resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json') 8562 path_params = {} 8563 if 'account_id' in params: 8564 path_params['accountId'] = params['account_id'] 8565 8566 query_params = {} 8567 8568 header_params = {} 8569 8570 form_params = [] 8571 local_var_files = {} 8572 8573 body_params = None 8574 if 'watermark' in params: 8575 body_params = params['watermark'] 8576 # HTTP header `Accept` 8577 header_params['Accept'] = self.api_client.\ 8578 select_header_accept(['application/json']) 8579 8580 # Authentication setting 8581 auth_settings = [] 8582 8583 return self.api_client.call_api(resource_path, 'PUT', 8584 path_params, 8585 query_params, 8586 header_params, 8587 body=body_params, 8588 post_params=form_params, 8589 files=local_var_files, 8590 response_type='Watermark', 8591 auth_settings=auth_settings, 8592 callback=params.get('callback'), 8593 _return_http_data_only=params.get('_return_http_data_only'), 8594 _preload_content=params.get('_preload_content', True), 8595 _request_timeout=params.get('_request_timeout'), 8596 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_completion_rate_for_template(self, account_id, template_id, **kwargs)
3745 def get_completion_rate_for_template(self, account_id, template_id, **kwargs): 3746 """ 3747 Gets completion rate for the template 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_completion_rate_for_template(account_id, template_id, 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 template_id: The ID of the template being accessed. (required) 3760 :return: TemplateCompletionRateResponse 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_completion_rate_for_template_with_http_info(account_id, template_id, **kwargs) 3767 else: 3768 (data) = self.get_completion_rate_for_template_with_http_info(account_id, template_id, **kwargs) 3769 return data
Gets completion rate for the 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.get_completion_rate_for_template(account_id, template_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str template_id: The ID of the template being accessed. (required)
Returns
TemplateCompletionRateResponse If the method is called asynchronously, returns the request thread.
def
get_completion_rate_for_template_with_http_info(self, account_id, template_id, **kwargs)
3771 def get_completion_rate_for_template_with_http_info(self, account_id, template_id, **kwargs): 3772 """ 3773 Gets completion rate for the template 3774 This method makes a synchronous HTTP request by default. To make an 3775 asynchronous HTTP request, please define a `callback` function 3776 to be invoked when receiving the response. 3777 >>> def callback_function(response): 3778 >>> pprint(response) 3779 >>> 3780 >>> thread = api.get_completion_rate_for_template_with_http_info(account_id, template_id, callback=callback_function) 3781 3782 :param callback function: The callback function 3783 for asynchronous request. (optional) 3784 :param str account_id: The external account number (int) or account ID Guid. (required) 3785 :param str template_id: The ID of the template being accessed. (required) 3786 :return: TemplateCompletionRateResponse 3787 If the method is called asynchronously, 3788 returns the request thread. 3789 """ 3790 3791 all_params = ['account_id', 'template_id'] 3792 all_params.append('callback') 3793 all_params.append('_return_http_data_only') 3794 all_params.append('_preload_content') 3795 all_params.append('_request_timeout') 3796 3797 params = locals() 3798 for key, val in iteritems(params['kwargs']): 3799 if key not in all_params: 3800 raise TypeError( 3801 "Got an unexpected keyword argument '%s'" 3802 " to method get_completion_rate_for_template" % key 3803 ) 3804 params[key] = val 3805 del params['kwargs'] 3806 # verify the required parameter 'account_id' is set 3807 if ('account_id' not in params) or (params['account_id'] is None): 3808 raise ValueError("Missing the required parameter `account_id` when calling `get_completion_rate_for_template`") 3809 # verify the required parameter 'template_id' is set 3810 if ('template_id' not in params) or (params['template_id'] is None): 3811 raise ValueError("Missing the required parameter `template_id` when calling `get_completion_rate_for_template`") 3812 3813 3814 collection_formats = {} 3815 3816 resource_path = '/v2.1/accounts/{accountId}/templates/{templateId}/insights/completionRate'.replace('{format}', 'json') 3817 path_params = {} 3818 if 'account_id' in params: 3819 path_params['accountId'] = params['account_id'] 3820 if 'template_id' in params: 3821 path_params['templateId'] = params['template_id'] 3822 3823 query_params = {} 3824 3825 header_params = {} 3826 3827 form_params = [] 3828 local_var_files = {} 3829 3830 body_params = None 3831 # HTTP header `Accept` 3832 header_params['Accept'] = self.api_client.\ 3833 select_header_accept(['application/json']) 3834 3835 # Authentication setting 3836 auth_settings = [] 3837 3838 return self.api_client.call_api(resource_path, 'GET', 3839 path_params, 3840 query_params, 3841 header_params, 3842 body=body_params, 3843 post_params=form_params, 3844 files=local_var_files, 3845 response_type='TemplateCompletionRateResponse', 3846 auth_settings=auth_settings, 3847 callback=params.get('callback'), 3848 _return_http_data_only=params.get('_return_http_data_only'), 3849 _preload_content=params.get('_preload_content', True), 3850 _request_timeout=params.get('_request_timeout'), 3851 collection_formats=collection_formats)
Gets completion rate for the 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.get_completion_rate_for_template_with_http_info(account_id, template_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str template_id: The ID of the template being accessed. (required)
Returns
TemplateCompletionRateResponse If the method is called asynchronously, returns the request thread.
def
get_completion_rate_for_template_owner(self, account_id, **kwargs)
3853 def get_completion_rate_for_template_owner(self, account_id, **kwargs): 3854 """ 3855 Gets completion rate for the user 3856 This method makes a synchronous HTTP request by default. To make an 3857 asynchronous HTTP request, please define a `callback` function 3858 to be invoked when receiving the response. 3859 >>> def callback_function(response): 3860 >>> pprint(response) 3861 >>> 3862 >>> thread = api.get_completion_rate_for_template_owner(account_id, callback=callback_function) 3863 3864 :param callback function: The callback function 3865 for asynchronous request. (optional) 3866 :param str account_id: The external account number (int) or account ID Guid. (required) 3867 :return: UserCompletionRateResponse 3868 If the method is called asynchronously, 3869 returns the request thread. 3870 """ 3871 kwargs['_return_http_data_only'] = True 3872 if kwargs.get('callback'): 3873 return self.get_completion_rate_for_template_owner_with_http_info(account_id, **kwargs) 3874 else: 3875 (data) = self.get_completion_rate_for_template_owner_with_http_info(account_id, **kwargs) 3876 return data
Gets completion rate for the user
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_completion_rate_for_template_owner(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
UserCompletionRateResponse If the method is called asynchronously, returns the request thread.
def
get_completion_rate_for_template_owner_with_http_info(self, account_id, **kwargs)
3878 def get_completion_rate_for_template_owner_with_http_info(self, account_id, **kwargs): 3879 """ 3880 Gets completion rate for the user 3881 This method makes a synchronous HTTP request by default. To make an 3882 asynchronous HTTP request, please define a `callback` function 3883 to be invoked when receiving the response. 3884 >>> def callback_function(response): 3885 >>> pprint(response) 3886 >>> 3887 >>> thread = api.get_completion_rate_for_template_owner_with_http_info(account_id, callback=callback_function) 3888 3889 :param callback function: The callback function 3890 for asynchronous request. (optional) 3891 :param str account_id: The external account number (int) or account ID Guid. (required) 3892 :return: UserCompletionRateResponse 3893 If the method is called asynchronously, 3894 returns the request thread. 3895 """ 3896 3897 all_params = ['account_id'] 3898 all_params.append('callback') 3899 all_params.append('_return_http_data_only') 3900 all_params.append('_preload_content') 3901 all_params.append('_request_timeout') 3902 3903 params = locals() 3904 for key, val in iteritems(params['kwargs']): 3905 if key not in all_params: 3906 raise TypeError( 3907 "Got an unexpected keyword argument '%s'" 3908 " to method get_completion_rate_for_template_owner" % key 3909 ) 3910 params[key] = val 3911 del params['kwargs'] 3912 # verify the required parameter 'account_id' is set 3913 if ('account_id' not in params) or (params['account_id'] is None): 3914 raise ValueError("Missing the required parameter `account_id` when calling `get_completion_rate_for_template_owner`") 3915 3916 3917 collection_formats = {} 3918 3919 resource_path = '/v2.1/accounts/{accountId}/templates/insights/completionRate'.replace('{format}', 'json') 3920 path_params = {} 3921 if 'account_id' in params: 3922 path_params['accountId'] = params['account_id'] 3923 3924 query_params = {} 3925 3926 header_params = {} 3927 3928 form_params = [] 3929 local_var_files = {} 3930 3931 body_params = None 3932 # HTTP header `Accept` 3933 header_params['Accept'] = self.api_client.\ 3934 select_header_accept(['application/json']) 3935 3936 # Authentication setting 3937 auth_settings = [] 3938 3939 return self.api_client.call_api(resource_path, 'GET', 3940 path_params, 3941 query_params, 3942 header_params, 3943 body=body_params, 3944 post_params=form_params, 3945 files=local_var_files, 3946 response_type='UserCompletionRateResponse', 3947 auth_settings=auth_settings, 3948 callback=params.get('callback'), 3949 _return_http_data_only=params.get('_return_http_data_only'), 3950 _preload_content=params.get('_preload_content', True), 3951 _request_timeout=params.get('_request_timeout'), 3952 collection_formats=collection_formats)
Gets completion rate for the user
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_completion_rate_for_template_owner_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
UserCompletionRateResponse If the method is called asynchronously, returns the request thread.
def
get_consumer_disclosure(self, account_id, lang_code, **kwargs)
3954 def get_consumer_disclosure(self, account_id, lang_code, **kwargs): 3955 """ 3956 Gets the Electronic Record and Signature Disclosure. 3957 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. 3958 This method makes a synchronous HTTP request by default. To make an 3959 asynchronous HTTP request, please define a `callback` function 3960 to be invoked when receiving the response. 3961 >>> def callback_function(response): 3962 >>> pprint(response) 3963 >>> 3964 >>> thread = api.get_consumer_disclosure(account_id, lang_code, callback=callback_function) 3965 3966 :param callback function: The callback function 3967 for asynchronous request. (optional) 3968 :param str account_id: The external account number (int) or account ID Guid. (required) 3969 :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) 3970 :return: ConsumerDisclosure 3971 If the method is called asynchronously, 3972 returns the request thread. 3973 """ 3974 kwargs['_return_http_data_only'] = True 3975 if kwargs.get('callback'): 3976 return self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 3977 else: 3978 (data) = self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 3979 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)
3981 def get_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs): 3982 """ 3983 Gets the Electronic Record and Signature Disclosure. 3984 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. 3985 This method makes a synchronous HTTP request by default. To make an 3986 asynchronous HTTP request, please define a `callback` function 3987 to be invoked when receiving the response. 3988 >>> def callback_function(response): 3989 >>> pprint(response) 3990 >>> 3991 >>> thread = api.get_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function) 3992 3993 :param callback function: The callback function 3994 for asynchronous request. (optional) 3995 :param str account_id: The external account number (int) or account ID Guid. (required) 3996 :param str 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) 3997 :return: ConsumerDisclosure 3998 If the method is called asynchronously, 3999 returns the request thread. 4000 """ 4001 4002 all_params = ['account_id', 'lang_code'] 4003 all_params.append('callback') 4004 all_params.append('_return_http_data_only') 4005 all_params.append('_preload_content') 4006 all_params.append('_request_timeout') 4007 4008 params = locals() 4009 for key, val in iteritems(params['kwargs']): 4010 if key not in all_params: 4011 raise TypeError( 4012 "Got an unexpected keyword argument '%s'" 4013 " to method get_consumer_disclosure" % key 4014 ) 4015 params[key] = val 4016 del params['kwargs'] 4017 # verify the required parameter 'account_id' is set 4018 if ('account_id' not in params) or (params['account_id'] is None): 4019 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure`") 4020 # verify the required parameter 'lang_code' is set 4021 if ('lang_code' not in params) or (params['lang_code'] is None): 4022 raise ValueError("Missing the required parameter `lang_code` when calling `get_consumer_disclosure`") 4023 4024 4025 collection_formats = {} 4026 4027 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 4028 path_params = {} 4029 if 'account_id' in params: 4030 path_params['accountId'] = params['account_id'] 4031 if 'lang_code' in params: 4032 path_params['langCode'] = params['lang_code'] 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='ConsumerDisclosure', 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)
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)
4064 def get_consumer_disclosure_default(self, account_id, **kwargs): 4065 """ 4066 Gets the Electronic Record and Signature Disclosure for the account. 4067 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. 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_consumer_disclosure_default(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 :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. 4080 :return: ConsumerDisclosure 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_consumer_disclosure_default_with_http_info(account_id, **kwargs) 4087 else: 4088 (data) = self.get_consumer_disclosure_default_with_http_info(account_id, **kwargs) 4089 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)
4091 def get_consumer_disclosure_default_with_http_info(self, account_id, **kwargs): 4092 """ 4093 Gets the Electronic Record and Signature Disclosure for the account. 4094 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. 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_consumer_disclosure_default_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 :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. 4107 :return: ConsumerDisclosure 4108 If the method is called asynchronously, 4109 returns the request thread. 4110 """ 4111 4112 all_params = ['account_id', 'lang_code'] 4113 all_params.append('callback') 4114 all_params.append('_return_http_data_only') 4115 all_params.append('_preload_content') 4116 all_params.append('_request_timeout') 4117 4118 params = locals() 4119 for key, val in iteritems(params['kwargs']): 4120 if key not in all_params: 4121 raise TypeError( 4122 "Got an unexpected keyword argument '%s'" 4123 " to method get_consumer_disclosure_default" % key 4124 ) 4125 params[key] = val 4126 del params['kwargs'] 4127 # verify the required parameter 'account_id' is set 4128 if ('account_id' not in params) or (params['account_id'] is None): 4129 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure_default`") 4130 4131 4132 collection_formats = {} 4133 4134 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure'.replace('{format}', 'json') 4135 path_params = {} 4136 if 'account_id' in params: 4137 path_params['accountId'] = params['account_id'] 4138 4139 query_params = {} 4140 if 'lang_code' in params: 4141 query_params['langCode'] = params['lang_code'] 4142 4143 header_params = {} 4144 4145 form_params = [] 4146 local_var_files = {} 4147 4148 body_params = None 4149 # HTTP header `Accept` 4150 header_params['Accept'] = self.api_client.\ 4151 select_header_accept(['application/json']) 4152 4153 # Authentication setting 4154 auth_settings = [] 4155 4156 return self.api_client.call_api(resource_path, 'GET', 4157 path_params, 4158 query_params, 4159 header_params, 4160 body=body_params, 4161 post_params=form_params, 4162 files=local_var_files, 4163 response_type='ConsumerDisclosure', 4164 auth_settings=auth_settings, 4165 callback=params.get('callback'), 4166 _return_http_data_only=params.get('_return_http_data_only'), 4167 _preload_content=params.get('_preload_content', True), 4168 _request_timeout=params.get('_request_timeout'), 4169 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)
4171 def get_e_note_configuration(self, account_id, **kwargs): 4172 """ 4173 Returns the configuration information for the eNote eOriginal integration. 4174 4175 This method makes a synchronous HTTP request by default. To make an 4176 asynchronous HTTP request, please define a `callback` function 4177 to be invoked when receiving the response. 4178 >>> def callback_function(response): 4179 >>> pprint(response) 4180 >>> 4181 >>> thread = api.get_e_note_configuration(account_id, callback=callback_function) 4182 4183 :param callback function: The callback function 4184 for asynchronous request. (optional) 4185 :param str account_id: The external account number (int) or account ID Guid. (required) 4186 :return: ENoteConfiguration 4187 If the method is called asynchronously, 4188 returns the request thread. 4189 """ 4190 kwargs['_return_http_data_only'] = True 4191 if kwargs.get('callback'): 4192 return self.get_e_note_configuration_with_http_info(account_id, **kwargs) 4193 else: 4194 (data) = self.get_e_note_configuration_with_http_info(account_id, **kwargs) 4195 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)
4197 def get_e_note_configuration_with_http_info(self, account_id, **kwargs): 4198 """ 4199 Returns the configuration information for the eNote eOriginal integration. 4200 4201 This method makes a synchronous HTTP request by default. To make an 4202 asynchronous HTTP request, please define a `callback` function 4203 to be invoked when receiving the response. 4204 >>> def callback_function(response): 4205 >>> pprint(response) 4206 >>> 4207 >>> thread = api.get_e_note_configuration_with_http_info(account_id, callback=callback_function) 4208 4209 :param callback function: The callback function 4210 for asynchronous request. (optional) 4211 :param str account_id: The external account number (int) or account ID Guid. (required) 4212 :return: ENoteConfiguration 4213 If the method is called asynchronously, 4214 returns the request thread. 4215 """ 4216 4217 all_params = ['account_id'] 4218 all_params.append('callback') 4219 all_params.append('_return_http_data_only') 4220 all_params.append('_preload_content') 4221 all_params.append('_request_timeout') 4222 4223 params = locals() 4224 for key, val in iteritems(params['kwargs']): 4225 if key not in all_params: 4226 raise TypeError( 4227 "Got an unexpected keyword argument '%s'" 4228 " to method get_e_note_configuration" % key 4229 ) 4230 params[key] = val 4231 del params['kwargs'] 4232 # verify the required parameter 'account_id' is set 4233 if ('account_id' not in params) or (params['account_id'] is None): 4234 raise ValueError("Missing the required parameter `account_id` when calling `get_e_note_configuration`") 4235 4236 4237 collection_formats = {} 4238 4239 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 4240 path_params = {} 4241 if 'account_id' in params: 4242 path_params['accountId'] = params['account_id'] 4243 4244 query_params = {} 4245 4246 header_params = {} 4247 4248 form_params = [] 4249 local_var_files = {} 4250 4251 body_params = None 4252 # HTTP header `Accept` 4253 header_params['Accept'] = self.api_client.\ 4254 select_header_accept(['application/json']) 4255 4256 # Authentication setting 4257 auth_settings = [] 4258 4259 return self.api_client.call_api(resource_path, 'GET', 4260 path_params, 4261 query_params, 4262 header_params, 4263 body=body_params, 4264 post_params=form_params, 4265 files=local_var_files, 4266 response_type='ENoteConfiguration', 4267 auth_settings=auth_settings, 4268 callback=params.get('callback'), 4269 _return_http_data_only=params.get('_return_http_data_only'), 4270 _preload_content=params.get('_preload_content', True), 4271 _request_timeout=params.get('_request_timeout'), 4272 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)
4274 def get_envelope_purge_configuration(self, account_id, **kwargs): 4275 """ 4276 Select envelope purge configuration. 4277 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. 4278 This method makes a synchronous HTTP request by default. To make an 4279 asynchronous HTTP request, please define a `callback` function 4280 to be invoked when receiving the response. 4281 >>> def callback_function(response): 4282 >>> pprint(response) 4283 >>> 4284 >>> thread = api.get_envelope_purge_configuration(account_id, callback=callback_function) 4285 4286 :param callback function: The callback function 4287 for asynchronous request. (optional) 4288 :param str account_id: The external account number (int) or account ID Guid. (required) 4289 :return: EnvelopePurgeConfiguration 4290 If the method is called asynchronously, 4291 returns the request thread. 4292 """ 4293 kwargs['_return_http_data_only'] = True 4294 if kwargs.get('callback'): 4295 return self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs) 4296 else: 4297 (data) = self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs) 4298 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)
4300 def get_envelope_purge_configuration_with_http_info(self, account_id, **kwargs): 4301 """ 4302 Select envelope purge configuration. 4303 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. 4304 This method makes a synchronous HTTP request by default. To make an 4305 asynchronous HTTP request, please define a `callback` function 4306 to be invoked when receiving the response. 4307 >>> def callback_function(response): 4308 >>> pprint(response) 4309 >>> 4310 >>> thread = api.get_envelope_purge_configuration_with_http_info(account_id, callback=callback_function) 4311 4312 :param callback function: The callback function 4313 for asynchronous request. (optional) 4314 :param str account_id: The external account number (int) or account ID Guid. (required) 4315 :return: EnvelopePurgeConfiguration 4316 If the method is called asynchronously, 4317 returns the request thread. 4318 """ 4319 4320 all_params = ['account_id'] 4321 all_params.append('callback') 4322 all_params.append('_return_http_data_only') 4323 all_params.append('_preload_content') 4324 all_params.append('_request_timeout') 4325 4326 params = locals() 4327 for key, val in iteritems(params['kwargs']): 4328 if key not in all_params: 4329 raise TypeError( 4330 "Got an unexpected keyword argument '%s'" 4331 " to method get_envelope_purge_configuration" % key 4332 ) 4333 params[key] = val 4334 del params['kwargs'] 4335 # verify the required parameter 'account_id' is set 4336 if ('account_id' not in params) or (params['account_id'] is None): 4337 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_purge_configuration`") 4338 4339 4340 collection_formats = {} 4341 4342 resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json') 4343 path_params = {} 4344 if 'account_id' in params: 4345 path_params['accountId'] = params['account_id'] 4346 4347 query_params = {} 4348 4349 header_params = {} 4350 4351 form_params = [] 4352 local_var_files = {} 4353 4354 body_params = None 4355 # HTTP header `Accept` 4356 header_params['Accept'] = self.api_client.\ 4357 select_header_accept(['application/json']) 4358 4359 # Authentication setting 4360 auth_settings = [] 4361 4362 return self.api_client.call_api(resource_path, 'GET', 4363 path_params, 4364 query_params, 4365 header_params, 4366 body=body_params, 4367 post_params=form_params, 4368 files=local_var_files, 4369 response_type='EnvelopePurgeConfiguration', 4370 auth_settings=auth_settings, 4371 callback=params.get('callback'), 4372 _return_http_data_only=params.get('_return_http_data_only'), 4373 _preload_content=params.get('_preload_content', True), 4374 _request_timeout=params.get('_request_timeout'), 4375 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)
4377 def get_favorite_templates(self, account_id, **kwargs): 4378 """ 4379 Retrieves the list of favorited templates for this caller 4380 4381 This method makes a synchronous HTTP request by default. To make an 4382 asynchronous HTTP request, please define a `callback` function 4383 to be invoked when receiving the response. 4384 >>> def callback_function(response): 4385 >>> pprint(response) 4386 >>> 4387 >>> thread = api.get_favorite_templates(account_id, callback=callback_function) 4388 4389 :param callback function: The callback function 4390 for asynchronous request. (optional) 4391 :param str account_id: The external account number (int) or account ID Guid. (required) 4392 :return: FavoriteTemplatesInfo 4393 If the method is called asynchronously, 4394 returns the request thread. 4395 """ 4396 kwargs['_return_http_data_only'] = True 4397 if kwargs.get('callback'): 4398 return self.get_favorite_templates_with_http_info(account_id, **kwargs) 4399 else: 4400 (data) = self.get_favorite_templates_with_http_info(account_id, **kwargs) 4401 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)
4403 def get_favorite_templates_with_http_info(self, account_id, **kwargs): 4404 """ 4405 Retrieves the list of favorited templates for this caller 4406 4407 This method makes a synchronous HTTP request by default. To make an 4408 asynchronous HTTP request, please define a `callback` function 4409 to be invoked when receiving the response. 4410 >>> def callback_function(response): 4411 >>> pprint(response) 4412 >>> 4413 >>> thread = api.get_favorite_templates_with_http_info(account_id, callback=callback_function) 4414 4415 :param callback function: The callback function 4416 for asynchronous request. (optional) 4417 :param str account_id: The external account number (int) or account ID Guid. (required) 4418 :return: FavoriteTemplatesInfo 4419 If the method is called asynchronously, 4420 returns the request thread. 4421 """ 4422 4423 all_params = ['account_id'] 4424 all_params.append('callback') 4425 all_params.append('_return_http_data_only') 4426 all_params.append('_preload_content') 4427 all_params.append('_request_timeout') 4428 4429 params = locals() 4430 for key, val in iteritems(params['kwargs']): 4431 if key not in all_params: 4432 raise TypeError( 4433 "Got an unexpected keyword argument '%s'" 4434 " to method get_favorite_templates" % key 4435 ) 4436 params[key] = val 4437 del params['kwargs'] 4438 # verify the required parameter 'account_id' is set 4439 if ('account_id' not in params) or (params['account_id'] is None): 4440 raise ValueError("Missing the required parameter `account_id` when calling `get_favorite_templates`") 4441 4442 4443 collection_formats = {} 4444 4445 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 4446 path_params = {} 4447 if 'account_id' in params: 4448 path_params['accountId'] = params['account_id'] 4449 4450 query_params = {} 4451 4452 header_params = {} 4453 4454 form_params = [] 4455 local_var_files = {} 4456 4457 body_params = None 4458 # HTTP header `Accept` 4459 header_params['Accept'] = self.api_client.\ 4460 select_header_accept(['application/json']) 4461 4462 # Authentication setting 4463 auth_settings = [] 4464 4465 return self.api_client.call_api(resource_path, 'GET', 4466 path_params, 4467 query_params, 4468 header_params, 4469 body=body_params, 4470 post_params=form_params, 4471 files=local_var_files, 4472 response_type='FavoriteTemplatesInfo', 4473 auth_settings=auth_settings, 4474 callback=params.get('callback'), 4475 _return_http_data_only=params.get('_return_http_data_only'), 4476 _preload_content=params.get('_preload_content', True), 4477 _request_timeout=params.get('_request_timeout'), 4478 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)
4480 def get_notification_defaults(self, account_id, **kwargs): 4481 """ 4482 Returns default user level settings for a specified account 4483 This method returns the default settings for the email notifications that signers and senders receive about envelopes. 4484 This method makes a synchronous HTTP request by default. To make an 4485 asynchronous HTTP request, please define a `callback` function 4486 to be invoked when receiving the response. 4487 >>> def callback_function(response): 4488 >>> pprint(response) 4489 >>> 4490 >>> thread = api.get_notification_defaults(account_id, callback=callback_function) 4491 4492 :param callback function: The callback function 4493 for asynchronous request. (optional) 4494 :param str account_id: The external account number (int) or account ID Guid. (required) 4495 :return: NotificationDefaults 4496 If the method is called asynchronously, 4497 returns the request thread. 4498 """ 4499 kwargs['_return_http_data_only'] = True 4500 if kwargs.get('callback'): 4501 return self.get_notification_defaults_with_http_info(account_id, **kwargs) 4502 else: 4503 (data) = self.get_notification_defaults_with_http_info(account_id, **kwargs) 4504 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)
4506 def get_notification_defaults_with_http_info(self, account_id, **kwargs): 4507 """ 4508 Returns default user level settings for a specified account 4509 This method returns the default settings for the email notifications that signers and senders receive about envelopes. 4510 This method makes a synchronous HTTP request by default. To make an 4511 asynchronous HTTP request, please define a `callback` function 4512 to be invoked when receiving the response. 4513 >>> def callback_function(response): 4514 >>> pprint(response) 4515 >>> 4516 >>> thread = api.get_notification_defaults_with_http_info(account_id, callback=callback_function) 4517 4518 :param callback function: The callback function 4519 for asynchronous request. (optional) 4520 :param str account_id: The external account number (int) or account ID Guid. (required) 4521 :return: NotificationDefaults 4522 If the method is called asynchronously, 4523 returns the request thread. 4524 """ 4525 4526 all_params = ['account_id'] 4527 all_params.append('callback') 4528 all_params.append('_return_http_data_only') 4529 all_params.append('_preload_content') 4530 all_params.append('_request_timeout') 4531 4532 params = locals() 4533 for key, val in iteritems(params['kwargs']): 4534 if key not in all_params: 4535 raise TypeError( 4536 "Got an unexpected keyword argument '%s'" 4537 " to method get_notification_defaults" % key 4538 ) 4539 params[key] = val 4540 del params['kwargs'] 4541 # verify the required parameter 'account_id' is set 4542 if ('account_id' not in params) or (params['account_id'] is None): 4543 raise ValueError("Missing the required parameter `account_id` when calling `get_notification_defaults`") 4544 4545 4546 collection_formats = {} 4547 4548 resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json') 4549 path_params = {} 4550 if 'account_id' in params: 4551 path_params['accountId'] = params['account_id'] 4552 4553 query_params = {} 4554 4555 header_params = {} 4556 4557 form_params = [] 4558 local_var_files = {} 4559 4560 body_params = None 4561 # HTTP header `Accept` 4562 header_params['Accept'] = self.api_client.\ 4563 select_header_accept(['application/json']) 4564 4565 # Authentication setting 4566 auth_settings = [] 4567 4568 return self.api_client.call_api(resource_path, 'GET', 4569 path_params, 4570 query_params, 4571 header_params, 4572 body=body_params, 4573 post_params=form_params, 4574 files=local_var_files, 4575 response_type='NotificationDefaults', 4576 auth_settings=auth_settings, 4577 callback=params.get('callback'), 4578 _return_http_data_only=params.get('_return_http_data_only'), 4579 _preload_content=params.get('_preload_content', True), 4580 _request_timeout=params.get('_request_timeout'), 4581 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)
4583 def get_password_rules(self, account_id, **kwargs): 4584 """ 4585 Get the password rules 4586 This method retrieves the password rules for an account. 4587 This method makes a synchronous HTTP request by default. To make an 4588 asynchronous HTTP request, please define a `callback` function 4589 to be invoked when receiving the response. 4590 >>> def callback_function(response): 4591 >>> pprint(response) 4592 >>> 4593 >>> thread = api.get_password_rules(account_id, callback=callback_function) 4594 4595 :param callback function: The callback function 4596 for asynchronous request. (optional) 4597 :param str account_id: The external account number (int) or account ID Guid. (required) 4598 :return: AccountPasswordRules 4599 If the method is called asynchronously, 4600 returns the request thread. 4601 """ 4602 kwargs['_return_http_data_only'] = True 4603 if kwargs.get('callback'): 4604 return self.get_password_rules_with_http_info(account_id, **kwargs) 4605 else: 4606 (data) = self.get_password_rules_with_http_info(account_id, **kwargs) 4607 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)
4609 def get_password_rules_with_http_info(self, account_id, **kwargs): 4610 """ 4611 Get the password rules 4612 This method retrieves the password rules for an account. 4613 This method makes a synchronous HTTP request by default. To make an 4614 asynchronous HTTP request, please define a `callback` function 4615 to be invoked when receiving the response. 4616 >>> def callback_function(response): 4617 >>> pprint(response) 4618 >>> 4619 >>> thread = api.get_password_rules_with_http_info(account_id, callback=callback_function) 4620 4621 :param callback function: The callback function 4622 for asynchronous request. (optional) 4623 :param str account_id: The external account number (int) or account ID Guid. (required) 4624 :return: AccountPasswordRules 4625 If the method is called asynchronously, 4626 returns the request thread. 4627 """ 4628 4629 all_params = ['account_id'] 4630 all_params.append('callback') 4631 all_params.append('_return_http_data_only') 4632 all_params.append('_preload_content') 4633 all_params.append('_request_timeout') 4634 4635 params = locals() 4636 for key, val in iteritems(params['kwargs']): 4637 if key not in all_params: 4638 raise TypeError( 4639 "Got an unexpected keyword argument '%s'" 4640 " to method get_password_rules" % key 4641 ) 4642 params[key] = val 4643 del params['kwargs'] 4644 # verify the required parameter 'account_id' is set 4645 if ('account_id' not in params) or (params['account_id'] is None): 4646 raise ValueError("Missing the required parameter `account_id` when calling `get_password_rules`") 4647 4648 4649 collection_formats = {} 4650 4651 resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json') 4652 path_params = {} 4653 if 'account_id' in params: 4654 path_params['accountId'] = params['account_id'] 4655 4656 query_params = {} 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='AccountPasswordRules', 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)
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)
4686 def get_password_rules_0(self, **kwargs): 4687 """ 4688 Get membership account password rules 4689 4690 This method makes a synchronous HTTP request by default. To make an 4691 asynchronous HTTP request, please define a `callback` function 4692 to be invoked when receiving the response. 4693 >>> def callback_function(response): 4694 >>> pprint(response) 4695 >>> 4696 >>> thread = api.get_password_rules_0(callback=callback_function) 4697 4698 :param callback function: The callback function 4699 for asynchronous request. (optional) 4700 :return: UserPasswordRules 4701 If the method is called asynchronously, 4702 returns the request thread. 4703 """ 4704 kwargs['_return_http_data_only'] = True 4705 if kwargs.get('callback'): 4706 return self.get_password_rules_0_with_http_info(**kwargs) 4707 else: 4708 (data) = self.get_password_rules_0_with_http_info(**kwargs) 4709 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)
4711 def get_password_rules_0_with_http_info(self, **kwargs): 4712 """ 4713 Get membership account password rules 4714 4715 This method makes a synchronous HTTP request by default. To make an 4716 asynchronous HTTP request, please define a `callback` function 4717 to be invoked when receiving the response. 4718 >>> def callback_function(response): 4719 >>> pprint(response) 4720 >>> 4721 >>> thread = api.get_password_rules_0_with_http_info(callback=callback_function) 4722 4723 :param callback function: The callback function 4724 for asynchronous request. (optional) 4725 :return: UserPasswordRules 4726 If the method is called asynchronously, 4727 returns the request thread. 4728 """ 4729 4730 all_params = [] 4731 all_params.append('callback') 4732 all_params.append('_return_http_data_only') 4733 all_params.append('_preload_content') 4734 all_params.append('_request_timeout') 4735 4736 params = locals() 4737 for key, val in iteritems(params['kwargs']): 4738 if key not in all_params: 4739 raise TypeError( 4740 "Got an unexpected keyword argument '%s'" 4741 " to method get_password_rules_0" % key 4742 ) 4743 params[key] = val 4744 del params['kwargs'] 4745 4746 collection_formats = {} 4747 4748 resource_path = '/v2.1/current_user/password_rules'.replace('{format}', 'json') 4749 path_params = {} 4750 4751 query_params = {} 4752 4753 header_params = {} 4754 4755 form_params = [] 4756 local_var_files = {} 4757 4758 body_params = None 4759 # HTTP header `Accept` 4760 header_params['Accept'] = self.api_client.\ 4761 select_header_accept(['application/json']) 4762 4763 # Authentication setting 4764 auth_settings = [] 4765 4766 return self.api_client.call_api(resource_path, 'GET', 4767 path_params, 4768 query_params, 4769 header_params, 4770 body=body_params, 4771 post_params=form_params, 4772 files=local_var_files, 4773 response_type='UserPasswordRules', 4774 auth_settings=auth_settings, 4775 callback=params.get('callback'), 4776 _return_http_data_only=params.get('_return_http_data_only'), 4777 _preload_content=params.get('_preload_content', True), 4778 _request_timeout=params.get('_request_timeout'), 4779 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)
4781 def get_permission_profile(self, account_id, permission_profile_id, **kwargs): 4782 """ 4783 Returns a permissions profile in the specified account. 4784 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/) 4785 This method makes a synchronous HTTP request by default. To make an 4786 asynchronous HTTP request, please define a `callback` function 4787 to be invoked when receiving the response. 4788 >>> def callback_function(response): 4789 >>> pprint(response) 4790 >>> 4791 >>> thread = api.get_permission_profile(account_id, permission_profile_id, callback=callback_function) 4792 4793 :param callback function: The callback function 4794 for asynchronous request. (optional) 4795 :param str account_id: The external account number (int) or account ID Guid. (required) 4796 :param str permission_profile_id: (required) 4797 :param str include: 4798 :return: PermissionProfile 4799 If the method is called asynchronously, 4800 returns the request thread. 4801 """ 4802 kwargs['_return_http_data_only'] = True 4803 if kwargs.get('callback'): 4804 return self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 4805 else: 4806 (data) = self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 4807 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)
4809 def get_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 4810 """ 4811 Returns a permissions profile in the specified account. 4812 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/) 4813 This method makes a synchronous HTTP request by default. To make an 4814 asynchronous HTTP request, please define a `callback` function 4815 to be invoked when receiving the response. 4816 >>> def callback_function(response): 4817 >>> pprint(response) 4818 >>> 4819 >>> thread = api.get_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 4820 4821 :param callback function: The callback function 4822 for asynchronous request. (optional) 4823 :param str account_id: The external account number (int) or account ID Guid. (required) 4824 :param str permission_profile_id: (required) 4825 :param str include: 4826 :return: PermissionProfile 4827 If the method is called asynchronously, 4828 returns the request thread. 4829 """ 4830 4831 all_params = ['account_id', 'permission_profile_id', 'include'] 4832 all_params.append('callback') 4833 all_params.append('_return_http_data_only') 4834 all_params.append('_preload_content') 4835 all_params.append('_request_timeout') 4836 4837 params = locals() 4838 for key, val in iteritems(params['kwargs']): 4839 if key not in all_params: 4840 raise TypeError( 4841 "Got an unexpected keyword argument '%s'" 4842 " to method get_permission_profile" % key 4843 ) 4844 params[key] = val 4845 del params['kwargs'] 4846 # verify the required parameter 'account_id' is set 4847 if ('account_id' not in params) or (params['account_id'] is None): 4848 raise ValueError("Missing the required parameter `account_id` when calling `get_permission_profile`") 4849 # verify the required parameter 'permission_profile_id' is set 4850 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 4851 raise ValueError("Missing the required parameter `permission_profile_id` when calling `get_permission_profile`") 4852 4853 4854 collection_formats = {} 4855 4856 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 4857 path_params = {} 4858 if 'account_id' in params: 4859 path_params['accountId'] = params['account_id'] 4860 if 'permission_profile_id' in params: 4861 path_params['permissionProfileId'] = params['permission_profile_id'] 4862 4863 query_params = {} 4864 if 'include' in params: 4865 query_params['include'] = params['include'] 4866 4867 header_params = {} 4868 4869 form_params = [] 4870 local_var_files = {} 4871 4872 body_params = None 4873 # HTTP header `Accept` 4874 header_params['Accept'] = self.api_client.\ 4875 select_header_accept(['application/json']) 4876 4877 # Authentication setting 4878 auth_settings = [] 4879 4880 return self.api_client.call_api(resource_path, 'GET', 4881 path_params, 4882 query_params, 4883 header_params, 4884 body=body_params, 4885 post_params=form_params, 4886 files=local_var_files, 4887 response_type='PermissionProfile', 4888 auth_settings=auth_settings, 4889 callback=params.get('callback'), 4890 _return_http_data_only=params.get('_return_http_data_only'), 4891 _preload_content=params.get('_preload_content', True), 4892 _request_timeout=params.get('_request_timeout'), 4893 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)
5031 def get_provisioning(self, **kwargs): 5032 """ 5033 Retrieves the account provisioning information for the account. 5034 Retrieves the account provisioning information for the account. 5035 This method makes a synchronous HTTP request by default. To make an 5036 asynchronous HTTP request, please define a `callback` function 5037 to be invoked when receiving the response. 5038 >>> def callback_function(response): 5039 >>> pprint(response) 5040 >>> 5041 >>> thread = api.get_provisioning(callback=callback_function) 5042 5043 :param callback function: The callback function 5044 for asynchronous request. (optional) 5045 :return: ProvisioningInformation 5046 If the method is called asynchronously, 5047 returns the request thread. 5048 """ 5049 kwargs['_return_http_data_only'] = True 5050 if kwargs.get('callback'): 5051 return self.get_provisioning_with_http_info(**kwargs) 5052 else: 5053 (data) = self.get_provisioning_with_http_info(**kwargs) 5054 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)
5056 def get_provisioning_with_http_info(self, **kwargs): 5057 """ 5058 Retrieves the account provisioning information for the account. 5059 Retrieves the account provisioning information for the account. 5060 This method makes a synchronous HTTP request by default. To make an 5061 asynchronous HTTP request, please define a `callback` function 5062 to be invoked when receiving the response. 5063 >>> def callback_function(response): 5064 >>> pprint(response) 5065 >>> 5066 >>> thread = api.get_provisioning_with_http_info(callback=callback_function) 5067 5068 :param callback function: The callback function 5069 for asynchronous request. (optional) 5070 :return: ProvisioningInformation 5071 If the method is called asynchronously, 5072 returns the request thread. 5073 """ 5074 5075 all_params = [] 5076 all_params.append('callback') 5077 all_params.append('_return_http_data_only') 5078 all_params.append('_preload_content') 5079 all_params.append('_request_timeout') 5080 5081 params = locals() 5082 for key, val in iteritems(params['kwargs']): 5083 if key not in all_params: 5084 raise TypeError( 5085 "Got an unexpected keyword argument '%s'" 5086 " to method get_provisioning" % key 5087 ) 5088 params[key] = val 5089 del params['kwargs'] 5090 5091 collection_formats = {} 5092 5093 resource_path = '/v2.1/accounts/provisioning'.replace('{format}', 'json') 5094 path_params = {} 5095 5096 query_params = {} 5097 5098 header_params = {} 5099 5100 form_params = [] 5101 local_var_files = {} 5102 5103 body_params = None 5104 # HTTP header `Accept` 5105 header_params['Accept'] = self.api_client.\ 5106 select_header_accept(['application/json']) 5107 5108 # Authentication setting 5109 auth_settings = [] 5110 5111 return self.api_client.call_api(resource_path, 'GET', 5112 path_params, 5113 query_params, 5114 header_params, 5115 body=body_params, 5116 post_params=form_params, 5117 files=local_var_files, 5118 response_type='ProvisioningInformation', 5119 auth_settings=auth_settings, 5120 callback=params.get('callback'), 5121 _return_http_data_only=params.get('_return_http_data_only'), 5122 _preload_content=params.get('_preload_content', True), 5123 _request_timeout=params.get('_request_timeout'), 5124 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)
5126 def get_supported_languages(self, account_id, **kwargs): 5127 """ 5128 Gets list of supported languages for recipient language setting. 5129 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). 5130 This method makes a synchronous HTTP request by default. To make an 5131 asynchronous HTTP request, please define a `callback` function 5132 to be invoked when receiving the response. 5133 >>> def callback_function(response): 5134 >>> pprint(response) 5135 >>> 5136 >>> thread = api.get_supported_languages(account_id, callback=callback_function) 5137 5138 :param callback function: The callback function 5139 for asynchronous request. (optional) 5140 :param str account_id: The external account number (int) or account ID Guid. (required) 5141 :return: SupportedLanguages 5142 If the method is called asynchronously, 5143 returns the request thread. 5144 """ 5145 kwargs['_return_http_data_only'] = True 5146 if kwargs.get('callback'): 5147 return self.get_supported_languages_with_http_info(account_id, **kwargs) 5148 else: 5149 (data) = self.get_supported_languages_with_http_info(account_id, **kwargs) 5150 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)
5152 def get_supported_languages_with_http_info(self, account_id, **kwargs): 5153 """ 5154 Gets list of supported languages for recipient language setting. 5155 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). 5156 This method makes a synchronous HTTP request by default. To make an 5157 asynchronous HTTP request, please define a `callback` function 5158 to be invoked when receiving the response. 5159 >>> def callback_function(response): 5160 >>> pprint(response) 5161 >>> 5162 >>> thread = api.get_supported_languages_with_http_info(account_id, callback=callback_function) 5163 5164 :param callback function: The callback function 5165 for asynchronous request. (optional) 5166 :param str account_id: The external account number (int) or account ID Guid. (required) 5167 :return: SupportedLanguages 5168 If the method is called asynchronously, 5169 returns the request thread. 5170 """ 5171 5172 all_params = ['account_id'] 5173 all_params.append('callback') 5174 all_params.append('_return_http_data_only') 5175 all_params.append('_preload_content') 5176 all_params.append('_request_timeout') 5177 5178 params = locals() 5179 for key, val in iteritems(params['kwargs']): 5180 if key not in all_params: 5181 raise TypeError( 5182 "Got an unexpected keyword argument '%s'" 5183 " to method get_supported_languages" % key 5184 ) 5185 params[key] = val 5186 del params['kwargs'] 5187 # verify the required parameter 'account_id' is set 5188 if ('account_id' not in params) or (params['account_id'] is None): 5189 raise ValueError("Missing the required parameter `account_id` when calling `get_supported_languages`") 5190 5191 5192 collection_formats = {} 5193 5194 resource_path = '/v2.1/accounts/{accountId}/supported_languages'.replace('{format}', 'json') 5195 path_params = {} 5196 if 'account_id' in params: 5197 path_params['accountId'] = params['account_id'] 5198 5199 query_params = {} 5200 5201 header_params = {} 5202 5203 form_params = [] 5204 local_var_files = {} 5205 5206 body_params = None 5207 # HTTP header `Accept` 5208 header_params['Accept'] = self.api_client.\ 5209 select_header_accept(['application/json']) 5210 5211 # Authentication setting 5212 auth_settings = [] 5213 5214 return self.api_client.call_api(resource_path, 'GET', 5215 path_params, 5216 query_params, 5217 header_params, 5218 body=body_params, 5219 post_params=form_params, 5220 files=local_var_files, 5221 response_type='SupportedLanguages', 5222 auth_settings=auth_settings, 5223 callback=params.get('callback'), 5224 _return_http_data_only=params.get('_return_http_data_only'), 5225 _preload_content=params.get('_preload_content', True), 5226 _request_timeout=params.get('_request_timeout'), 5227 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)
5344 def get_watermark(self, account_id, **kwargs): 5345 """ 5346 Get watermark information. 5347 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.get_watermark(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 :return: Watermark 5360 If the method is called asynchronously, 5361 returns the request thread. 5362 """ 5363 kwargs['_return_http_data_only'] = True 5364 if kwargs.get('callback'): 5365 return self.get_watermark_with_http_info(account_id, **kwargs) 5366 else: 5367 (data) = self.get_watermark_with_http_info(account_id, **kwargs) 5368 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)
5370 def get_watermark_with_http_info(self, account_id, **kwargs): 5371 """ 5372 Get watermark information. 5373 5374 This method makes a synchronous HTTP request by default. To make an 5375 asynchronous HTTP request, please define a `callback` function 5376 to be invoked when receiving the response. 5377 >>> def callback_function(response): 5378 >>> pprint(response) 5379 >>> 5380 >>> thread = api.get_watermark_with_http_info(account_id, callback=callback_function) 5381 5382 :param callback function: The callback function 5383 for asynchronous request. (optional) 5384 :param str account_id: The external account number (int) or account ID Guid. (required) 5385 :return: Watermark 5386 If the method is called asynchronously, 5387 returns the request thread. 5388 """ 5389 5390 all_params = ['account_id'] 5391 all_params.append('callback') 5392 all_params.append('_return_http_data_only') 5393 all_params.append('_preload_content') 5394 all_params.append('_request_timeout') 5395 5396 params = locals() 5397 for key, val in iteritems(params['kwargs']): 5398 if key not in all_params: 5399 raise TypeError( 5400 "Got an unexpected keyword argument '%s'" 5401 " to method get_watermark" % key 5402 ) 5403 params[key] = val 5404 del params['kwargs'] 5405 # verify the required parameter 'account_id' is set 5406 if ('account_id' not in params) or (params['account_id'] is None): 5407 raise ValueError("Missing the required parameter `account_id` when calling `get_watermark`") 5408 5409 5410 collection_formats = {} 5411 5412 resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json') 5413 path_params = {} 5414 if 'account_id' in params: 5415 path_params['accountId'] = params['account_id'] 5416 5417 query_params = {} 5418 5419 header_params = {} 5420 5421 form_params = [] 5422 local_var_files = {} 5423 5424 body_params = None 5425 # HTTP header `Accept` 5426 header_params['Accept'] = self.api_client.\ 5427 select_header_accept(['application/json']) 5428 5429 # Authentication setting 5430 auth_settings = [] 5431 5432 return self.api_client.call_api(resource_path, 'GET', 5433 path_params, 5434 query_params, 5435 header_params, 5436 body=body_params, 5437 post_params=form_params, 5438 files=local_var_files, 5439 response_type='Watermark', 5440 auth_settings=auth_settings, 5441 callback=params.get('callback'), 5442 _return_http_data_only=params.get('_return_http_data_only'), 5443 _preload_content=params.get('_preload_content', True), 5444 _request_timeout=params.get('_request_timeout'), 5445 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)
5447 def get_watermark_preview(self, account_id, **kwargs): 5448 """ 5449 Get watermark preview. 5450 5451 This method makes a synchronous HTTP request by default. To make an 5452 asynchronous HTTP request, please define a `callback` function 5453 to be invoked when receiving the response. 5454 >>> def callback_function(response): 5455 >>> pprint(response) 5456 >>> 5457 >>> thread = api.get_watermark_preview(account_id, callback=callback_function) 5458 5459 :param callback function: The callback function 5460 for asynchronous request. (optional) 5461 :param str account_id: The external account number (int) or account ID Guid. (required) 5462 :param Watermark watermark: 5463 :return: Watermark 5464 If the method is called asynchronously, 5465 returns the request thread. 5466 """ 5467 kwargs['_return_http_data_only'] = True 5468 if kwargs.get('callback'): 5469 return self.get_watermark_preview_with_http_info(account_id, **kwargs) 5470 else: 5471 (data) = self.get_watermark_preview_with_http_info(account_id, **kwargs) 5472 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)
5474 def get_watermark_preview_with_http_info(self, account_id, **kwargs): 5475 """ 5476 Get watermark preview. 5477 5478 This method makes a synchronous HTTP request by default. To make an 5479 asynchronous HTTP request, please define a `callback` function 5480 to be invoked when receiving the response. 5481 >>> def callback_function(response): 5482 >>> pprint(response) 5483 >>> 5484 >>> thread = api.get_watermark_preview_with_http_info(account_id, callback=callback_function) 5485 5486 :param callback function: The callback function 5487 for asynchronous request. (optional) 5488 :param str account_id: The external account number (int) or account ID Guid. (required) 5489 :param Watermark watermark: 5490 :return: Watermark 5491 If the method is called asynchronously, 5492 returns the request thread. 5493 """ 5494 5495 all_params = ['account_id', 'watermark'] 5496 all_params.append('callback') 5497 all_params.append('_return_http_data_only') 5498 all_params.append('_preload_content') 5499 all_params.append('_request_timeout') 5500 5501 params = locals() 5502 for key, val in iteritems(params['kwargs']): 5503 if key not in all_params: 5504 raise TypeError( 5505 "Got an unexpected keyword argument '%s'" 5506 " to method get_watermark_preview" % key 5507 ) 5508 params[key] = val 5509 del params['kwargs'] 5510 # verify the required parameter 'account_id' is set 5511 if ('account_id' not in params) or (params['account_id'] is None): 5512 raise ValueError("Missing the required parameter `account_id` when calling `get_watermark_preview`") 5513 5514 5515 collection_formats = {} 5516 5517 resource_path = '/v2.1/accounts/{accountId}/watermark/preview'.replace('{format}', 'json') 5518 path_params = {} 5519 if 'account_id' in params: 5520 path_params['accountId'] = params['account_id'] 5521 5522 query_params = {} 5523 5524 header_params = {} 5525 5526 form_params = [] 5527 local_var_files = {} 5528 5529 body_params = None 5530 if 'watermark' in params: 5531 body_params = params['watermark'] 5532 # HTTP header `Accept` 5533 header_params['Accept'] = self.api_client.\ 5534 select_header_accept(['application/json']) 5535 5536 # Authentication setting 5537 auth_settings = [] 5538 5539 return self.api_client.call_api(resource_path, 'PUT', 5540 path_params, 5541 query_params, 5542 header_params, 5543 body=body_params, 5544 post_params=form_params, 5545 files=local_var_files, 5546 response_type='Watermark', 5547 auth_settings=auth_settings, 5548 callback=params.get('callback'), 5549 _return_http_data_only=params.get('_return_http_data_only'), 5550 _preload_content=params.get('_preload_content', True), 5551 _request_timeout=params.get('_request_timeout'), 5552 collection_formats=collection_formats)
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)
5554 def list_brands(self, account_id, **kwargs): 5555 """ 5556 Gets a list of brand profiles. 5557 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. 5558 This method makes a synchronous HTTP request by default. To make an 5559 asynchronous HTTP request, please define a `callback` function 5560 to be invoked when receiving the response. 5561 >>> def callback_function(response): 5562 >>> pprint(response) 5563 >>> 5564 >>> thread = api.list_brands(account_id, callback=callback_function) 5565 5566 :param callback function: The callback function 5567 for asynchronous request. (optional) 5568 :param str account_id: The external account number (int) or account ID Guid. (required) 5569 :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set. 5570 :param str include_logos: When set to **true**, returns the logos associated with the brand. 5571 :return: BrandsResponse 5572 If the method is called asynchronously, 5573 returns the request thread. 5574 """ 5575 kwargs['_return_http_data_only'] = True 5576 if kwargs.get('callback'): 5577 return self.list_brands_with_http_info(account_id, **kwargs) 5578 else: 5579 (data) = self.list_brands_with_http_info(account_id, **kwargs) 5580 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)
5582 def list_brands_with_http_info(self, account_id, **kwargs): 5583 """ 5584 Gets a list of brand profiles. 5585 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. 5586 This method makes a synchronous HTTP request by default. To make an 5587 asynchronous HTTP request, please define a `callback` function 5588 to be invoked when receiving the response. 5589 >>> def callback_function(response): 5590 >>> pprint(response) 5591 >>> 5592 >>> thread = api.list_brands_with_http_info(account_id, callback=callback_function) 5593 5594 :param callback function: The callback function 5595 for asynchronous request. (optional) 5596 :param str account_id: The external account number (int) or account ID Guid. (required) 5597 :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set. 5598 :param str include_logos: When set to **true**, returns the logos associated with the brand. 5599 :return: BrandsResponse 5600 If the method is called asynchronously, 5601 returns the request thread. 5602 """ 5603 5604 all_params = ['account_id', 'exclude_distributor_brand', 'include_logos'] 5605 all_params.append('callback') 5606 all_params.append('_return_http_data_only') 5607 all_params.append('_preload_content') 5608 all_params.append('_request_timeout') 5609 5610 params = locals() 5611 for key, val in iteritems(params['kwargs']): 5612 if key not in all_params: 5613 raise TypeError( 5614 "Got an unexpected keyword argument '%s'" 5615 " to method list_brands" % key 5616 ) 5617 params[key] = val 5618 del params['kwargs'] 5619 # verify the required parameter 'account_id' is set 5620 if ('account_id' not in params) or (params['account_id'] is None): 5621 raise ValueError("Missing the required parameter `account_id` when calling `list_brands`") 5622 5623 5624 collection_formats = {} 5625 5626 resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json') 5627 path_params = {} 5628 if 'account_id' in params: 5629 path_params['accountId'] = params['account_id'] 5630 5631 query_params = {} 5632 if 'exclude_distributor_brand' in params: 5633 query_params['exclude_distributor_brand'] = params['exclude_distributor_brand'] 5634 if 'include_logos' in params: 5635 query_params['include_logos'] = params['include_logos'] 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='BrandsResponse', 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)
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)
5665 def list_custom_fields(self, account_id, **kwargs): 5666 """ 5667 Gets a list of custom fields associated with the account. 5668 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. 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_custom_fields(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 :return: CustomFields 5681 If the method is called asynchronously, 5682 returns the request thread. 5683 """ 5684 kwargs['_return_http_data_only'] = True 5685 if kwargs.get('callback'): 5686 return self.list_custom_fields_with_http_info(account_id, **kwargs) 5687 else: 5688 (data) = self.list_custom_fields_with_http_info(account_id, **kwargs) 5689 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)
5691 def list_custom_fields_with_http_info(self, account_id, **kwargs): 5692 """ 5693 Gets a list of custom fields associated with the account. 5694 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. 5695 This method makes a synchronous HTTP request by default. To make an 5696 asynchronous HTTP request, please define a `callback` function 5697 to be invoked when receiving the response. 5698 >>> def callback_function(response): 5699 >>> pprint(response) 5700 >>> 5701 >>> thread = api.list_custom_fields_with_http_info(account_id, callback=callback_function) 5702 5703 :param callback function: The callback function 5704 for asynchronous request. (optional) 5705 :param str account_id: The external account number (int) or account ID Guid. (required) 5706 :return: CustomFields 5707 If the method is called asynchronously, 5708 returns the request thread. 5709 """ 5710 5711 all_params = ['account_id'] 5712 all_params.append('callback') 5713 all_params.append('_return_http_data_only') 5714 all_params.append('_preload_content') 5715 all_params.append('_request_timeout') 5716 5717 params = locals() 5718 for key, val in iteritems(params['kwargs']): 5719 if key not in all_params: 5720 raise TypeError( 5721 "Got an unexpected keyword argument '%s'" 5722 " to method list_custom_fields" % key 5723 ) 5724 params[key] = val 5725 del params['kwargs'] 5726 # verify the required parameter 'account_id' is set 5727 if ('account_id' not in params) or (params['account_id'] is None): 5728 raise ValueError("Missing the required parameter `account_id` when calling `list_custom_fields`") 5729 5730 5731 collection_formats = {} 5732 5733 resource_path = '/v2.1/accounts/{accountId}/custom_fields'.replace('{format}', 'json') 5734 path_params = {} 5735 if 'account_id' in params: 5736 path_params['accountId'] = params['account_id'] 5737 5738 query_params = {} 5739 5740 header_params = {} 5741 5742 form_params = [] 5743 local_var_files = {} 5744 5745 body_params = None 5746 # HTTP header `Accept` 5747 header_params['Accept'] = self.api_client.\ 5748 select_header_accept(['application/json']) 5749 5750 # Authentication setting 5751 auth_settings = [] 5752 5753 return self.api_client.call_api(resource_path, 'GET', 5754 path_params, 5755 query_params, 5756 header_params, 5757 body=body_params, 5758 post_params=form_params, 5759 files=local_var_files, 5760 response_type='CustomFields', 5761 auth_settings=auth_settings, 5762 callback=params.get('callback'), 5763 _return_http_data_only=params.get('_return_http_data_only'), 5764 _preload_content=params.get('_preload_content', True), 5765 _request_timeout=params.get('_request_timeout'), 5766 collection_formats=collection_formats)
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)
5768 def list_permissions(self, account_id, **kwargs): 5769 """ 5770 Gets a list of permission profiles. 5771 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. 5772 This method makes a synchronous HTTP request by default. To make an 5773 asynchronous HTTP request, please define a `callback` function 5774 to be invoked when receiving the response. 5775 >>> def callback_function(response): 5776 >>> pprint(response) 5777 >>> 5778 >>> thread = api.list_permissions(account_id, callback=callback_function) 5779 5780 :param callback function: The callback function 5781 for asynchronous request. (optional) 5782 :param str account_id: The external account number (int) or account ID Guid. (required) 5783 :param str include: 5784 :return: PermissionProfileInformation 5785 If the method is called asynchronously, 5786 returns the request thread. 5787 """ 5788 kwargs['_return_http_data_only'] = True 5789 if kwargs.get('callback'): 5790 return self.list_permissions_with_http_info(account_id, **kwargs) 5791 else: 5792 (data) = self.list_permissions_with_http_info(account_id, **kwargs) 5793 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)
5795 def list_permissions_with_http_info(self, account_id, **kwargs): 5796 """ 5797 Gets a list of permission profiles. 5798 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. 5799 This method makes a synchronous HTTP request by default. To make an 5800 asynchronous HTTP request, please define a `callback` function 5801 to be invoked when receiving the response. 5802 >>> def callback_function(response): 5803 >>> pprint(response) 5804 >>> 5805 >>> thread = api.list_permissions_with_http_info(account_id, callback=callback_function) 5806 5807 :param callback function: The callback function 5808 for asynchronous request. (optional) 5809 :param str account_id: The external account number (int) or account ID Guid. (required) 5810 :param str include: 5811 :return: PermissionProfileInformation 5812 If the method is called asynchronously, 5813 returns the request thread. 5814 """ 5815 5816 all_params = ['account_id', 'include'] 5817 all_params.append('callback') 5818 all_params.append('_return_http_data_only') 5819 all_params.append('_preload_content') 5820 all_params.append('_request_timeout') 5821 5822 params = locals() 5823 for key, val in iteritems(params['kwargs']): 5824 if key not in all_params: 5825 raise TypeError( 5826 "Got an unexpected keyword argument '%s'" 5827 " to method list_permissions" % key 5828 ) 5829 params[key] = val 5830 del params['kwargs'] 5831 # verify the required parameter 'account_id' is set 5832 if ('account_id' not in params) or (params['account_id'] is None): 5833 raise ValueError("Missing the required parameter `account_id` when calling `list_permissions`") 5834 5835 5836 collection_formats = {} 5837 5838 resource_path = '/v2.1/accounts/{accountId}/permission_profiles'.replace('{format}', 'json') 5839 path_params = {} 5840 if 'account_id' in params: 5841 path_params['accountId'] = params['account_id'] 5842 5843 query_params = {} 5844 if 'include' in params: 5845 query_params['include'] = params['include'] 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='PermissionProfileInformation', 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)
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_settings(self, account_id, **kwargs)
5875 def list_settings(self, account_id, **kwargs): 5876 """ 5877 Gets account settings information. 5878 Retrieves the account settings information for the specified account. 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_settings(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 :return: AccountSettingsInformation 5891 If the method is called asynchronously, 5892 returns the request thread. 5893 """ 5894 kwargs['_return_http_data_only'] = True 5895 if kwargs.get('callback'): 5896 return self.list_settings_with_http_info(account_id, **kwargs) 5897 else: 5898 (data) = self.list_settings_with_http_info(account_id, **kwargs) 5899 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)
5901 def list_settings_with_http_info(self, account_id, **kwargs): 5902 """ 5903 Gets account settings information. 5904 Retrieves the account settings information for the specified account. 5905 This method makes a synchronous HTTP request by default. To make an 5906 asynchronous HTTP request, please define a `callback` function 5907 to be invoked when receiving the response. 5908 >>> def callback_function(response): 5909 >>> pprint(response) 5910 >>> 5911 >>> thread = api.list_settings_with_http_info(account_id, callback=callback_function) 5912 5913 :param callback function: The callback function 5914 for asynchronous request. (optional) 5915 :param str account_id: The external account number (int) or account ID Guid. (required) 5916 :return: AccountSettingsInformation 5917 If the method is called asynchronously, 5918 returns the request thread. 5919 """ 5920 5921 all_params = ['account_id'] 5922 all_params.append('callback') 5923 all_params.append('_return_http_data_only') 5924 all_params.append('_preload_content') 5925 all_params.append('_request_timeout') 5926 5927 params = locals() 5928 for key, val in iteritems(params['kwargs']): 5929 if key not in all_params: 5930 raise TypeError( 5931 "Got an unexpected keyword argument '%s'" 5932 " to method list_settings" % key 5933 ) 5934 params[key] = val 5935 del params['kwargs'] 5936 # verify the required parameter 'account_id' is set 5937 if ('account_id' not in params) or (params['account_id'] is None): 5938 raise ValueError("Missing the required parameter `account_id` when calling `list_settings`") 5939 5940 5941 collection_formats = {} 5942 5943 resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json') 5944 path_params = {} 5945 if 'account_id' in params: 5946 path_params['accountId'] = params['account_id'] 5947 5948 query_params = {} 5949 5950 header_params = {} 5951 5952 form_params = [] 5953 local_var_files = {} 5954 5955 body_params = None 5956 # HTTP header `Accept` 5957 header_params['Accept'] = self.api_client.\ 5958 select_header_accept(['application/json']) 5959 5960 # Authentication setting 5961 auth_settings = [] 5962 5963 return self.api_client.call_api(resource_path, 'GET', 5964 path_params, 5965 query_params, 5966 header_params, 5967 body=body_params, 5968 post_params=form_params, 5969 files=local_var_files, 5970 response_type='AccountSettingsInformation', 5971 auth_settings=auth_settings, 5972 callback=params.get('callback'), 5973 _return_http_data_only=params.get('_return_http_data_only'), 5974 _preload_content=params.get('_preload_content', True), 5975 _request_timeout=params.get('_request_timeout'), 5976 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)
6113 def list_signature_providers(self, account_id, **kwargs): 6114 """ 6115 Returns Account available signature providers for specified account. 6116 Returns a list of signature providers that the specified account can use. 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_signature_providers(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: AccountSignatureProviders 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_signature_providers_with_http_info(account_id, **kwargs) 6135 else: 6136 (data) = self.list_signature_providers_with_http_info(account_id, **kwargs) 6137 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)
6139 def list_signature_providers_with_http_info(self, account_id, **kwargs): 6140 """ 6141 Returns Account available signature providers for specified account. 6142 Returns a list of signature providers that the specified account can use. 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_signature_providers_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: AccountSignatureProviders 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_signature_providers" % 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_signature_providers`") 6177 6178 6179 collection_formats = {} 6180 6181 resource_path = '/v2.1/accounts/{accountId}/signatureProviders'.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='AccountSignatureProviders', 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)
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)
6216 def list_unsupported_file_types(self, account_id, **kwargs): 6217 """ 6218 Gets a list of unsupported file types. 6219 Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system. 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.list_unsupported_file_types(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 :return: FileTypeList 6232 If the method is called asynchronously, 6233 returns the request thread. 6234 """ 6235 kwargs['_return_http_data_only'] = True 6236 if kwargs.get('callback'): 6237 return self.list_unsupported_file_types_with_http_info(account_id, **kwargs) 6238 else: 6239 (data) = self.list_unsupported_file_types_with_http_info(account_id, **kwargs) 6240 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)
6242 def list_unsupported_file_types_with_http_info(self, account_id, **kwargs): 6243 """ 6244 Gets a list of unsupported file types. 6245 Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system. 6246 This method makes a synchronous HTTP request by default. To make an 6247 asynchronous HTTP request, please define a `callback` function 6248 to be invoked when receiving the response. 6249 >>> def callback_function(response): 6250 >>> pprint(response) 6251 >>> 6252 >>> thread = api.list_unsupported_file_types_with_http_info(account_id, callback=callback_function) 6253 6254 :param callback function: The callback function 6255 for asynchronous request. (optional) 6256 :param str account_id: The external account number (int) or account ID Guid. (required) 6257 :return: FileTypeList 6258 If the method is called asynchronously, 6259 returns the request thread. 6260 """ 6261 6262 all_params = ['account_id'] 6263 all_params.append('callback') 6264 all_params.append('_return_http_data_only') 6265 all_params.append('_preload_content') 6266 all_params.append('_request_timeout') 6267 6268 params = locals() 6269 for key, val in iteritems(params['kwargs']): 6270 if key not in all_params: 6271 raise TypeError( 6272 "Got an unexpected keyword argument '%s'" 6273 " to method list_unsupported_file_types" % key 6274 ) 6275 params[key] = val 6276 del params['kwargs'] 6277 # verify the required parameter 'account_id' is set 6278 if ('account_id' not in params) or (params['account_id'] is None): 6279 raise ValueError("Missing the required parameter `account_id` when calling `list_unsupported_file_types`") 6280 6281 6282 collection_formats = {} 6283 6284 resource_path = '/v2.1/accounts/{accountId}/unsupported_file_types'.replace('{format}', 'json') 6285 path_params = {} 6286 if 'account_id' in params: 6287 path_params['accountId'] = params['account_id'] 6288 6289 query_params = {} 6290 6291 header_params = {} 6292 6293 form_params = [] 6294 local_var_files = {} 6295 6296 body_params = None 6297 # HTTP header `Accept` 6298 header_params['Accept'] = self.api_client.\ 6299 select_header_accept(['application/json']) 6300 6301 # Authentication setting 6302 auth_settings = [] 6303 6304 return self.api_client.call_api(resource_path, 'GET', 6305 path_params, 6306 query_params, 6307 header_params, 6308 body=body_params, 6309 post_params=form_params, 6310 files=local_var_files, 6311 response_type='FileTypeList', 6312 auth_settings=auth_settings, 6313 callback=params.get('callback'), 6314 _return_http_data_only=params.get('_return_http_data_only'), 6315 _preload_content=params.get('_preload_content', True), 6316 _request_timeout=params.get('_request_timeout'), 6317 collection_formats=collection_formats)
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)
6319 def un_favorite_template(self, account_id, **kwargs): 6320 """ 6321 Unfavorite a template 6322 6323 This method makes a synchronous HTTP request by default. To make an 6324 asynchronous HTTP request, please define a `callback` function 6325 to be invoked when receiving the response. 6326 >>> def callback_function(response): 6327 >>> pprint(response) 6328 >>> 6329 >>> thread = api.un_favorite_template(account_id, callback=callback_function) 6330 6331 :param callback function: The callback function 6332 for asynchronous request. (optional) 6333 :param str account_id: The external account number (int) or account ID Guid. (required) 6334 :param FavoriteTemplatesInfo favorite_templates_info: 6335 :return: FavoriteTemplatesInfo 6336 If the method is called asynchronously, 6337 returns the request thread. 6338 """ 6339 kwargs['_return_http_data_only'] = True 6340 if kwargs.get('callback'): 6341 return self.un_favorite_template_with_http_info(account_id, **kwargs) 6342 else: 6343 (data) = self.un_favorite_template_with_http_info(account_id, **kwargs) 6344 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)
6346 def un_favorite_template_with_http_info(self, account_id, **kwargs): 6347 """ 6348 Unfavorite a template 6349 6350 This method makes a synchronous HTTP request by default. To make an 6351 asynchronous HTTP request, please define a `callback` function 6352 to be invoked when receiving the response. 6353 >>> def callback_function(response): 6354 >>> pprint(response) 6355 >>> 6356 >>> thread = api.un_favorite_template_with_http_info(account_id, callback=callback_function) 6357 6358 :param callback function: The callback function 6359 for asynchronous request. (optional) 6360 :param str account_id: The external account number (int) or account ID Guid. (required) 6361 :param FavoriteTemplatesInfo favorite_templates_info: 6362 :return: FavoriteTemplatesInfo 6363 If the method is called asynchronously, 6364 returns the request thread. 6365 """ 6366 6367 all_params = ['account_id', 'favorite_templates_info'] 6368 all_params.append('callback') 6369 all_params.append('_return_http_data_only') 6370 all_params.append('_preload_content') 6371 all_params.append('_request_timeout') 6372 6373 params = locals() 6374 for key, val in iteritems(params['kwargs']): 6375 if key not in all_params: 6376 raise TypeError( 6377 "Got an unexpected keyword argument '%s'" 6378 " to method un_favorite_template" % key 6379 ) 6380 params[key] = val 6381 del params['kwargs'] 6382 # verify the required parameter 'account_id' is set 6383 if ('account_id' not in params) or (params['account_id'] is None): 6384 raise ValueError("Missing the required parameter `account_id` when calling `un_favorite_template`") 6385 6386 6387 collection_formats = {} 6388 6389 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 6390 path_params = {} 6391 if 'account_id' in params: 6392 path_params['accountId'] = params['account_id'] 6393 6394 query_params = {} 6395 6396 header_params = {} 6397 6398 form_params = [] 6399 local_var_files = {} 6400 6401 body_params = None 6402 if 'favorite_templates_info' in params: 6403 body_params = params['favorite_templates_info'] 6404 # HTTP header `Accept` 6405 header_params['Accept'] = self.api_client.\ 6406 select_header_accept(['application/json']) 6407 6408 # Authentication setting 6409 auth_settings = [] 6410 6411 return self.api_client.call_api(resource_path, 'DELETE', 6412 path_params, 6413 query_params, 6414 header_params, 6415 body=body_params, 6416 post_params=form_params, 6417 files=local_var_files, 6418 response_type='FavoriteTemplatesInfo', 6419 auth_settings=auth_settings, 6420 callback=params.get('callback'), 6421 _return_http_data_only=params.get('_return_http_data_only'), 6422 _preload_content=params.get('_preload_content', True), 6423 _request_timeout=params.get('_request_timeout'), 6424 collection_formats=collection_formats)
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)
6426 def update_account_signature(self, account_id, **kwargs): 6427 """ 6428 Updates a account signature. 6429 6430 This method makes a synchronous HTTP request by default. To make an 6431 asynchronous HTTP request, please define a `callback` function 6432 to be invoked when receiving the response. 6433 >>> def callback_function(response): 6434 >>> pprint(response) 6435 >>> 6436 >>> thread = api.update_account_signature(account_id, callback=callback_function) 6437 6438 :param callback function: The callback function 6439 for asynchronous request. (optional) 6440 :param str account_id: The external account number (int) or account ID Guid. (required) 6441 :param AccountSignaturesInformation account_signatures_information: 6442 :return: AccountSignaturesInformation 6443 If the method is called asynchronously, 6444 returns the request thread. 6445 """ 6446 kwargs['_return_http_data_only'] = True 6447 if kwargs.get('callback'): 6448 return self.update_account_signature_with_http_info(account_id, **kwargs) 6449 else: 6450 (data) = self.update_account_signature_with_http_info(account_id, **kwargs) 6451 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)
6453 def update_account_signature_with_http_info(self, account_id, **kwargs): 6454 """ 6455 Updates a account signature. 6456 6457 This method makes a synchronous HTTP request by default. To make an 6458 asynchronous HTTP request, please define a `callback` function 6459 to be invoked when receiving the response. 6460 >>> def callback_function(response): 6461 >>> pprint(response) 6462 >>> 6463 >>> thread = api.update_account_signature_with_http_info(account_id, callback=callback_function) 6464 6465 :param callback function: The callback function 6466 for asynchronous request. (optional) 6467 :param str account_id: The external account number (int) or account ID Guid. (required) 6468 :param AccountSignaturesInformation account_signatures_information: 6469 :return: AccountSignaturesInformation 6470 If the method is called asynchronously, 6471 returns the request thread. 6472 """ 6473 6474 all_params = ['account_id', 'account_signatures_information'] 6475 all_params.append('callback') 6476 all_params.append('_return_http_data_only') 6477 all_params.append('_preload_content') 6478 all_params.append('_request_timeout') 6479 6480 params = locals() 6481 for key, val in iteritems(params['kwargs']): 6482 if key not in all_params: 6483 raise TypeError( 6484 "Got an unexpected keyword argument '%s'" 6485 " to method update_account_signature" % key 6486 ) 6487 params[key] = val 6488 del params['kwargs'] 6489 # verify the required parameter 'account_id' is set 6490 if ('account_id' not in params) or (params['account_id'] is None): 6491 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature`") 6492 6493 6494 collection_formats = {} 6495 6496 resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json') 6497 path_params = {} 6498 if 'account_id' in params: 6499 path_params['accountId'] = params['account_id'] 6500 6501 query_params = {} 6502 6503 header_params = {} 6504 6505 form_params = [] 6506 local_var_files = {} 6507 6508 body_params = None 6509 if 'account_signatures_information' in params: 6510 body_params = params['account_signatures_information'] 6511 # HTTP header `Accept` 6512 header_params['Accept'] = self.api_client.\ 6513 select_header_accept(['application/json']) 6514 6515 # Authentication setting 6516 auth_settings = [] 6517 6518 return self.api_client.call_api(resource_path, 'PUT', 6519 path_params, 6520 query_params, 6521 header_params, 6522 body=body_params, 6523 post_params=form_params, 6524 files=local_var_files, 6525 response_type='AccountSignaturesInformation', 6526 auth_settings=auth_settings, 6527 callback=params.get('callback'), 6528 _return_http_data_only=params.get('_return_http_data_only'), 6529 _preload_content=params.get('_preload_content', True), 6530 _request_timeout=params.get('_request_timeout'), 6531 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)
6533 def update_account_signature_by_id(self, account_id, signature_id, **kwargs): 6534 """ 6535 Updates a account signature. 6536 6537 This method makes a synchronous HTTP request by default. To make an 6538 asynchronous HTTP request, please define a `callback` function 6539 to be invoked when receiving the response. 6540 >>> def callback_function(response): 6541 >>> pprint(response) 6542 >>> 6543 >>> thread = api.update_account_signature_by_id(account_id, signature_id, callback=callback_function) 6544 6545 :param callback function: The callback function 6546 for asynchronous request. (optional) 6547 :param str account_id: The external account number (int) or account ID Guid. (required) 6548 :param str signature_id: The ID of the signature being accessed. (required) 6549 :param str close_existing_signature: 6550 :param AccountSignatureDefinition account_signature_definition: 6551 :return: AccountSignature 6552 If the method is called asynchronously, 6553 returns the request thread. 6554 """ 6555 kwargs['_return_http_data_only'] = True 6556 if kwargs.get('callback'): 6557 return self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs) 6558 else: 6559 (data) = self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs) 6560 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)
6562 def update_account_signature_by_id_with_http_info(self, account_id, signature_id, **kwargs): 6563 """ 6564 Updates a account signature. 6565 6566 This method makes a synchronous HTTP request by default. To make an 6567 asynchronous HTTP request, please define a `callback` function 6568 to be invoked when receiving the response. 6569 >>> def callback_function(response): 6570 >>> pprint(response) 6571 >>> 6572 >>> thread = api.update_account_signature_by_id_with_http_info(account_id, signature_id, callback=callback_function) 6573 6574 :param callback function: The callback function 6575 for asynchronous request. (optional) 6576 :param str account_id: The external account number (int) or account ID Guid. (required) 6577 :param str signature_id: The ID of the signature being accessed. (required) 6578 :param str close_existing_signature: 6579 :param AccountSignatureDefinition account_signature_definition: 6580 :return: AccountSignature 6581 If the method is called asynchronously, 6582 returns the request thread. 6583 """ 6584 6585 all_params = ['account_id', 'signature_id', 'close_existing_signature', 'account_signature_definition'] 6586 all_params.append('callback') 6587 all_params.append('_return_http_data_only') 6588 all_params.append('_preload_content') 6589 all_params.append('_request_timeout') 6590 6591 params = locals() 6592 for key, val in iteritems(params['kwargs']): 6593 if key not in all_params: 6594 raise TypeError( 6595 "Got an unexpected keyword argument '%s'" 6596 " to method update_account_signature_by_id" % key 6597 ) 6598 params[key] = val 6599 del params['kwargs'] 6600 # verify the required parameter 'account_id' is set 6601 if ('account_id' not in params) or (params['account_id'] is None): 6602 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_by_id`") 6603 # verify the required parameter 'signature_id' is set 6604 if ('signature_id' not in params) or (params['signature_id'] is None): 6605 raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_by_id`") 6606 6607 6608 collection_formats = {} 6609 6610 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 6611 path_params = {} 6612 if 'account_id' in params: 6613 path_params['accountId'] = params['account_id'] 6614 if 'signature_id' in params: 6615 path_params['signatureId'] = params['signature_id'] 6616 6617 query_params = {} 6618 if 'close_existing_signature' in params: 6619 query_params['close_existing_signature'] = params['close_existing_signature'] 6620 6621 header_params = {} 6622 6623 form_params = [] 6624 local_var_files = {} 6625 6626 body_params = None 6627 if 'account_signature_definition' in params: 6628 body_params = params['account_signature_definition'] 6629 # HTTP header `Accept` 6630 header_params['Accept'] = self.api_client.\ 6631 select_header_accept(['application/json']) 6632 6633 # Authentication setting 6634 auth_settings = [] 6635 6636 return self.api_client.call_api(resource_path, 'PUT', 6637 path_params, 6638 query_params, 6639 header_params, 6640 body=body_params, 6641 post_params=form_params, 6642 files=local_var_files, 6643 response_type='AccountSignature', 6644 auth_settings=auth_settings, 6645 callback=params.get('callback'), 6646 _return_http_data_only=params.get('_return_http_data_only'), 6647 _preload_content=params.get('_preload_content', True), 6648 _request_timeout=params.get('_request_timeout'), 6649 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)
6651 def update_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 6652 """ 6653 Sets a signature, initials, or stamps image. 6654 6655 This method makes a synchronous HTTP request by default. To make an 6656 asynchronous HTTP request, please define a `callback` function 6657 to be invoked when receiving the response. 6658 >>> def callback_function(response): 6659 >>> pprint(response) 6660 >>> 6661 >>> thread = api.update_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 6662 6663 :param callback function: The callback function 6664 for asynchronous request. (optional) 6665 :param str account_id: The external account number (int) or account ID Guid. (required) 6666 :param str image_type: One of **signature_image** or **initials_image**. (required) 6667 :param str signature_id: The ID of the signature being accessed. (required) 6668 :param str transparent_png: 6669 :return: AccountSignature 6670 If the method is called asynchronously, 6671 returns the request thread. 6672 """ 6673 kwargs['_return_http_data_only'] = True 6674 if kwargs.get('callback'): 6675 return self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 6676 else: 6677 (data) = self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 6678 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)
6680 def update_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 6681 """ 6682 Sets a signature, initials, or stamps image. 6683 6684 This method makes a synchronous HTTP request by default. To make an 6685 asynchronous HTTP request, please define a `callback` function 6686 to be invoked when receiving the response. 6687 >>> def callback_function(response): 6688 >>> pprint(response) 6689 >>> 6690 >>> thread = api.update_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 6691 6692 :param callback function: The callback function 6693 for asynchronous request. (optional) 6694 :param str account_id: The external account number (int) or account ID Guid. (required) 6695 :param str image_type: One of **signature_image** or **initials_image**. (required) 6696 :param str signature_id: The ID of the signature being accessed. (required) 6697 :param str transparent_png: 6698 :return: AccountSignature 6699 If the method is called asynchronously, 6700 returns the request thread. 6701 """ 6702 6703 all_params = ['account_id', 'image_type', 'signature_id', 'transparent_png'] 6704 all_params.append('callback') 6705 all_params.append('_return_http_data_only') 6706 all_params.append('_preload_content') 6707 all_params.append('_request_timeout') 6708 6709 params = locals() 6710 for key, val in iteritems(params['kwargs']): 6711 if key not in all_params: 6712 raise TypeError( 6713 "Got an unexpected keyword argument '%s'" 6714 " to method update_account_signature_image" % key 6715 ) 6716 params[key] = val 6717 del params['kwargs'] 6718 # verify the required parameter 'account_id' is set 6719 if ('account_id' not in params) or (params['account_id'] is None): 6720 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_image`") 6721 # verify the required parameter 'image_type' is set 6722 if ('image_type' not in params) or (params['image_type'] is None): 6723 raise ValueError("Missing the required parameter `image_type` when calling `update_account_signature_image`") 6724 # verify the required parameter 'signature_id' is set 6725 if ('signature_id' not in params) or (params['signature_id'] is None): 6726 raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_image`") 6727 6728 6729 collection_formats = {} 6730 6731 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 6732 path_params = {} 6733 if 'account_id' in params: 6734 path_params['accountId'] = params['account_id'] 6735 if 'image_type' in params: 6736 path_params['imageType'] = params['image_type'] 6737 if 'signature_id' in params: 6738 path_params['signatureId'] = params['signature_id'] 6739 6740 query_params = {} 6741 if 'transparent_png' in params: 6742 query_params['transparent_png'] = params['transparent_png'] 6743 6744 header_params = {} 6745 6746 form_params = [] 6747 local_var_files = {} 6748 6749 body_params = None 6750 # HTTP header `Accept` 6751 header_params['Accept'] = self.api_client.\ 6752 select_header_accept(['application/json']) 6753 6754 # HTTP header `Content-Type` 6755 header_params['Content-Type'] = self.api_client.\ 6756 select_header_content_type(['image/gif']) 6757 6758 # Authentication setting 6759 auth_settings = [] 6760 6761 return self.api_client.call_api(resource_path, 'PUT', 6762 path_params, 6763 query_params, 6764 header_params, 6765 body=body_params, 6766 post_params=form_params, 6767 files=local_var_files, 6768 response_type='AccountSignature', 6769 auth_settings=auth_settings, 6770 callback=params.get('callback'), 6771 _return_http_data_only=params.get('_return_http_data_only'), 6772 _preload_content=params.get('_preload_content', True), 6773 _request_timeout=params.get('_request_timeout'), 6774 collection_formats=collection_formats)
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)
6776 def update_account_tab_settings(self, account_id, **kwargs): 6777 """ 6778 Modifies tab settings for specified account 6779 This method modifies the tab types and tab functionality that is enabled for an account. 6780 This method makes a synchronous HTTP request by default. To make an 6781 asynchronous HTTP request, please define a `callback` function 6782 to be invoked when receiving the response. 6783 >>> def callback_function(response): 6784 >>> pprint(response) 6785 >>> 6786 >>> thread = api.update_account_tab_settings(account_id, callback=callback_function) 6787 6788 :param callback function: The callback function 6789 for asynchronous request. (optional) 6790 :param str account_id: The external account number (int) or account ID Guid. (required) 6791 :param TabAccountSettings tab_account_settings: 6792 :return: TabAccountSettings 6793 If the method is called asynchronously, 6794 returns the request thread. 6795 """ 6796 kwargs['_return_http_data_only'] = True 6797 if kwargs.get('callback'): 6798 return self.update_account_tab_settings_with_http_info(account_id, **kwargs) 6799 else: 6800 (data) = self.update_account_tab_settings_with_http_info(account_id, **kwargs) 6801 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)
6803 def update_account_tab_settings_with_http_info(self, account_id, **kwargs): 6804 """ 6805 Modifies tab settings for specified account 6806 This method modifies the tab types and tab functionality that is enabled for an account. 6807 This method makes a synchronous HTTP request by default. To make an 6808 asynchronous HTTP request, please define a `callback` function 6809 to be invoked when receiving the response. 6810 >>> def callback_function(response): 6811 >>> pprint(response) 6812 >>> 6813 >>> thread = api.update_account_tab_settings_with_http_info(account_id, callback=callback_function) 6814 6815 :param callback function: The callback function 6816 for asynchronous request. (optional) 6817 :param str account_id: The external account number (int) or account ID Guid. (required) 6818 :param TabAccountSettings tab_account_settings: 6819 :return: TabAccountSettings 6820 If the method is called asynchronously, 6821 returns the request thread. 6822 """ 6823 6824 all_params = ['account_id', 'tab_account_settings'] 6825 all_params.append('callback') 6826 all_params.append('_return_http_data_only') 6827 all_params.append('_preload_content') 6828 all_params.append('_request_timeout') 6829 6830 params = locals() 6831 for key, val in iteritems(params['kwargs']): 6832 if key not in all_params: 6833 raise TypeError( 6834 "Got an unexpected keyword argument '%s'" 6835 " to method update_account_tab_settings" % key 6836 ) 6837 params[key] = val 6838 del params['kwargs'] 6839 # verify the required parameter 'account_id' is set 6840 if ('account_id' not in params) or (params['account_id'] is None): 6841 raise ValueError("Missing the required parameter `account_id` when calling `update_account_tab_settings`") 6842 6843 6844 collection_formats = {} 6845 6846 resource_path = '/v2.1/accounts/{accountId}/settings/tabs'.replace('{format}', 'json') 6847 path_params = {} 6848 if 'account_id' in params: 6849 path_params['accountId'] = params['account_id'] 6850 6851 query_params = {} 6852 6853 header_params = {} 6854 6855 form_params = [] 6856 local_var_files = {} 6857 6858 body_params = None 6859 if 'tab_account_settings' in params: 6860 body_params = params['tab_account_settings'] 6861 # HTTP header `Accept` 6862 header_params['Accept'] = self.api_client.\ 6863 select_header_accept(['application/json']) 6864 6865 # Authentication setting 6866 auth_settings = [] 6867 6868 return self.api_client.call_api(resource_path, 'PUT', 6869 path_params, 6870 query_params, 6871 header_params, 6872 body=body_params, 6873 post_params=form_params, 6874 files=local_var_files, 6875 response_type='TabAccountSettings', 6876 auth_settings=auth_settings, 6877 callback=params.get('callback'), 6878 _return_http_data_only=params.get('_return_http_data_only'), 6879 _preload_content=params.get('_preload_content', True), 6880 _request_timeout=params.get('_request_timeout'), 6881 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)
6883 def update_brand(self, account_id, brand_id, **kwargs): 6884 """ 6885 Updates an existing brand. 6886 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**). 6887 This method makes a synchronous HTTP request by default. To make an 6888 asynchronous HTTP request, please define a `callback` function 6889 to be invoked when receiving the response. 6890 >>> def callback_function(response): 6891 >>> pprint(response) 6892 >>> 6893 >>> thread = api.update_brand(account_id, brand_id, callback=callback_function) 6894 6895 :param callback function: The callback function 6896 for asynchronous request. (optional) 6897 :param str account_id: The external account number (int) or account ID Guid. (required) 6898 :param str brand_id: The unique identifier of a brand. (required) 6899 :param str replace_brand: 6900 :param Brand brand: 6901 :return: Brand 6902 If the method is called asynchronously, 6903 returns the request thread. 6904 """ 6905 kwargs['_return_http_data_only'] = True 6906 if kwargs.get('callback'): 6907 return self.update_brand_with_http_info(account_id, brand_id, **kwargs) 6908 else: 6909 (data) = self.update_brand_with_http_info(account_id, brand_id, **kwargs) 6910 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)
6912 def update_brand_with_http_info(self, account_id, brand_id, **kwargs): 6913 """ 6914 Updates an existing brand. 6915 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**). 6916 This method makes a synchronous HTTP request by default. To make an 6917 asynchronous HTTP request, please define a `callback` function 6918 to be invoked when receiving the response. 6919 >>> def callback_function(response): 6920 >>> pprint(response) 6921 >>> 6922 >>> thread = api.update_brand_with_http_info(account_id, brand_id, callback=callback_function) 6923 6924 :param callback function: The callback function 6925 for asynchronous request. (optional) 6926 :param str account_id: The external account number (int) or account ID Guid. (required) 6927 :param str brand_id: The unique identifier of a brand. (required) 6928 :param str replace_brand: 6929 :param Brand brand: 6930 :return: Brand 6931 If the method is called asynchronously, 6932 returns the request thread. 6933 """ 6934 6935 all_params = ['account_id', 'brand_id', 'replace_brand', 'brand'] 6936 all_params.append('callback') 6937 all_params.append('_return_http_data_only') 6938 all_params.append('_preload_content') 6939 all_params.append('_request_timeout') 6940 6941 params = locals() 6942 for key, val in iteritems(params['kwargs']): 6943 if key not in all_params: 6944 raise TypeError( 6945 "Got an unexpected keyword argument '%s'" 6946 " to method update_brand" % key 6947 ) 6948 params[key] = val 6949 del params['kwargs'] 6950 # verify the required parameter 'account_id' is set 6951 if ('account_id' not in params) or (params['account_id'] is None): 6952 raise ValueError("Missing the required parameter `account_id` when calling `update_brand`") 6953 # verify the required parameter 'brand_id' is set 6954 if ('brand_id' not in params) or (params['brand_id'] is None): 6955 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand`") 6956 6957 6958 collection_formats = {} 6959 6960 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 6961 path_params = {} 6962 if 'account_id' in params: 6963 path_params['accountId'] = params['account_id'] 6964 if 'brand_id' in params: 6965 path_params['brandId'] = params['brand_id'] 6966 6967 query_params = {} 6968 if 'replace_brand' in params: 6969 query_params['replace_brand'] = params['replace_brand'] 6970 6971 header_params = {} 6972 6973 form_params = [] 6974 local_var_files = {} 6975 6976 body_params = None 6977 if 'brand' in params: 6978 body_params = params['brand'] 6979 # HTTP header `Accept` 6980 header_params['Accept'] = self.api_client.\ 6981 select_header_accept(['application/json']) 6982 6983 # Authentication setting 6984 auth_settings = [] 6985 6986 return self.api_client.call_api(resource_path, 'PUT', 6987 path_params, 6988 query_params, 6989 header_params, 6990 body=body_params, 6991 post_params=form_params, 6992 files=local_var_files, 6993 response_type='Brand', 6994 auth_settings=auth_settings, 6995 callback=params.get('callback'), 6996 _return_http_data_only=params.get('_return_http_data_only'), 6997 _preload_content=params.get('_preload_content', True), 6998 _request_timeout=params.get('_request_timeout'), 6999 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)
7001 def update_brand_logo_by_type(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs): 7002 """ 7003 Put one branding logo. 7004 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**). 7005 This method makes a synchronous HTTP request by default. To make an 7006 asynchronous HTTP request, please define a `callback` function 7007 to be invoked when receiving the response. 7008 >>> def callback_function(response): 7009 >>> pprint(response) 7010 >>> 7011 >>> thread = api.update_brand_logo_by_type(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function) 7012 7013 :param callback function: The callback function 7014 for asynchronous request. (optional) 7015 :param str account_id: The external account number (int) or account ID GUID. (required) 7016 :param str brand_id: The ID of the brand. (required) 7017 :param str logo_type: The type of logo. Valid values are: - `primary` - `secondary` - `email` (required) 7018 :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) 7019 :return: None 7020 If the method is called asynchronously, 7021 returns the request thread. 7022 """ 7023 kwargs['_return_http_data_only'] = True 7024 if kwargs.get('callback'): 7025 return self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs) 7026 else: 7027 (data) = self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs) 7028 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)
7030 def update_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs): 7031 """ 7032 Put one branding logo. 7033 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**). 7034 This method makes a synchronous HTTP request by default. To make an 7035 asynchronous HTTP request, please define a `callback` function 7036 to be invoked when receiving the response. 7037 >>> def callback_function(response): 7038 >>> pprint(response) 7039 >>> 7040 >>> thread = api.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function) 7041 7042 :param callback function: The callback function 7043 for asynchronous request. (optional) 7044 :param str account_id: The external account number (int) or account ID GUID. (required) 7045 :param str brand_id: The ID of the brand. (required) 7046 :param str logo_type: The type of logo. Valid values are: - `primary` - `secondary` - `email` (required) 7047 :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) 7048 :return: None 7049 If the method is called asynchronously, 7050 returns the request thread. 7051 """ 7052 7053 all_params = ['account_id', 'brand_id', 'logo_type', 'logo_file_bytes'] 7054 all_params.append('callback') 7055 all_params.append('_return_http_data_only') 7056 all_params.append('_preload_content') 7057 all_params.append('_request_timeout') 7058 7059 params = locals() 7060 for key, val in iteritems(params['kwargs']): 7061 if key not in all_params: 7062 raise TypeError( 7063 "Got an unexpected keyword argument '%s'" 7064 " to method update_brand_logo_by_type" % key 7065 ) 7066 params[key] = val 7067 del params['kwargs'] 7068 # verify the required parameter 'account_id' is set 7069 if ('account_id' not in params) or (params['account_id'] is None): 7070 raise ValueError("Missing the required parameter `account_id` when calling `update_brand_logo_by_type`") 7071 # verify the required parameter 'brand_id' is set 7072 if ('brand_id' not in params) or (params['brand_id'] is None): 7073 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_logo_by_type`") 7074 # verify the required parameter 'logo_type' is set 7075 if ('logo_type' not in params) or (params['logo_type'] is None): 7076 raise ValueError("Missing the required parameter `logo_type` when calling `update_brand_logo_by_type`") 7077 # verify the required parameter 'logo_file_bytes' is set 7078 if ('logo_file_bytes' not in params) or (params['logo_file_bytes'] is None): 7079 raise ValueError("Missing the required parameter `logo_file_bytes` when calling `update_brand_logo_by_type`") 7080 7081 7082 collection_formats = {} 7083 7084 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 7085 path_params = {} 7086 if 'account_id' in params: 7087 path_params['accountId'] = params['account_id'] 7088 if 'brand_id' in params: 7089 path_params['brandId'] = params['brand_id'] 7090 if 'logo_type' in params: 7091 path_params['logoType'] = params['logo_type'] 7092 7093 query_params = {} 7094 7095 header_params = {} 7096 7097 form_params = [] 7098 local_var_files = {} 7099 7100 body_params = None 7101 if 'logo_file_bytes' in params: 7102 body_params = params['logo_file_bytes'] 7103 # HTTP header `Accept` 7104 header_params['Accept'] = self.api_client.\ 7105 select_header_accept(['application/json']) 7106 7107 # HTTP header `Content-Type` 7108 header_params['Content-Type'] = self.api_client.\ 7109 select_header_content_type(['image/png']) 7110 7111 # Authentication setting 7112 auth_settings = [] 7113 7114 return self.api_client.call_api(resource_path, 'PUT', 7115 path_params, 7116 query_params, 7117 header_params, 7118 body=body_params, 7119 post_params=form_params, 7120 files=local_var_files, 7121 response_type=None, 7122 auth_settings=auth_settings, 7123 callback=params.get('callback'), 7124 _return_http_data_only=params.get('_return_http_data_only'), 7125 _preload_content=params.get('_preload_content', True), 7126 _request_timeout=params.get('_request_timeout'), 7127 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)
7129 def update_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, file_xml, **kwargs): 7130 """ 7131 Uploads a branding resource file. 7132 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. 7133 This method makes a synchronous HTTP request by default. To make an 7134 asynchronous HTTP request, please define a `callback` function 7135 to be invoked when receiving the response. 7136 >>> def callback_function(response): 7137 >>> pprint(response) 7138 >>> 7139 >>> thread = api.update_brand_resources_by_content_type(account_id, brand_id, resource_content_type, file_xml, callback=callback_function) 7140 7141 :param callback function: The callback function 7142 for asynchronous request. (optional) 7143 :param str account_id: The external account number (int) or account ID GUID. (required) 7144 :param str brand_id: The ID of the brand. (required) 7145 :param str resource_content_type: The type of brand resource file that you are updating. Valid values are: - `sending` - `signing` - `email` - `signing_captive` (required) 7146 :param file file_xml: Brand resource XML file. (required) 7147 :return: BrandResources 7148 If the method is called asynchronously, 7149 returns the request thread. 7150 """ 7151 kwargs['_return_http_data_only'] = True 7152 if kwargs.get('callback'): 7153 return self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs) 7154 else: 7155 (data) = self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs) 7156 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)
7158 def update_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, file_xml, **kwargs): 7159 """ 7160 Uploads a branding resource file. 7161 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. 7162 This method makes a synchronous HTTP request by default. To make an 7163 asynchronous HTTP request, please define a `callback` function 7164 to be invoked when receiving the response. 7165 >>> def callback_function(response): 7166 >>> pprint(response) 7167 >>> 7168 >>> thread = api.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, callback=callback_function) 7169 7170 :param callback function: The callback function 7171 for asynchronous request. (optional) 7172 :param str account_id: The external account number (int) or account ID GUID. (required) 7173 :param str brand_id: The ID of the brand. (required) 7174 :param str resource_content_type: The type of brand resource file that you are updating. Valid values are: - `sending` - `signing` - `email` - `signing_captive` (required) 7175 :param file file_xml: Brand resource XML file. (required) 7176 :return: BrandResources 7177 If the method is called asynchronously, 7178 returns the request thread. 7179 """ 7180 7181 all_params = ['account_id', 'brand_id', 'resource_content_type', 'file_xml'] 7182 all_params.append('callback') 7183 all_params.append('_return_http_data_only') 7184 all_params.append('_preload_content') 7185 all_params.append('_request_timeout') 7186 7187 params = locals() 7188 for key, val in iteritems(params['kwargs']): 7189 if key not in all_params: 7190 raise TypeError( 7191 "Got an unexpected keyword argument '%s'" 7192 " to method update_brand_resources_by_content_type" % key 7193 ) 7194 params[key] = val 7195 del params['kwargs'] 7196 # verify the required parameter 'account_id' is set 7197 if ('account_id' not in params) or (params['account_id'] is None): 7198 raise ValueError("Missing the required parameter `account_id` when calling `update_brand_resources_by_content_type`") 7199 # verify the required parameter 'brand_id' is set 7200 if ('brand_id' not in params) or (params['brand_id'] is None): 7201 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_resources_by_content_type`") 7202 # verify the required parameter 'resource_content_type' is set 7203 if ('resource_content_type' not in params) or (params['resource_content_type'] is None): 7204 raise ValueError("Missing the required parameter `resource_content_type` when calling `update_brand_resources_by_content_type`") 7205 # verify the required parameter 'file_xml' is set 7206 if ('file_xml' not in params) or (params['file_xml'] is None): 7207 raise ValueError("Missing the required parameter `file_xml` when calling `update_brand_resources_by_content_type`") 7208 7209 7210 collection_formats = {} 7211 7212 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources/{resourceContentType}'.replace('{format}', 'json') 7213 path_params = {} 7214 if 'account_id' in params: 7215 path_params['accountId'] = params['account_id'] 7216 if 'brand_id' in params: 7217 path_params['brandId'] = params['brand_id'] 7218 if 'resource_content_type' in params: 7219 path_params['resourceContentType'] = params['resource_content_type'] 7220 7221 query_params = {} 7222 7223 header_params = {} 7224 7225 form_params = [] 7226 local_var_files = {} 7227 if 'file_xml' in params: 7228 local_var_files['file.xml'] = params['file_xml'] 7229 7230 body_params = None 7231 # HTTP header `Accept` 7232 header_params['Accept'] = self.api_client.\ 7233 select_header_accept(['application/json']) 7234 7235 # HTTP header `Content-Type` 7236 header_params['Content-Type'] = self.api_client.\ 7237 select_header_content_type(['multipart/form-data']) 7238 7239 # Authentication setting 7240 auth_settings = [] 7241 7242 return self.api_client.call_api(resource_path, 'PUT', 7243 path_params, 7244 query_params, 7245 header_params, 7246 body=body_params, 7247 post_params=form_params, 7248 files=local_var_files, 7249 response_type='BrandResources', 7250 auth_settings=auth_settings, 7251 callback=params.get('callback'), 7252 _return_http_data_only=params.get('_return_http_data_only'), 7253 _preload_content=params.get('_preload_content', True), 7254 _request_timeout=params.get('_request_timeout'), 7255 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)
7257 def update_consumer_disclosure(self, account_id, lang_code, **kwargs): 7258 """ 7259 Update Consumer Disclosure. 7260 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. 7261 This method makes a synchronous HTTP request by default. To make an 7262 asynchronous HTTP request, please define a `callback` function 7263 to be invoked when receiving the response. 7264 >>> def callback_function(response): 7265 >>> pprint(response) 7266 >>> 7267 >>> thread = api.update_consumer_disclosure(account_id, lang_code, callback=callback_function) 7268 7269 :param callback function: The callback function 7270 for asynchronous request. (optional) 7271 :param str account_id: The external account number (int) or account ID Guid. (required) 7272 :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) 7273 :param str include_metadata: 7274 :param ConsumerDisclosure consumer_disclosure: 7275 :return: ConsumerDisclosure 7276 If the method is called asynchronously, 7277 returns the request thread. 7278 """ 7279 kwargs['_return_http_data_only'] = True 7280 if kwargs.get('callback'): 7281 return self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 7282 else: 7283 (data) = self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 7284 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)
7286 def update_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs): 7287 """ 7288 Update Consumer Disclosure. 7289 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. 7290 This method makes a synchronous HTTP request by default. To make an 7291 asynchronous HTTP request, please define a `callback` function 7292 to be invoked when receiving the response. 7293 >>> def callback_function(response): 7294 >>> pprint(response) 7295 >>> 7296 >>> thread = api.update_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function) 7297 7298 :param callback function: The callback function 7299 for asynchronous request. (optional) 7300 :param str account_id: The external account number (int) or account ID Guid. (required) 7301 :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) 7302 :param str include_metadata: 7303 :param ConsumerDisclosure consumer_disclosure: 7304 :return: ConsumerDisclosure 7305 If the method is called asynchronously, 7306 returns the request thread. 7307 """ 7308 7309 all_params = ['account_id', 'lang_code', 'include_metadata', 'consumer_disclosure'] 7310 all_params.append('callback') 7311 all_params.append('_return_http_data_only') 7312 all_params.append('_preload_content') 7313 all_params.append('_request_timeout') 7314 7315 params = locals() 7316 for key, val in iteritems(params['kwargs']): 7317 if key not in all_params: 7318 raise TypeError( 7319 "Got an unexpected keyword argument '%s'" 7320 " to method update_consumer_disclosure" % key 7321 ) 7322 params[key] = val 7323 del params['kwargs'] 7324 # verify the required parameter 'account_id' is set 7325 if ('account_id' not in params) or (params['account_id'] is None): 7326 raise ValueError("Missing the required parameter `account_id` when calling `update_consumer_disclosure`") 7327 # verify the required parameter 'lang_code' is set 7328 if ('lang_code' not in params) or (params['lang_code'] is None): 7329 raise ValueError("Missing the required parameter `lang_code` when calling `update_consumer_disclosure`") 7330 7331 7332 collection_formats = {} 7333 7334 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 7335 path_params = {} 7336 if 'account_id' in params: 7337 path_params['accountId'] = params['account_id'] 7338 if 'lang_code' in params: 7339 path_params['langCode'] = params['lang_code'] 7340 7341 query_params = {} 7342 if 'include_metadata' in params: 7343 query_params['include_metadata'] = params['include_metadata'] 7344 7345 header_params = {} 7346 7347 form_params = [] 7348 local_var_files = {} 7349 7350 body_params = None 7351 if 'consumer_disclosure' in params: 7352 body_params = params['consumer_disclosure'] 7353 # HTTP header `Accept` 7354 header_params['Accept'] = self.api_client.\ 7355 select_header_accept(['application/json']) 7356 7357 # Authentication setting 7358 auth_settings = [] 7359 7360 return self.api_client.call_api(resource_path, 'PUT', 7361 path_params, 7362 query_params, 7363 header_params, 7364 body=body_params, 7365 post_params=form_params, 7366 files=local_var_files, 7367 response_type='ConsumerDisclosure', 7368 auth_settings=auth_settings, 7369 callback=params.get('callback'), 7370 _return_http_data_only=params.get('_return_http_data_only'), 7371 _preload_content=params.get('_preload_content', True), 7372 _request_timeout=params.get('_request_timeout'), 7373 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)
7375 def update_custom_field(self, account_id, custom_field_id, **kwargs): 7376 """ 7377 Updates an existing account custom field. 7378 This method updates an existing account custom field. 7379 This method makes a synchronous HTTP request by default. To make an 7380 asynchronous HTTP request, please define a `callback` function 7381 to be invoked when receiving the response. 7382 >>> def callback_function(response): 7383 >>> pprint(response) 7384 >>> 7385 >>> thread = api.update_custom_field(account_id, custom_field_id, callback=callback_function) 7386 7387 :param callback function: The callback function 7388 for asynchronous request. (optional) 7389 :param str account_id: The external account number (int) or account ID Guid. (required) 7390 :param str custom_field_id: (required) 7391 :param str apply_to_templates: 7392 :param CustomField custom_field: 7393 :return: CustomFields 7394 If the method is called asynchronously, 7395 returns the request thread. 7396 """ 7397 kwargs['_return_http_data_only'] = True 7398 if kwargs.get('callback'): 7399 return self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 7400 else: 7401 (data) = self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 7402 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)
7404 def update_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs): 7405 """ 7406 Updates an existing account custom field. 7407 This method updates an existing account custom field. 7408 This method makes a synchronous HTTP request by default. To make an 7409 asynchronous HTTP request, please define a `callback` function 7410 to be invoked when receiving the response. 7411 >>> def callback_function(response): 7412 >>> pprint(response) 7413 >>> 7414 >>> thread = api.update_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function) 7415 7416 :param callback function: The callback function 7417 for asynchronous request. (optional) 7418 :param str account_id: The external account number (int) or account ID Guid. (required) 7419 :param str custom_field_id: (required) 7420 :param str apply_to_templates: 7421 :param CustomField custom_field: 7422 :return: CustomFields 7423 If the method is called asynchronously, 7424 returns the request thread. 7425 """ 7426 7427 all_params = ['account_id', 'custom_field_id', 'apply_to_templates', 'custom_field'] 7428 all_params.append('callback') 7429 all_params.append('_return_http_data_only') 7430 all_params.append('_preload_content') 7431 all_params.append('_request_timeout') 7432 7433 params = locals() 7434 for key, val in iteritems(params['kwargs']): 7435 if key not in all_params: 7436 raise TypeError( 7437 "Got an unexpected keyword argument '%s'" 7438 " to method update_custom_field" % key 7439 ) 7440 params[key] = val 7441 del params['kwargs'] 7442 # verify the required parameter 'account_id' is set 7443 if ('account_id' not in params) or (params['account_id'] is None): 7444 raise ValueError("Missing the required parameter `account_id` when calling `update_custom_field`") 7445 # verify the required parameter 'custom_field_id' is set 7446 if ('custom_field_id' not in params) or (params['custom_field_id'] is None): 7447 raise ValueError("Missing the required parameter `custom_field_id` when calling `update_custom_field`") 7448 7449 7450 collection_formats = {} 7451 7452 resource_path = '/v2.1/accounts/{accountId}/custom_fields/{customFieldId}'.replace('{format}', 'json') 7453 path_params = {} 7454 if 'account_id' in params: 7455 path_params['accountId'] = params['account_id'] 7456 if 'custom_field_id' in params: 7457 path_params['customFieldId'] = params['custom_field_id'] 7458 7459 query_params = {} 7460 if 'apply_to_templates' in params: 7461 query_params['apply_to_templates'] = params['apply_to_templates'] 7462 7463 header_params = {} 7464 7465 form_params = [] 7466 local_var_files = {} 7467 7468 body_params = None 7469 if 'custom_field' in params: 7470 body_params = params['custom_field'] 7471 # HTTP header `Accept` 7472 header_params['Accept'] = self.api_client.\ 7473 select_header_accept(['application/json']) 7474 7475 # Authentication setting 7476 auth_settings = [] 7477 7478 return self.api_client.call_api(resource_path, 'PUT', 7479 path_params, 7480 query_params, 7481 header_params, 7482 body=body_params, 7483 post_params=form_params, 7484 files=local_var_files, 7485 response_type='CustomFields', 7486 auth_settings=auth_settings, 7487 callback=params.get('callback'), 7488 _return_http_data_only=params.get('_return_http_data_only'), 7489 _preload_content=params.get('_preload_content', True), 7490 _request_timeout=params.get('_request_timeout'), 7491 collection_formats=collection_formats)
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)
7493 def update_e_note_configuration(self, account_id, **kwargs): 7494 """ 7495 Updates configuration information for the eNote eOriginal integration. 7496 7497 This method makes a synchronous HTTP request by default. To make an 7498 asynchronous HTTP request, please define a `callback` function 7499 to be invoked when receiving the response. 7500 >>> def callback_function(response): 7501 >>> pprint(response) 7502 >>> 7503 >>> thread = api.update_e_note_configuration(account_id, callback=callback_function) 7504 7505 :param callback function: The callback function 7506 for asynchronous request. (optional) 7507 :param str account_id: The external account number (int) or account ID Guid. (required) 7508 :param ENoteConfiguration e_note_configuration: 7509 :return: ENoteConfiguration 7510 If the method is called asynchronously, 7511 returns the request thread. 7512 """ 7513 kwargs['_return_http_data_only'] = True 7514 if kwargs.get('callback'): 7515 return self.update_e_note_configuration_with_http_info(account_id, **kwargs) 7516 else: 7517 (data) = self.update_e_note_configuration_with_http_info(account_id, **kwargs) 7518 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)
7520 def update_e_note_configuration_with_http_info(self, account_id, **kwargs): 7521 """ 7522 Updates configuration information for the eNote eOriginal integration. 7523 7524 This method makes a synchronous HTTP request by default. To make an 7525 asynchronous HTTP request, please define a `callback` function 7526 to be invoked when receiving the response. 7527 >>> def callback_function(response): 7528 >>> pprint(response) 7529 >>> 7530 >>> thread = api.update_e_note_configuration_with_http_info(account_id, callback=callback_function) 7531 7532 :param callback function: The callback function 7533 for asynchronous request. (optional) 7534 :param str account_id: The external account number (int) or account ID Guid. (required) 7535 :param ENoteConfiguration e_note_configuration: 7536 :return: ENoteConfiguration 7537 If the method is called asynchronously, 7538 returns the request thread. 7539 """ 7540 7541 all_params = ['account_id', 'e_note_configuration'] 7542 all_params.append('callback') 7543 all_params.append('_return_http_data_only') 7544 all_params.append('_preload_content') 7545 all_params.append('_request_timeout') 7546 7547 params = locals() 7548 for key, val in iteritems(params['kwargs']): 7549 if key not in all_params: 7550 raise TypeError( 7551 "Got an unexpected keyword argument '%s'" 7552 " to method update_e_note_configuration" % key 7553 ) 7554 params[key] = val 7555 del params['kwargs'] 7556 # verify the required parameter 'account_id' is set 7557 if ('account_id' not in params) or (params['account_id'] is None): 7558 raise ValueError("Missing the required parameter `account_id` when calling `update_e_note_configuration`") 7559 7560 7561 collection_formats = {} 7562 7563 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 7564 path_params = {} 7565 if 'account_id' in params: 7566 path_params['accountId'] = params['account_id'] 7567 7568 query_params = {} 7569 7570 header_params = {} 7571 7572 form_params = [] 7573 local_var_files = {} 7574 7575 body_params = None 7576 if 'e_note_configuration' in params: 7577 body_params = params['e_note_configuration'] 7578 # HTTP header `Accept` 7579 header_params['Accept'] = self.api_client.\ 7580 select_header_accept(['application/json']) 7581 7582 # Authentication setting 7583 auth_settings = [] 7584 7585 return self.api_client.call_api(resource_path, 'PUT', 7586 path_params, 7587 query_params, 7588 header_params, 7589 body=body_params, 7590 post_params=form_params, 7591 files=local_var_files, 7592 response_type='ENoteConfiguration', 7593 auth_settings=auth_settings, 7594 callback=params.get('callback'), 7595 _return_http_data_only=params.get('_return_http_data_only'), 7596 _preload_content=params.get('_preload_content', True), 7597 _request_timeout=params.get('_request_timeout'), 7598 collection_formats=collection_formats)
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)
7600 def update_envelope_purge_configuration(self, account_id, **kwargs): 7601 """ 7602 Updates envelope purge configuration. 7603 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). 7604 This method makes a synchronous HTTP request by default. To make an 7605 asynchronous HTTP request, please define a `callback` function 7606 to be invoked when receiving the response. 7607 >>> def callback_function(response): 7608 >>> pprint(response) 7609 >>> 7610 >>> thread = api.update_envelope_purge_configuration(account_id, callback=callback_function) 7611 7612 :param callback function: The callback function 7613 for asynchronous request. (optional) 7614 :param str account_id: The external account number (int) or account ID Guid. (required) 7615 :param EnvelopePurgeConfiguration envelope_purge_configuration: 7616 :return: EnvelopePurgeConfiguration 7617 If the method is called asynchronously, 7618 returns the request thread. 7619 """ 7620 kwargs['_return_http_data_only'] = True 7621 if kwargs.get('callback'): 7622 return self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs) 7623 else: 7624 (data) = self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs) 7625 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)
7627 def update_envelope_purge_configuration_with_http_info(self, account_id, **kwargs): 7628 """ 7629 Updates envelope purge configuration. 7630 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). 7631 This method makes a synchronous HTTP request by default. To make an 7632 asynchronous HTTP request, please define a `callback` function 7633 to be invoked when receiving the response. 7634 >>> def callback_function(response): 7635 >>> pprint(response) 7636 >>> 7637 >>> thread = api.update_envelope_purge_configuration_with_http_info(account_id, callback=callback_function) 7638 7639 :param callback function: The callback function 7640 for asynchronous request. (optional) 7641 :param str account_id: The external account number (int) or account ID Guid. (required) 7642 :param EnvelopePurgeConfiguration envelope_purge_configuration: 7643 :return: EnvelopePurgeConfiguration 7644 If the method is called asynchronously, 7645 returns the request thread. 7646 """ 7647 7648 all_params = ['account_id', 'envelope_purge_configuration'] 7649 all_params.append('callback') 7650 all_params.append('_return_http_data_only') 7651 all_params.append('_preload_content') 7652 all_params.append('_request_timeout') 7653 7654 params = locals() 7655 for key, val in iteritems(params['kwargs']): 7656 if key not in all_params: 7657 raise TypeError( 7658 "Got an unexpected keyword argument '%s'" 7659 " to method update_envelope_purge_configuration" % key 7660 ) 7661 params[key] = val 7662 del params['kwargs'] 7663 # verify the required parameter 'account_id' is set 7664 if ('account_id' not in params) or (params['account_id'] is None): 7665 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_purge_configuration`") 7666 7667 7668 collection_formats = {} 7669 7670 resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json') 7671 path_params = {} 7672 if 'account_id' in params: 7673 path_params['accountId'] = params['account_id'] 7674 7675 query_params = {} 7676 7677 header_params = {} 7678 7679 form_params = [] 7680 local_var_files = {} 7681 7682 body_params = None 7683 if 'envelope_purge_configuration' in params: 7684 body_params = params['envelope_purge_configuration'] 7685 # HTTP header `Accept` 7686 header_params['Accept'] = self.api_client.\ 7687 select_header_accept(['application/json']) 7688 7689 # Authentication setting 7690 auth_settings = [] 7691 7692 return self.api_client.call_api(resource_path, 'PUT', 7693 path_params, 7694 query_params, 7695 header_params, 7696 body=body_params, 7697 post_params=form_params, 7698 files=local_var_files, 7699 response_type='EnvelopePurgeConfiguration', 7700 auth_settings=auth_settings, 7701 callback=params.get('callback'), 7702 _return_http_data_only=params.get('_return_http_data_only'), 7703 _preload_content=params.get('_preload_content', True), 7704 _request_timeout=params.get('_request_timeout'), 7705 collection_formats=collection_formats)
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)
7707 def update_favorite_template(self, account_id, **kwargs): 7708 """ 7709 Favorites a template 7710 7711 This method makes a synchronous HTTP request by default. To make an 7712 asynchronous HTTP request, please define a `callback` function 7713 to be invoked when receiving the response. 7714 >>> def callback_function(response): 7715 >>> pprint(response) 7716 >>> 7717 >>> thread = api.update_favorite_template(account_id, callback=callback_function) 7718 7719 :param callback function: The callback function 7720 for asynchronous request. (optional) 7721 :param str account_id: The external account number (int) or account ID Guid. (required) 7722 :param FavoriteTemplatesInfo favorite_templates_info: 7723 :return: FavoriteTemplatesInfo 7724 If the method is called asynchronously, 7725 returns the request thread. 7726 """ 7727 kwargs['_return_http_data_only'] = True 7728 if kwargs.get('callback'): 7729 return self.update_favorite_template_with_http_info(account_id, **kwargs) 7730 else: 7731 (data) = self.update_favorite_template_with_http_info(account_id, **kwargs) 7732 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)
7734 def update_favorite_template_with_http_info(self, account_id, **kwargs): 7735 """ 7736 Favorites a template 7737 7738 This method makes a synchronous HTTP request by default. To make an 7739 asynchronous HTTP request, please define a `callback` function 7740 to be invoked when receiving the response. 7741 >>> def callback_function(response): 7742 >>> pprint(response) 7743 >>> 7744 >>> thread = api.update_favorite_template_with_http_info(account_id, callback=callback_function) 7745 7746 :param callback function: The callback function 7747 for asynchronous request. (optional) 7748 :param str account_id: The external account number (int) or account ID Guid. (required) 7749 :param FavoriteTemplatesInfo favorite_templates_info: 7750 :return: FavoriteTemplatesInfo 7751 If the method is called asynchronously, 7752 returns the request thread. 7753 """ 7754 7755 all_params = ['account_id', 'favorite_templates_info'] 7756 all_params.append('callback') 7757 all_params.append('_return_http_data_only') 7758 all_params.append('_preload_content') 7759 all_params.append('_request_timeout') 7760 7761 params = locals() 7762 for key, val in iteritems(params['kwargs']): 7763 if key not in all_params: 7764 raise TypeError( 7765 "Got an unexpected keyword argument '%s'" 7766 " to method update_favorite_template" % key 7767 ) 7768 params[key] = val 7769 del params['kwargs'] 7770 # verify the required parameter 'account_id' is set 7771 if ('account_id' not in params) or (params['account_id'] is None): 7772 raise ValueError("Missing the required parameter `account_id` when calling `update_favorite_template`") 7773 7774 7775 collection_formats = {} 7776 7777 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 7778 path_params = {} 7779 if 'account_id' in params: 7780 path_params['accountId'] = params['account_id'] 7781 7782 query_params = {} 7783 7784 header_params = {} 7785 7786 form_params = [] 7787 local_var_files = {} 7788 7789 body_params = None 7790 if 'favorite_templates_info' in params: 7791 body_params = params['favorite_templates_info'] 7792 # HTTP header `Accept` 7793 header_params['Accept'] = self.api_client.\ 7794 select_header_accept(['application/json']) 7795 7796 # Authentication setting 7797 auth_settings = [] 7798 7799 return self.api_client.call_api(resource_path, 'PUT', 7800 path_params, 7801 query_params, 7802 header_params, 7803 body=body_params, 7804 post_params=form_params, 7805 files=local_var_files, 7806 response_type='FavoriteTemplatesInfo', 7807 auth_settings=auth_settings, 7808 callback=params.get('callback'), 7809 _return_http_data_only=params.get('_return_http_data_only'), 7810 _preload_content=params.get('_preload_content', True), 7811 _request_timeout=params.get('_request_timeout'), 7812 collection_formats=collection_formats)
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)
7814 def update_notification_defaults(self, account_id, **kwargs): 7815 """ 7816 Updates default user level settings for a specified account 7817 This method changes the default settings for the email notifications that signers and senders receive about envelopes. 7818 This method makes a synchronous HTTP request by default. To make an 7819 asynchronous HTTP request, please define a `callback` function 7820 to be invoked when receiving the response. 7821 >>> def callback_function(response): 7822 >>> pprint(response) 7823 >>> 7824 >>> thread = api.update_notification_defaults(account_id, callback=callback_function) 7825 7826 :param callback function: The callback function 7827 for asynchronous request. (optional) 7828 :param str account_id: The external account number (int) or account ID Guid. (required) 7829 :param NotificationDefaults notification_defaults: 7830 :return: NotificationDefaults 7831 If the method is called asynchronously, 7832 returns the request thread. 7833 """ 7834 kwargs['_return_http_data_only'] = True 7835 if kwargs.get('callback'): 7836 return self.update_notification_defaults_with_http_info(account_id, **kwargs) 7837 else: 7838 (data) = self.update_notification_defaults_with_http_info(account_id, **kwargs) 7839 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)
7841 def update_notification_defaults_with_http_info(self, account_id, **kwargs): 7842 """ 7843 Updates default user level settings for a specified account 7844 This method changes the default settings for the email notifications that signers and senders receive about envelopes. 7845 This method makes a synchronous HTTP request by default. To make an 7846 asynchronous HTTP request, please define a `callback` function 7847 to be invoked when receiving the response. 7848 >>> def callback_function(response): 7849 >>> pprint(response) 7850 >>> 7851 >>> thread = api.update_notification_defaults_with_http_info(account_id, callback=callback_function) 7852 7853 :param callback function: The callback function 7854 for asynchronous request. (optional) 7855 :param str account_id: The external account number (int) or account ID Guid. (required) 7856 :param NotificationDefaults notification_defaults: 7857 :return: NotificationDefaults 7858 If the method is called asynchronously, 7859 returns the request thread. 7860 """ 7861 7862 all_params = ['account_id', 'notification_defaults'] 7863 all_params.append('callback') 7864 all_params.append('_return_http_data_only') 7865 all_params.append('_preload_content') 7866 all_params.append('_request_timeout') 7867 7868 params = locals() 7869 for key, val in iteritems(params['kwargs']): 7870 if key not in all_params: 7871 raise TypeError( 7872 "Got an unexpected keyword argument '%s'" 7873 " to method update_notification_defaults" % key 7874 ) 7875 params[key] = val 7876 del params['kwargs'] 7877 # verify the required parameter 'account_id' is set 7878 if ('account_id' not in params) or (params['account_id'] is None): 7879 raise ValueError("Missing the required parameter `account_id` when calling `update_notification_defaults`") 7880 7881 7882 collection_formats = {} 7883 7884 resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json') 7885 path_params = {} 7886 if 'account_id' in params: 7887 path_params['accountId'] = params['account_id'] 7888 7889 query_params = {} 7890 7891 header_params = {} 7892 7893 form_params = [] 7894 local_var_files = {} 7895 7896 body_params = None 7897 if 'notification_defaults' in params: 7898 body_params = params['notification_defaults'] 7899 # HTTP header `Accept` 7900 header_params['Accept'] = self.api_client.\ 7901 select_header_accept(['application/json']) 7902 7903 # Authentication setting 7904 auth_settings = [] 7905 7906 return self.api_client.call_api(resource_path, 'PUT', 7907 path_params, 7908 query_params, 7909 header_params, 7910 body=body_params, 7911 post_params=form_params, 7912 files=local_var_files, 7913 response_type='NotificationDefaults', 7914 auth_settings=auth_settings, 7915 callback=params.get('callback'), 7916 _return_http_data_only=params.get('_return_http_data_only'), 7917 _preload_content=params.get('_preload_content', True), 7918 _request_timeout=params.get('_request_timeout'), 7919 collection_formats=collection_formats)
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)
7921 def update_password_rules(self, account_id, **kwargs): 7922 """ 7923 Update the password rules 7924 This method updates the password rules for an account. **Note:** To update the password rules for an account, you must be an account administrator. 7925 This method makes a synchronous HTTP request by default. To make an 7926 asynchronous HTTP request, please define a `callback` function 7927 to be invoked when receiving the response. 7928 >>> def callback_function(response): 7929 >>> pprint(response) 7930 >>> 7931 >>> thread = api.update_password_rules(account_id, callback=callback_function) 7932 7933 :param callback function: The callback function 7934 for asynchronous request. (optional) 7935 :param str account_id: The external account number (int) or account ID Guid. (required) 7936 :param AccountPasswordRules account_password_rules: 7937 :return: AccountPasswordRules 7938 If the method is called asynchronously, 7939 returns the request thread. 7940 """ 7941 kwargs['_return_http_data_only'] = True 7942 if kwargs.get('callback'): 7943 return self.update_password_rules_with_http_info(account_id, **kwargs) 7944 else: 7945 (data) = self.update_password_rules_with_http_info(account_id, **kwargs) 7946 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)
7948 def update_password_rules_with_http_info(self, account_id, **kwargs): 7949 """ 7950 Update the password rules 7951 This method updates the password rules for an account. **Note:** To update the password rules for an account, you must be an account administrator. 7952 This method makes a synchronous HTTP request by default. To make an 7953 asynchronous HTTP request, please define a `callback` function 7954 to be invoked when receiving the response. 7955 >>> def callback_function(response): 7956 >>> pprint(response) 7957 >>> 7958 >>> thread = api.update_password_rules_with_http_info(account_id, callback=callback_function) 7959 7960 :param callback function: The callback function 7961 for asynchronous request. (optional) 7962 :param str account_id: The external account number (int) or account ID Guid. (required) 7963 :param AccountPasswordRules account_password_rules: 7964 :return: AccountPasswordRules 7965 If the method is called asynchronously, 7966 returns the request thread. 7967 """ 7968 7969 all_params = ['account_id', 'account_password_rules'] 7970 all_params.append('callback') 7971 all_params.append('_return_http_data_only') 7972 all_params.append('_preload_content') 7973 all_params.append('_request_timeout') 7974 7975 params = locals() 7976 for key, val in iteritems(params['kwargs']): 7977 if key not in all_params: 7978 raise TypeError( 7979 "Got an unexpected keyword argument '%s'" 7980 " to method update_password_rules" % key 7981 ) 7982 params[key] = val 7983 del params['kwargs'] 7984 # verify the required parameter 'account_id' is set 7985 if ('account_id' not in params) or (params['account_id'] is None): 7986 raise ValueError("Missing the required parameter `account_id` when calling `update_password_rules`") 7987 7988 7989 collection_formats = {} 7990 7991 resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json') 7992 path_params = {} 7993 if 'account_id' in params: 7994 path_params['accountId'] = params['account_id'] 7995 7996 query_params = {} 7997 7998 header_params = {} 7999 8000 form_params = [] 8001 local_var_files = {} 8002 8003 body_params = None 8004 if 'account_password_rules' in params: 8005 body_params = params['account_password_rules'] 8006 # HTTP header `Accept` 8007 header_params['Accept'] = self.api_client.\ 8008 select_header_accept(['application/json']) 8009 8010 # Authentication setting 8011 auth_settings = [] 8012 8013 return self.api_client.call_api(resource_path, 'PUT', 8014 path_params, 8015 query_params, 8016 header_params, 8017 body=body_params, 8018 post_params=form_params, 8019 files=local_var_files, 8020 response_type='AccountPasswordRules', 8021 auth_settings=auth_settings, 8022 callback=params.get('callback'), 8023 _return_http_data_only=params.get('_return_http_data_only'), 8024 _preload_content=params.get('_preload_content', True), 8025 _request_timeout=params.get('_request_timeout'), 8026 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)
8028 def update_permission_profile(self, account_id, permission_profile_id, **kwargs): 8029 """ 8030 Updates a permission profile within the specified account. 8031 This method updates an account permission profile. ### Related topics - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 8032 This method makes a synchronous HTTP request by default. To make an 8033 asynchronous HTTP request, please define a `callback` function 8034 to be invoked when receiving the response. 8035 >>> def callback_function(response): 8036 >>> pprint(response) 8037 >>> 8038 >>> thread = api.update_permission_profile(account_id, permission_profile_id, callback=callback_function) 8039 8040 :param callback function: The callback function 8041 for asynchronous request. (optional) 8042 :param str account_id: The external account number (int) or account ID Guid. (required) 8043 :param str permission_profile_id: (required) 8044 :param str include: 8045 :param PermissionProfile permission_profile: 8046 :return: PermissionProfile 8047 If the method is called asynchronously, 8048 returns the request thread. 8049 """ 8050 kwargs['_return_http_data_only'] = True 8051 if kwargs.get('callback'): 8052 return self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 8053 else: 8054 (data) = self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 8055 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)
8057 def update_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 8058 """ 8059 Updates a permission profile within the specified account. 8060 This method updates an account permission profile. ### Related topics - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 8061 This method makes a synchronous HTTP request by default. To make an 8062 asynchronous HTTP request, please define a `callback` function 8063 to be invoked when receiving the response. 8064 >>> def callback_function(response): 8065 >>> pprint(response) 8066 >>> 8067 >>> thread = api.update_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 8068 8069 :param callback function: The callback function 8070 for asynchronous request. (optional) 8071 :param str account_id: The external account number (int) or account ID Guid. (required) 8072 :param str permission_profile_id: (required) 8073 :param str include: 8074 :param PermissionProfile permission_profile: 8075 :return: PermissionProfile 8076 If the method is called asynchronously, 8077 returns the request thread. 8078 """ 8079 8080 all_params = ['account_id', 'permission_profile_id', 'include', 'permission_profile'] 8081 all_params.append('callback') 8082 all_params.append('_return_http_data_only') 8083 all_params.append('_preload_content') 8084 all_params.append('_request_timeout') 8085 8086 params = locals() 8087 for key, val in iteritems(params['kwargs']): 8088 if key not in all_params: 8089 raise TypeError( 8090 "Got an unexpected keyword argument '%s'" 8091 " to method update_permission_profile" % key 8092 ) 8093 params[key] = val 8094 del params['kwargs'] 8095 # verify the required parameter 'account_id' is set 8096 if ('account_id' not in params) or (params['account_id'] is None): 8097 raise ValueError("Missing the required parameter `account_id` when calling `update_permission_profile`") 8098 # verify the required parameter 'permission_profile_id' is set 8099 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 8100 raise ValueError("Missing the required parameter `permission_profile_id` when calling `update_permission_profile`") 8101 8102 8103 collection_formats = {} 8104 8105 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 8106 path_params = {} 8107 if 'account_id' in params: 8108 path_params['accountId'] = params['account_id'] 8109 if 'permission_profile_id' in params: 8110 path_params['permissionProfileId'] = params['permission_profile_id'] 8111 8112 query_params = {} 8113 if 'include' in params: 8114 query_params['include'] = params['include'] 8115 8116 header_params = {} 8117 8118 form_params = [] 8119 local_var_files = {} 8120 8121 body_params = None 8122 if 'permission_profile' in params: 8123 body_params = params['permission_profile'] 8124 # HTTP header `Accept` 8125 header_params['Accept'] = self.api_client.\ 8126 select_header_accept(['application/json']) 8127 8128 # Authentication setting 8129 auth_settings = [] 8130 8131 return self.api_client.call_api(resource_path, 'PUT', 8132 path_params, 8133 query_params, 8134 header_params, 8135 body=body_params, 8136 post_params=form_params, 8137 files=local_var_files, 8138 response_type='PermissionProfile', 8139 auth_settings=auth_settings, 8140 callback=params.get('callback'), 8141 _return_http_data_only=params.get('_return_http_data_only'), 8142 _preload_content=params.get('_preload_content', True), 8143 _request_timeout=params.get('_request_timeout'), 8144 collection_formats=collection_formats)
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)
8146 def update_settings(self, account_id, **kwargs): 8147 """ 8148 Updates the account settings for an account. 8149 Updates the account settings for the specified account. 8150 This method makes a synchronous HTTP request by default. To make an 8151 asynchronous HTTP request, please define a `callback` function 8152 to be invoked when receiving the response. 8153 >>> def callback_function(response): 8154 >>> pprint(response) 8155 >>> 8156 >>> thread = api.update_settings(account_id, callback=callback_function) 8157 8158 :param callback function: The callback function 8159 for asynchronous request. (optional) 8160 :param str account_id: The external account number (int) or account ID Guid. (required) 8161 :param AccountSettingsInformation account_settings_information: 8162 :return: None 8163 If the method is called asynchronously, 8164 returns the request thread. 8165 """ 8166 kwargs['_return_http_data_only'] = True 8167 if kwargs.get('callback'): 8168 return self.update_settings_with_http_info(account_id, **kwargs) 8169 else: 8170 (data) = self.update_settings_with_http_info(account_id, **kwargs) 8171 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)
8173 def update_settings_with_http_info(self, account_id, **kwargs): 8174 """ 8175 Updates the account settings for an account. 8176 Updates the account settings for the specified account. 8177 This method makes a synchronous HTTP request by default. To make an 8178 asynchronous HTTP request, please define a `callback` function 8179 to be invoked when receiving the response. 8180 >>> def callback_function(response): 8181 >>> pprint(response) 8182 >>> 8183 >>> thread = api.update_settings_with_http_info(account_id, callback=callback_function) 8184 8185 :param callback function: The callback function 8186 for asynchronous request. (optional) 8187 :param str account_id: The external account number (int) or account ID Guid. (required) 8188 :param AccountSettingsInformation account_settings_information: 8189 :return: None 8190 If the method is called asynchronously, 8191 returns the request thread. 8192 """ 8193 8194 all_params = ['account_id', 'account_settings_information'] 8195 all_params.append('callback') 8196 all_params.append('_return_http_data_only') 8197 all_params.append('_preload_content') 8198 all_params.append('_request_timeout') 8199 8200 params = locals() 8201 for key, val in iteritems(params['kwargs']): 8202 if key not in all_params: 8203 raise TypeError( 8204 "Got an unexpected keyword argument '%s'" 8205 " to method update_settings" % key 8206 ) 8207 params[key] = val 8208 del params['kwargs'] 8209 # verify the required parameter 'account_id' is set 8210 if ('account_id' not in params) or (params['account_id'] is None): 8211 raise ValueError("Missing the required parameter `account_id` when calling `update_settings`") 8212 8213 8214 collection_formats = {} 8215 8216 resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json') 8217 path_params = {} 8218 if 'account_id' in params: 8219 path_params['accountId'] = params['account_id'] 8220 8221 query_params = {} 8222 8223 header_params = {} 8224 8225 form_params = [] 8226 local_var_files = {} 8227 8228 body_params = None 8229 if 'account_settings_information' in params: 8230 body_params = params['account_settings_information'] 8231 # HTTP header `Accept` 8232 header_params['Accept'] = self.api_client.\ 8233 select_header_accept(['application/json']) 8234 8235 # Authentication setting 8236 auth_settings = [] 8237 8238 return self.api_client.call_api(resource_path, 'PUT', 8239 path_params, 8240 query_params, 8241 header_params, 8242 body=body_params, 8243 post_params=form_params, 8244 files=local_var_files, 8245 response_type=None, 8246 auth_settings=auth_settings, 8247 callback=params.get('callback'), 8248 _return_http_data_only=params.get('_return_http_data_only'), 8249 _preload_content=params.get('_preload_content', True), 8250 _request_timeout=params.get('_request_timeout'), 8251 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)
8491 def update_watermark(self, account_id, **kwargs): 8492 """ 8493 Update watermark information. 8494 8495 This method makes a synchronous HTTP request by default. To make an 8496 asynchronous HTTP request, please define a `callback` function 8497 to be invoked when receiving the response. 8498 >>> def callback_function(response): 8499 >>> pprint(response) 8500 >>> 8501 >>> thread = api.update_watermark(account_id, callback=callback_function) 8502 8503 :param callback function: The callback function 8504 for asynchronous request. (optional) 8505 :param str account_id: The external account number (int) or account ID Guid. (required) 8506 :param Watermark watermark: 8507 :return: Watermark 8508 If the method is called asynchronously, 8509 returns the request thread. 8510 """ 8511 kwargs['_return_http_data_only'] = True 8512 if kwargs.get('callback'): 8513 return self.update_watermark_with_http_info(account_id, **kwargs) 8514 else: 8515 (data) = self.update_watermark_with_http_info(account_id, **kwargs) 8516 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)
8518 def update_watermark_with_http_info(self, account_id, **kwargs): 8519 """ 8520 Update watermark information. 8521 8522 This method makes a synchronous HTTP request by default. To make an 8523 asynchronous HTTP request, please define a `callback` function 8524 to be invoked when receiving the response. 8525 >>> def callback_function(response): 8526 >>> pprint(response) 8527 >>> 8528 >>> thread = api.update_watermark_with_http_info(account_id, callback=callback_function) 8529 8530 :param callback function: The callback function 8531 for asynchronous request. (optional) 8532 :param str account_id: The external account number (int) or account ID Guid. (required) 8533 :param Watermark watermark: 8534 :return: Watermark 8535 If the method is called asynchronously, 8536 returns the request thread. 8537 """ 8538 8539 all_params = ['account_id', 'watermark'] 8540 all_params.append('callback') 8541 all_params.append('_return_http_data_only') 8542 all_params.append('_preload_content') 8543 all_params.append('_request_timeout') 8544 8545 params = locals() 8546 for key, val in iteritems(params['kwargs']): 8547 if key not in all_params: 8548 raise TypeError( 8549 "Got an unexpected keyword argument '%s'" 8550 " to method update_watermark" % key 8551 ) 8552 params[key] = val 8553 del params['kwargs'] 8554 # verify the required parameter 'account_id' is set 8555 if ('account_id' not in params) or (params['account_id'] is None): 8556 raise ValueError("Missing the required parameter `account_id` when calling `update_watermark`") 8557 8558 8559 collection_formats = {} 8560 8561 resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json') 8562 path_params = {} 8563 if 'account_id' in params: 8564 path_params['accountId'] = params['account_id'] 8565 8566 query_params = {} 8567 8568 header_params = {} 8569 8570 form_params = [] 8571 local_var_files = {} 8572 8573 body_params = None 8574 if 'watermark' in params: 8575 body_params = params['watermark'] 8576 # HTTP header `Accept` 8577 header_params['Accept'] = self.api_client.\ 8578 select_header_accept(['application/json']) 8579 8580 # Authentication setting 8581 auth_settings = [] 8582 8583 return self.api_client.call_api(resource_path, 'PUT', 8584 path_params, 8585 query_params, 8586 header_params, 8587 body=body_params, 8588 post_params=form_params, 8589 files=local_var_files, 8590 response_type='Watermark', 8591 auth_settings=auth_settings, 8592 callback=params.get('callback'), 8593 _return_http_data_only=params.get('_return_http_data_only'), 8594 _preload_content=params.get('_preload_content', True), 8595 _request_timeout=params.get('_request_timeout'), 8596 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.